1189 - Lenes

Leneşul este un animal foarte leneş. El se deplasează numai în linie dreaptă, dar face din când în când câte un popas. În această problemă leneşul trebuie să traverseze de la nord la sud şi înapoi un teren reprezentat de o matrice de dimensiuni M×N cu valori numere naturale. Valorile reprezintă efortul cerut pentru traversarea zonei respective. Leneşul va alege o coloană pentru traversarea matricei, iar pentru popasuri, în număr de k1, va alege zone alăturate drumului din coloana din stânga sau cea din dreapta. În cazul în care se va întoarce va proceda la fel, dar va face k2 popasuri. Regulile problemei cer ca cele două drumuri să nu aibă zone comune.

Cerințe

Cunoscând dimensiunile M, N ale terenului, numărul de popasuri k1, k2 și efortul pentru traversarea fiecărei zone a terenului, să se determine:

1. Efortul minim de parcurgere a terenului de la Nord la Sud, folosind k1 popasuri.
2. Efortul minim de parcurgere a terenului de la Nord la Sud și înapoi de la Sud la Nord, folosind k1 popasuri la deplasarea Nord – Sud, respectiv k2 popasuri la deplasarea Sud – Nord.

Date de intrare

Fișierul de intrare lenes.in conține:

• Pe prima linie un număr natural p reprezentând cerința de rezolvare. Pentru toate testele de intrare numărul p poate avea doar valoarea 1 sau 2.
• Pe linia a doua sunt 4 numere naturale M, N, k1, k2, separate prin câte un spațiu cu semnificaţia de mai sus.
• Pe următoarele M linii se găsesc câte N numere naturale separate prin câte un spațiu, reprezentând eforturile de traversare a fiecărei zone a terenului.

Date de ieșire

Dacă valoarea lui p este 1, se va rezolva numai cerința 1. În acest caz fişierul lenes.out va conţine un singur număr natural reprezentând efortul minim necesar pentru traversarea terenului în condiţiile date de la Nord la Sud.

Dacă valoarea lui p este 2, se va rezolva numai cerința 2. În acest caz fişierul lenes.out va conţine un singur număr natural reprezentând efortul minim necesar pentru traversarea terenului în condiţiile date în ambele sensuri de la Nord la Sud și de la Sud la Nord.

Restricții și precizări

• 3 ≤ M, N ≤ 500
• 0 ≤ k1, k2 ≤ M
• Valorile din matrice sunt numere naturale din intervalul [1, 1000].
• Leneșul poate să facă popasuri pe aceeaşi linie în ambele celule din stânga şi din dreapta coloanei parcurse.
• Deplasarea între ultima zonă a drumului parcurs de la Nord la Sud şi prima zonă a drumului parcurs de la Sud la Nord la întoarcere se face cu efort 0.

Exemplul 1

lenes.in

1
4 7 2 3
99 1 33 9 2 4 7
99 1 44 8 1 2 3
98 1 55 8 2 3 2
97 1 66 4 3 2 1

lenes.out

12

Explicație

p = 1

Leneșul traversează terenul de la Nord la Sud pe coloana a 5-a cu popas în zonele (2, 6) și (4, 6).

Atenție! Pentru acest test se rezolvă doar cerința 1.

Exemplul 2

lenes.in

2
4 7 3 2
99 1 33 9 2 4 7
99 1 44 8 1 2 3
98 1 55 8 2 2 2
97 1 66 4 3 2 1

lenes.out

35

Explicație

p = 2

Leneșul traversează terenul de la Nord la Sud pe coloana a 7-a cu popasuri în zonele (3, 6), (1, 6), (4, 6), iar de la Sud la Nord pe coloana a 5 – a, cu popas în zonele (4, 4) și (2, 6).

Atenție! Pentru acest test se rezolvă doar cerința 2.

import numpy as np

def min_effort_nord_sud(matrix, k1):
    M, N = len(matrix), len(matrix[0])
    inf = float('inf')
    
    # dp[c][r][p]: efort minim pentru a ajunge la (c, r) cu p popasuri rămase
    dp = np.full((M, N, k1 + 1), inf)
    
    # Inițializare
    for r in range(N):
        dp[0][r][k1] = matrix[0][r]
    
    for c in range(1, M):
        for r in range(N):
            for p in range(k1 + 1):
                # Deplasare pe coloana curentă
                if dp[c-1][r][p] < inf:
                    dp[c][r][p] = min(dp[c][r][p], dp[c-1][r][p] + matrix[c][r])
                
                # Popasuri (stânga/dreapta)
                if r > 0 and p > 0:
                    dp[c][r][p-1] = min(dp[c][r][p-1], dp[c-1][r-1][p] + matrix[c][r])
                if r < N - 1 and p > 0:
                    dp[c][r][p-1] = min(dp[c][r][p-1], dp[c-1][r+1][p] + matrix[c][r])
    
    return min(dp[M-1][r][0] for r in range(N))

def min_effort_nord_sud_sud_nord(matrix, k1, k2):
    M, N = len(matrix), len(matrix[0])
    inf = float('inf')
    
    # Minim efort Nord-Sud
    min_effort_nord_sud_val = min_effort_nord_sud(matrix, k1)
    
    # Inversăm matricea pentru Sud-Nord
    matrix_reversed = matrix[::-1]
    
    # Minim efort Sud-Nord
    min_effort_sud_nord_val = min_effort_nord_sud(matrix_reversed, k2)
    
    return min_effort_nord_sud_val + min_effort_sud_nord_val

# Exemple de utilizare
M, N = 4, 5
k1 = 2
k2 = 1
matrix = [
    [2, 4, 1, 8, 3],
    [6, 3, 2, 5, 1],
    [5, 2, 6, 7, 9],
    [8, 4, 2, 1, 5]
]

# Efort minim pentru traversarea Nord-Sud
effort_nord_sud = min_effort_nord_sud(matrix, k1)
print(f"Efort minim pentru traversarea Nord-Sud: {effort_nord_sud}")

# Efort minim pentru traversarea Nord-Sud și Sud-Nord
effort_nord_sud_sud_nord = min_effort_nord_sud_sud_nord(matrix, k1, k2)
print(f"Efort minim pentru traversarea Nord-Sud și Sud-Nord: {effort_nord_sud_sud_nord}")