Ruudukko

import bisect
 
def solve(nums):
    n = len(nums)
    m = len(nums[0])
    calculated = [[-1] * m for _ in range(n)]
 
    calculated_rows = [[] for _ in range(n)]
    calculated_columns = [[] for _ in range(m)]
 
    calculated_row_sums = [[] for _ in range(n)]
    calculated_column_sums = [[] for _ in range(m)]
    
 
    indecesSorted = [(i, j) for j in range(m) for i in range(n)]
    indecesSorted.sort(key=lambda x: nums[x[0]][x[1]])
    
    def inner(idx, idx1):
        if idx < 0 or idx1 < 0:
            return 0
        elif idx >= n or idx1 >= m:
            return 0
        elif nums[idx][idx1] == 1:
            calculated_rows[idx].append(nums[idx][idx1])
            calculated_columns[idx1].append(nums[idx][idx1])
            calculated_row_sums[idx].append(1)
            calculated_column_sums[idx1].append(1)
            calculated[idx][idx1] = 1
            return 1
 
        else:
            total = 1
            length_row_left = bisect.bisect_left(calculated_rows[idx], nums[idx][idx1]-1)
            length_column_left = bisect.bisect_left(calculated_columns[idx1], nums[idx][idx1]-1)
            length_row_right = bisect.bisect_right(calculated_rows[idx], nums[idx][idx1]-1)
            length_column_right = bisect.bisect_right(calculated_columns[idx1], nums[idx][idx1]-1)
 
            length_row = length_row_right
            if length_row_left == length_row_right:
                if length_row > 0:
                    total += calculated_row_sums[idx][length_row - 1]
                    total %= 1000000007
            else:
                total += calculated_row_sums[idx][length_row - 1] * (length_row_right - length_row_left)
                total %= 1000000007
 
            length_column = length_column_right
            if length_column_left == length_column_right:   
                if length_column > 0:
                    total += calculated_column_sums[idx1][length_column - 1]
                    total %= 1000000007
 
            else:
                total += calculated_column_sums[idx1][length_column - 1] * (length_column_right - length_column_left)
                total %= 1000000007
 
            calculated_rows[idx].append(nums[idx][idx1])
            calculated_columns[idx1].append(nums[idx][idx1])
 
            if length_row > 0:
                calculated_row_sums[idx].appen(total + calculated_row_sums[idx][length_row - 1])
            else:
                calculated_row_sums[idx].append(total)
            if length_column > 0:
                calculated_column_sums[idx1].append(total + calculated_column_sums[idx1][length_column - 1])
            else:
                calculated_column_sums[idx1].append(total)
 
            calculated[idx][idx1] = total
            return total
 
    total = 0
    for i in range(n * m):
        curr = indecesSorted[i]
        first = curr[0]
        second = curr[1]
        total += inner(first, second) if calculated[first][second] == -1 else calculated[first][second]
        total %= 1000000007
    return total
 
 
n = int(input())
 
nums = [[-1] * n for _ in range(n)]
for i in range(n):
    nums[i] = [int(a_value) for a_value in input().split()]
 
print(solve(nums))

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3

Verdict: RUNTIME ERROR

Traceback (most recent call last):
  File "input/code.py", line 88, in <module>
    print(...

Test 3

Group: 1, 2, 3

Verdict: RUNTIME ERROR

Traceback (most recent call last):
  File "input/code.py", line 88, in <module>
    print(...

Test 4

Group: 2, 3

Verdict: ACCEPTED

Test 5

Group: 2, 3

Verdict: RUNTIME ERROR

Traceback (most recent call last):
  File "input/code.py", line 88, in <module>
    print(...

Test 6

Group: 2, 3

Verdict: RUNTIME ERROR

Traceback (most recent call last):
  File "input/code.py", line 88, in <module>
    print(...

Test 7

Group: 3

Verdict: ACCEPTED

Test 8

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 3

Verdict: TIME LIMIT EXCEEDED