Problem:
Score : 1500 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 1500

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

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.System.exit;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

	static void solve() throws Exception {
		int n = scanInt();
		char map[][] = new char[n][];
		for (int i = 0; i < n; i++) {
			map[i] = scanString().toCharArray();
		}
		int sum[][] = new int[n][n];
		int maxI[][] = new int[n][n];
		int curProfilesD[][] = new int[n][n];
		int curProfilesR[][] = new int[n][n];
		int prevProfilesD[][] = new int[n][n];
		int prevProfilesR[][] = new int[n][n];
		long ans = 0;
		for (int i = n - 1; i >= 0; i--) {
			for (int j = n - 1; j >= 0; j--) {
				if (map[i][j] == '#') {
					continue;
				}
				int value = map[i][j] - '0';
				if (i == n - 1 || map[i + 1][j] == '#') {
					if (j == n - 1 || map[i][j + 1] == '#') {
						sum[i][j] = value;
						maxI[i][j] = i;
						for (int k = i + 1; k < n; k++) {
							curProfilesD[j][k] = n;
						}
						for (int k = i; k < n; k++) {
							curProfilesR[j][k] = j + 1;
						}
					} else {
						int psum = sum[i][j + 1];
						sum[i][j] = value + psum;
						ans += value * psum;
						maxI[i][j] = maxI[i][j + 1];
						for (int k = i + 1; k < n; k++) {
							curProfilesD[j][k] = curProfilesD[j + 1][k];
						}
						for (int k = i; k < n; k++) {
							curProfilesR[j][k] = curProfilesR[j + 1][k];
						}
					}
				} else {
					if (j == n - 1 || map[i][j + 1] == '#') {
						int psum = sum[i + 1][j];
						sum[i][j] = value + psum;
						ans += value * psum;
						maxI[i][j] = maxI[i + 1][j];
						curProfilesD[j][i + 1] = j;
						for (int k = i + 2; k < n; k++) {
							curProfilesD[j][k] = prevProfilesD[j][k];
						}
						curProfilesR[j][i] = j + 1;
						for (int k = i + 1; k < n; k++) {
							curProfilesR[j][k] = prevProfilesR[j][k];
						}
					} else {
						int psum = sum[i][j + 1] + sum[i + 1][j];
						for (int k = i + 1; k < n; k++) {
							if (curProfilesD[j + 1][k] < prevProfilesR[j][k]) {
								psum -= sum[k][curProfilesD[j + 1][k]];
								k = maxI[k][curProfilesD[j + 1][k]];
							}
						}
						sum[i][j] = value + psum;
						ans += value * psum;
						maxI[i][j] = max(maxI[i][j + 1], maxI[i + 1][j]);
						curProfilesD[j][i + 1] = j;
						for (int k = i + 2; k < n; k++) {
							curProfilesD[j][k] = min(prevProfilesD[j][k], curProfilesD[j + 1][k]);
						}
						curProfilesR[j][i] = curProfilesR[j + 1][i];
						for (int k = i + 1; k < n; k++) {
							curProfilesR[j][k] = max(curProfilesR[j + 1][k], prevProfilesR[j][k]);
						}
					}
				}
//				System.err.println(i + " " + j + " " + ans + " " +
//					Arrays.toString(Arrays.copyOfRange(curProfilesD[j], i + 1, n)) + " " +
//					Arrays.toString(Arrays.copyOfRange(curProfilesR[j], i, n)));
			}
			int t[][] = prevProfilesD;
			prevProfilesD = curProfilesD;
			curProfilesD = t;
			t = prevProfilesR;
			prevProfilesR = curProfilesR;
			curProfilesR = t;
		}
		out.print(ans);
	}

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}