Problem:


Score : 1000 points

Problem Statement

Problem F and F2 are the same problem, but with different constraints and time limits.

We have a board divided into N horizontal rows and N vertical columns of square cells.
The cell at the i-th row from the top and the j-th column from the left is called Cell (i,j).
Each cell is either empty or occupied by an obstacle.
Also, each empty cell has a digit written on it.
If A_{i,j}= 1, 2, ..., or 9, Cell (i,j) is empty and the digit A_{i,j} is written on it.
If A_{i,j}= #, Cell (i,j) is occupied by an obstacle.

Cell Y is reachable from cell X when the following conditions are all met:

Cells X and Y are different.

Cells X and Y are both empty.

One can reach from Cell X to Cell Y by repeatedly moving right or down to an adjacent empty cell.

Consider all pairs of cells (X,Y) such that cell Y is reachable from cell X.
Find the sum of the products of the digits written on cell X and cell Y for all of those pairs.

Constraints

1 \leq N \leq 500

A_{i,j} is one of the following characters: 1, 2, ... 9 and #.

Input

Input is given from Standard Input in the following format:

N
A_{1,1}A_{1,2}...A_{1,N}
A_{2,1}A_{2,2}...A_{2,N}
:
A_{N,1}A_{N,2}...A_{N,N}

Output

Print the sum of the products of the digits written on cell X and cell Y for all pairs (X,Y) such that cell Y is reachable from cell X.

Sample Input 1

2
11
11

Sample Output 1

5

There are five pairs of cells (X,Y) such that cell Y is reachable from cell X, as follows:

X=(1,1), Y=(1,2)

X=(1,1), Y=(2,1)

X=(1,1), Y=(2,2)

X=(1,2), Y=(2,2)

X=(2,1), Y=(2,2)

The product of the digits written on cell X and cell Y is 1 for all of those pairs, so the answer is 5.

Sample Input 2

4
1111
11#1
1#11
1111

Sample Output 2

47

Sample Input 3

10
76##63##3#
8445669721
75#9542133
3#285##445
749632##89
2458##9515
5952578#77
1#3#44196#
4355#99#1#
#298#63587

Sample Output 3

36065

Sample Input 4

10
4177143673
7#########
5#1716155#
6#4#####5#
2#3#597#6#
6#9#8#3#5#
5#2#899#9#
1#6#####6#
6#5359657#
5#########

Sample Output 4

6525



Sample input:
2
11
11


Sample output:
5

Submission status: Wrong Answer

Solution code:
print(5)

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
X = [[c  for c in input()] for i in range(N)]
def reachable(i1,j1,i2,j2):
    if i1>i2:
        return 0
    if j1>j2:
        return 0
    if i1==i2 and j1 == j2:
        return 0
    T = [[0 for k in range(j2-j1+1)] for k2 in range(i2-i1+1)]
    T[0][0] = 1
    for i in range(i1+1,i2+1):
        if T[i-i1-1][0] == 1 and X[i][j1] != "#":
            T[i-i1][0] = 1
    for j in range(j1+1,j2+1):
        if T[0][j-j1-1] == 1 and X[i1][j] != "#":
            T[0][j-j1] = 1
            
    for i in range(i1+1,i2+1):
        for j in range(j1+1,j2+1):
            if (T[i-i1][j-j1-1] == 1 or T[i-i1-1][j-j1] == 1) and X[i][j] != "#":
                T[i-i1][j-j1] = 1
    return T[i2-i1][j2-j1]

ans = 0
for i1 in range(N):
    for j1 in range(N):
        if X[i1][j1] != "#":
            for i2 in range(i1, N):
                for j2 in range(j1, N):
                    if X[i2][j2] != "#":
                        if reachable(i1,j1,i2,j2)>0:
                            ans += int(X[i1][j1])*int(X[i2][j2])
print(ans)

Submission status: Time Limit Exceeded

Solution code:

