0593 - Parc

Cerința

Parcul orașului este alcătuit din n intersecții, numerotate de la 1 la n, unite între ele prin m alei bidirecționale, fiecare având o anumita lungime. Într-o intersecție precizată C se organizează un concert; de asemenea, unele intersecții, precizate și ele, reprezintă porți de intrare în parc, accesul fiind posibil doar prin aceste porți.

Gigel poate ajunge cu mașina la oricare dintre aceste porți, dar vă roagă să alegeți pentru el acea poartă pentru care distanța până la intersecția C este minimă. Dacă există mai multe porți cu această proprietate se va determina poarta cu numărul de ordine mai mic.

Date de intrare

Fișierul de intrare parcIN.txt conține pe prima linie numerele n m C; următoarele m linii câte un triplet i j L, cu semnificația: există alee între intersecția i și intersecția j și are lungimea L. Următoarea linie conține numărul de porți P; ultima linie conține P numere diferite, reprezentând porțile.

Date de ieșire

Fișierul de ieșire parcOUT.txt va conține pe prima linie numărul de ordine al porții alese.

Restricții și precizări

• 1 ≤ n ≤ 100
• lungimea unei alei va fi mai mică decât 1000
• între oricare două intersecții există drum, direct sau prin intermediul altor intersecții În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

Exemplul 1:

parcIN.txt

7 8 2
1 2 4
1 5 1
1 7 2
2 3 9
2 4 2
2 6 2
2 7 1
5 6 7
2
3 5

parcOUt.txt

5

Exemplul 2:

parcIN.txt

0 8 2
1 2 4
1 5 1
1 7 2
2 3 9
2 4 2
2 6 2
2 7 1
5 6 7
2
3 5

parcOUt.txt

Datele nu corespund restrictiilor impuse

Rezolvare

import heapq
import sys

MAX = 100

def citire_date():
    with open('parcIN.txt', 'r') as fin:
        n, m, C = map(int, fin.readline().strip().split())
        muchii = [dict() for _ in range(MAX + 1)]
        lungimi = [dict() for _ in range(MAX + 1)]
        for _ in range(m):
            i, j, L = map(int, fin.readline().strip().split())
            muchii[i][j] = muchii[j][i] = True
            lungimi[i][j] = lungimi[j][i] = L
        P = int(fin.readline().strip())
        p_list = list(map(int, fin.readline().strip().split()))
    return n, m, C, muchii, lungimi, P, p_list

def validare_restrictii(n, m, lungimi):
    if not (1 <= n <= 100):
        return False
    for nod in range(1, n+1):
        for lungime in lungimi[nod].values():
            if lungime >= 1000:
                return False
    return True

def dijkstra(n, muchii, lungimi, start):
    lenMin = [float('inf')] * (n + 1)
    lenMin[start] = 0
    heap = [(0, start)]
    while heap:
        current_len, node = heapq.heappop(heap)
        if current_len > lenMin[node]:
            continue
        for neighbor in muchii[node]:
            length = current_len + lungimi[node][neighbor]
            if length < lenMin[neighbor]:
                lenMin[neighbor] = length
                heapq.heappush(heap, (length, neighbor))
    return lenMin

def main():
    n, m, C, muchii, lungimi, P, p_list = citire_date()
    if not validare_restrictii(n, m, lungimi):
        with open('parcOUT.txt', 'w') as fout:
            fout.write("Datele nu corespund restrictiilor impuse")
        return

    lenMinP = float('inf')
    pMin = -1
    for p in p_list:
        lenMin = dijkstra(n, muchii, lungimi, p)
        if lenMin[C] < lenMinP:
            lenMinP = lenMin[C]
            pMin = p

    with open('parcOUT.txt', 'w') as fout:
        fout.write(str(pMin))

if __name__ == "__main__":
    main()