Editing 3696 - taxa

== Enunt ==

Miruna se pregăteşte de vacanţa de vară. Ea a hotărât deja că împreună cu un grup de colegi să facă o excursie în regatul INFO unde moneda locală se numeşte BOSS. A studiat deja harta acestei zone şi a aflat multe lucruri interesante. Ea ştie că regatul se află pe o insula cu suprafaţa uscatului sub forma dreptunghiulară ce poate fi reprezentată ca o matrice cu N linii şi M coloane în care fiecare element este un cod pentru un tip de obiectiv turistic ce poate fi vizitat. Deoarece sosirea şi plecarea de pe insulă se face cu avionul, ea cunoaşte poziția (l0,c0) unde va fi debarcată şi poziţia (lf,cf) unde va fi plecarea de pe insulă. Ea se poate deplasa pentru vizitarea obiectivelor turistice doar în celule vecine pe cele opt direcţii (N, S, E, V, NE, NV, SE, SV), iar dacă nouă poziţie are alt cod decât cel din care venise la pasul precedent, atunci trebuie să plătească o taxa de vizitare egală cu produsul codurilor celor doua zone (exprimată tot în moneda locală, BOSS!!!). Miruna ar dori să afle care ar fi suma minimă necesară pentru a se deplasa până la locul de plecare de pe insulă.

== Cerinta ==

Dându-se configuraţia regatului şi poziţiile de plecare şi sosire, să se determine suma minimă necesară deplasării.

== Date de intrare ==

Pe prima linie a fişierului taxa.in se află valorile naturale N, M, l0, c0, lf, cf. Pe următoarele N linii se află câte M elemente, codurile fiecărei zone, numere naturale separate prin câte un spaţiu.

== Date de ieșire ==

Fișierul de ieșire taxa.out va conține un număr natural B, reprezentând suma minimă necesară deplasării.

== Restrictii si precizari ==

*0 < N, M < 1001
*Obiectivele au coduri numere naturale nenule mai mici sau egale cu 5, iar poziţia inițială şi finală sunt distincte
*Pentru 30% din teste vom avea N, M ≤ 100
*Pentru 20% din teste matricea conţine numai două valori.

== Exemplul 1 ==

;taxain.txt

:5 5 1 1 4 5

:1 1 2 2 2

:1 2 3 3 3

:1 1 3 3 3

:2 2 2 2 2

:1 1 1 2 1

;taxaout.txt

:Datele introduse corespund restrictiilor impuse.

:2

== Exemplul 2 ==

;taxain.txt

:86 453 53 4

:-3 32 0 -3

:22 9 323 43

:12 94 732 43

:-2 -3 -34 -4

:12 32  43 65

;taxaout.txt

:Datele de intrare nu corespund restrictiilor impuse.

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">

import heapq

def suma_minima_deplasare(regat, sosire, plecare):
    N = len(regat)
    M = len(regat[0])

    # Pasul 1: Construirea grafului
    graf = construieste_graf(regat, N, M)

    # Pasul 2: Calculul drumului minim
    suma_minima = dijkstra(graf, sosire, plecare)

    return suma_minima

def construieste_graf(regat, N, M):
    graf = {}

    for i in range(N):
        for j in range(M):
            cod_curent = regat[i][j]
            nod_curent = (i, j)

            if nod_curent not in graf:
                graf[nod_curent] = {}

            vecini = get_vecini(N, M, i, j)
            for vecin in vecini:
                i_vecin, j_vecin = vecin
                cod_vecin = regat[i_vecin][j_vecin]
                cost = cod_curent * cod_vecin
                nod_vecin = (i_vecin, j_vecin)

                if nod_vecin not in graf[nod_curent]:
                    graf[nod_curent][nod_vecin] = cost

    return graf

def get_vecini(N, M, i, j):
    vecini = []

    for di in [-1, 0, 1]:
        for dj in [-1, 0, 1]:
            if di == 0 and dj == 0:
                continue

            i_vecin, j_vecin = i + di, j + dj
            if 0 <= i_vecin < N and 0 <= j_vecin < M:
                vecini.append((i_vecin, j_vecin))

    return vecini

def dijkstra(graf, sosire, plecare):
    distante = {nod: float('inf') for nod in graf}
    distante[sosire] = 0

    heap = [(0, sosire)]

    while heap:
        cost_curent, nod_curent = heapq.heappop(heap)

        if cost_curent > distante[nod_curent]:
            continue

        for vecin, cost in graf[nod_curent].items():
            cost_total = cost_curent + cost

            if cost_total < distante[vecin]:
                distante[vecin] = cost_total
                heapq.heappush(heap, (cost_total, vecin))

    return distante[plecare]

rezultat = suma_minima_deplasare(regat, sosire, plecare)
print(rezultat)

</syntaxhighlight>