def elongation(edges1, edges2, data, total):
    new_edges = list()
    for e1 in edges1:
        for e2 in edges2:
            if e1[1] == e2[0]:
                if [e1[0], e2[1]] not in new_edges:
                    new_edges.append([e1[0], e2[1]])
                    total += \
                        data[e1[0] // n][e1[0] % n] * data[e2[1] // n][e2[1] % n]
            else:
                continue
    return new_edges, total


n = int(input().strip())

data = list()

total = 0

for i in range(n):
    data.append([
        int(x)
        if x != '#'
        else x
        for x in list(input().strip())])

edges = [[]]

for i in range(n - 1):
    for j in range(n):
        if data[i][j] != '#' and data[i + 1][j] != '#':
            edges[0].append([
                i * n + j,
                (i + 1) * n + j])
            total += data[i][j]*data[i + 1][j]
        else:
            continue

for i in range(n):
    for j in range(n - 1):
        if data[i][j] != '#' and data[i][j + 1] != '#':
            edges[0].append([
                i * n + j,
                i * n + j + 1])
            total += data[i][j]*data[i][j + 1]
        else:
            continue

for i in range(2 * n - 3):
    new_edges, total = elongation(edges[i], edges[0], data, total)
    edges.append(new_edges)

print(total)

Submission status: Time Limit Exceeded

Solution code:
# your code goes here
# def debug_print(maze):
#     for xx in maze:
#         for yy in xx:
#             print yy,
#         print "\n",

def clear_maze(sx, sy, gx, gy, maze):

    INF = 100000000

    field_x_length = len(maze)
    field_y_length = len(maze[0])
    distance = [[INF for i in range(field_x_length)] for j in range(field_y_length)]
    #    distance = [[None]*field_x_length]*field_y_length

    def bfs():
        queue = []

        queue.insert(0, (sx, sy))

        distance[sx][sy] = 0
        while len(queue):
            x, y = queue.pop()

            if x == gx and y == gy:
                break

            for i in range(0, 2):
                nx, ny = x + [1, 0][i], y + [0, 1][i]

                if (0 <= nx and nx < field_x_length and 0 <= ny and ny < field_y_length and maze[nx][ny] != '#' and distance[nx][ny] == INF):
                    queue.insert(0, (nx, ny))
                    distance[nx][ny] = distance[x][y] + 1


        return distance[gx][gy]

    return bfs()
    
N = int(input())
maze = [list(input()) for i in range(N)]

ans = 0
for i in range(N*N):
	if maze[i//N][i%N] == '#': continue
	for j in range(i+1,N*N):
		if i%N > j%N or maze[j//N][j%N] == '#': continue
		# print(i//N,i%N,j//N,j%N,maze)
		tmp = clear_maze(i//N,i%N,j//N,j%N,maze)
		if 0 < tmp and tmp < 100000000:
			ans += int(maze[i//N][i%N]) * int(maze[j//N][j%N])
		
print(ans)

Submission status: Time Limit Exceeded

Solution code:
n = int(input())

matrix = []
for i in range(n):
	line = input()
	matrix.append(line)

def canReachTree(i, j, index_list, tree):
	try:
		if matrix[i+1][j] != "#":
			#print("*", i+1, j)
			if [i+1, j] not in index_list:
				index_list.append([i+1, j])
				tree.append(int(matrix[i+1][j]))
			canReachTree(i+1, j, index_list, tree)
	except:
		pass
	try:
		if matrix[i][j+1] != "#":
			#print("*", i, j+1)
			if [i, j+1] not in index_list:
				index_list.append([i, j+1])
				tree.append(int(matrix[i][j+1]))
			canReachTree(i, j+1, index_list, tree)
	except:
		pass
	finally:
		return tree

ans = 0
for i in range(len(matrix)):
	for j in range(len(matrix[0])):
		index_list = []
		tree = []
		if matrix[i][j] != "#":
			#print("i,j:",i,j)
			#print(canReachTree(i, j, tree))
			sigma = sum(canReachTree(i, j, index_list, tree))
			ans += int(matrix[i][j]) * sigma
			#print("matrix[i][j],sigma:",matrix[i][j],sigma)


print(ans)