2461 - V

Se consideră un tablou bidimensional cu m linii şi n coloane. Se numeşte traseu în V o parcurgere prin elementele tabloului astfel:

• se pleacă întotdeauna dintr-un element de pe prima linie a tabloului, se ajunge în final într-un alt element de pe prima linie a tabloului, trecând prin cel puţin 3 elemente, fără a trece printr-un element de mai multe ori;
• parcurgerea elementelor tabloului se face în forma unei singure litere V ca în desen, dintr-un element putându-se trece doar într-un alt element imediat vecin pe diagonală.

Fiecare element al tabloului conţine valori întregi. La parcurgerea traseului se calculează suma elementelor de pe traseu.

Cerința

Determinaţi traseul în V care are suma maximă. În cazul în care există mai multe trasee de sumă maximă, se va alege traseul care parcurge cele mai puţine elemente. Dacă şi în acest caz există mai multe soluţii, se alege traseul cel mai din stânga (cel cu indicele coloanei de pornire cel mai mic).

Date de intrare

Din fişierul de intrare v.in se citesc de pe prima linie valorile naturale m şi n, separate printr-un spaţiu, reprezentând numărul de linii şi numărul de coloane ale tabloului. Pe următoarele m linii se află câte n valori întregi separate prin spaţii, reprezentând elementele tabloului.

Date de ieșire

Fişierul de ieşire v.out va conţine o singură linie pe care vor fi scrise trei valori naturale S C L, reprezentând suma maximă, coloana de pornire şi respectiv linia pe care se află vârful V-ului traseului determinat.

Restricții și precizări

• 1 ≤ m, n ≤ 1500
• -60000 ≤ valorile elementelor tabloului ≤ 60000
• Pentru datele de test suma valorilor din elementele oricărui traseu va fi între -2 000 000 000 şi 2 000 000 000 .
• Pentru 50% din teste 1 ≤ m, n ≤ 101
• Pentru 70% din teste 1 ≤ m, n ≤ 1000
• Nota: Această problemă conține restricții și teste îmbunătățite

Exemplu:

v.in

5 9
3 4 12 4 6 7 9 5 12
0 4 5 7 9 -5 1 1 5
0 98 34 0 1 7 7 1 1
6 7 8 -9 0 2 3 5 22
47 62 31 55 0 83 23 77 10

v.out

54 1 3

def find_best_v_path(matrix):
    m = len(matrix)
    n = len(matrix[0])
    
    # Step 3: Calculate dp_down
    dp_down = [[float('-inf')] * n for _ in range(m)]
    dp_down[0] = matrix[0][:]
    
    for i in range(1, m):
        for j in range(n):
            if j > 0:
                dp_down[i][j] = max(dp_down[i][j], dp_down[i-1][j-1] + matrix[i][j])
            if j < n - 1:
                dp_down[i][j] = max(dp_down[i][j], dp_down[i-1][j+1] + matrix[i][j])
    
    # Step 4: Calculate dp_up
    dp_up = [[float('-inf')] * n for _ in range(m)]
    dp_up[m-1] = matrix[m-1][:]
    
    for i in range(m-2, -1, -1):
        for j in range(n):
            if j > 0:
                dp_up[i][j] = max(dp_up[i][j], dp_up[i+1][j-1] + matrix[i][j])
            if j < n - 1:
                dp_up[i][j] = max(dp_up[i][j], dp_up[i+1][j+1] + matrix[i][j])
    
    # Step 5: Find the maximum sum path
    max_sum = float('-inf')
    min_length = float('inf')
    best_path_start = -1
    best_path_end = -1
    
    for i in range(m):
        for j in range(n):
            if dp_down[i][j] == float('-inf') or dp_up[i][j] == float('-inf'):
                continue
            total_sum = dp_down[i][j] + dp_up[i][j] - matrix[i][j]
            length = 2 * i + 1
            if total_sum > max_sum or (total_sum == max_sum and length < min_length):
                max_sum = total_sum
                min_length = length
                best_path_start = j
                best_path_end = j
    
    return max_sum, best_path_start, best_path_end

# Exemplu de utilizare:
matrix = [
    [3, 1, 7],
    [2, 5, 4],
    [1, 6, 2]
]

result = find_best_v_path(matrix)
print(result)