Problem:
Score : 1200 points

Problem Statement

Takahashi is a magician. He can cast a spell on an integer sequence (a_1,a_2,...,a_M) with M terms, to turn it into another sequence (s_1,s_2,...,s_M), where s_i is the sum of the first i terms in the original sequence.

One day, he received N integer sequences, each with M terms, and named those sequences A_1,A_2,...,A_N. He will try to cast the spell on those sequences so that A_1 < A_2 < ... < A_N will hold, where sequences are compared lexicographically.
Let the action of casting the spell on a selected sequence be one cast of the spell. Find the minimum number of casts of the spell he needs to perform in order to achieve his objective.

Here, for two sequences a = (a_1,a_2,...,a_M), b = (b_1,b_2,...,b_M) with M terms each, a < b holds lexicographically if and only if there exists i (1 ≦ i ≦ M) such that a_j = b_j (1 ≦ j < i) and a_i < b_i.

Constraints

1 ≦ N ≦ 10^3

1 ≦ M ≦ 10^3

Let the j-th term in A_i be A_{(i,j)}, then 1 ≦ A_{(i,j)} ≦ 10^9.

Partial Scores

In the test set worth 200 points, Takahashi can achieve his objective by at most 10^4 casts of the spell, while keeping the values of all terms at most 10^9.

In the test set worth another 800 points, A_{(i,j)} ≦ 80.

Input

The input is given from Standard Input in the following format:

N M
A_{(1,1)} A_{(1,2)} … A_{(1,M)}
A_{(2,1)} A_{(2,2)} … A_{(2,M)}
:
A_{(N,1)} A_{(N,2)} … A_{(N,M)}

Output

Print the minimum number of casts of the spell Takahashi needs to perform. If he cannot achieve his objective, print -1 instead.

Sample Input 1

3 3
2 3 1
2 1 2
2 6 3

Sample Output 1

1

Takahashi can achieve his objective by casting the spell on A_2 once to turn it into (2 , 3 , 5).

Sample Input 2

3 3
3 2 10
10 5 4
9 1 9

Sample Output 2

-1

In this case, Takahashi cannot achieve his objective by casting the spell any number of times.

Sample Input 3

5 5
2 6 5 6 9
2 6 4 9 10
2 6 8 6 7
2 1 7 3 8
2 1 4 8 3

Sample Output 3

11

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Text;
using System.Collections.Generic;
class Solve{
    int N,M;
    long[,] A;
    public Solve(){}
    StringBuilder sb;
    public static int Main(){
        new Solve().Run();
        return 0;
    }
    void Run(){
        sb = new StringBuilder();
        Read();
        Calc();
        Console.Write(sb.ToString());
    }
    void Calc(){
        long count = 0;
        long b = 0;
        if(M == 1){
            for(int i=1;i<N;i++){
                if(A[i,0] < A[i-1,0]){
                    count = -1;
                    break;
                }
            }
        }
        else{
            for(int i=1;i<N;i++){
                if(A[i,0] > A[i-1,0]){
                    b = 0;
                    continue;
                }
                else if(A[i,0] < A[i-1,0]){
                    count = -1;
                    break;
                }
                else{
                    long c;
                    if(A[i,1] > A[i-1,1]){
                        c = (A[i,1] - A[i-1,1] - 1)/A[i-1,0] + 1;
                        if(c > b){
                            b = 0;
                        }
                        else if(c * A[i-1,0] != A[i,1] - A[i-1,1]){
                            count += b - c + 1;
                            b -= c - 1;
                        }
                        else{
                            /*if(c < 30){
                                long[] temp1 = new long[M];
                                long[] temp2 = new long[M];
                                int j = 1;
                                for(int k=0;k<M;k++){
                                    if(k == 0){
                                        temp2[k] = A[i-1,0];
                                    }
                                    else{
                                        temp2[k] = A[i-1,k] + temp2[k-1];
                                    }
                                }
                                for(;j<c;j++){
                                    if(j%2 == 1){
                                        for(int k=0;k<M;k++){
                                            if(k == 0){
                                                temp1[k] = temp2[k];
                                            }
                                            else{
                                                temp1[k] = temp1[k-1] + temp2[k];
                                            }
                                        }
                                    }
                                    else{
                                        for(int k=0;k<M;k++){
                                            if(k == 0){
                                                temp2[k] = temp1[k];
                                            }
                                            else{
                                                temp2[k] = temp2[k-1] + temp1[k];
                                            }
                                        }
                                    }
                                }
                                if(c%2 == 0){
                                    for(int k=0;k<M;k++){
                                        if(temp1[k] > A[i,k]){
                                            break;
                                        }
                                        else if(temp1[k] < A[i,k]){
                                            c++;
                                            break;
                                        }
                                    }
                                }
                                else{
                                    for(int k=0;k<M;k++){
                                        if(temp2[k] > A[i,k]){
                                            break;
                                        }
                                        else if(temp2[k] < A[i,k]){
                                            c++;
                                            break;
                                        }
                                    }
                                }
                            }*/
                            //else{
                                Conv co = new Conv(M,c-1);
                                for(int k=0;k<M;k++){
                                    long sum = 0;
                                    for(int j=0;j<=k;j++){
                                        long x = co.C(k-j);
                                        if(x == -1){
                                            sum = -1;
                                            break;
                                        }
                                        sum += x * A[i-1,j];
                                        if(sum > 1000000000){
                                            sum = -1;
                                            break;
                                        }
                                    }
                                    if(sum == -1 || sum > A[i,k]){
                                        break;
                                    }
                                    else if(sum < A[i,k]){
                                        c++;
                                        break;
                                    }
                                }
                            //}
                            if(c > b){
                                b = 0;
                            }
                            else{
                                b -= c - 1;
                                count += b;
                            }
                        }
                    }
                    else if(A[i,1] < A[i-1,1]){
                        c = (A[i-1,1] - A[i,1] - 1)/A[i,0] + 1;
                        if(c * A[i,0] != A[i-1,1] - A[i,1]){
                            b += c;
                            count += b;
                        }
                        else{
                            /*if(c < 30){
                                long[] temp1 = new long[M];
                                long[] temp2 = new long[M];
                                int j = 1;
                                for(int k=0;k<M;k++){
                                    if(k == 0){
                                        temp2[k] = A[i,0];
                                    }
                                    else{
                                        temp2[k] = A[i,k] + temp2[k-1];
                                    }
                                }
                                for(;j<c;j++){
                                    if(j%2 == 1){
                                        for(int k=0;k<M;k++){
                                            if(k == 0){
                                                temp1[k] = temp2[k];
                                            }
                                            else{
                                                temp1[k] = temp1[k-1] + temp2[k];
                                            }
                                        }
                                    }
                                    else{
                                        for(int k=0;k<M;k++){
                                            if(k == 0){
                                                temp2[k] = temp1[k];
                                            }
                                            else{
                                                temp2[k] = temp2[k-1] + temp1[k];
                                            }
                                        }
                                    }
                                }
                                if(c%2 == 0){
                                    int k;
                                    for(k=0;k<M;k++){
                                        if(temp1[k] > A[i-1,k]){
                                            break;
                                        }
                                        else if(temp1[k] < A[i-1,k]){
                                            c++;
                                            break;
                                        }
                                    }
                                    if(k == M){
                                        c++;
                                    }
                                }
                                else{
                                    int k;
                                    for(k=0;k<M;k++){
                                        if(temp2[k] > A[i-1,k]){
                                            break;
                                        }
                                        else if(temp2[k] < A[i-1,k]){
                                            c++;
                                            break;
                                        }
                                    }
                                    if(k == M){
                                        c++;
                                    }
                                }
                            }*/
                            //else{
                                Conv co = new Conv(M,c-1);
                                int k;
                                for(k=0;k<M;k++){
                                    long sum = 0;
                                    for(int j=0;j<=k;j++){
                                        long x = co.C(k-j);
                                        if(x == -1){
                                            sum = -1;
                                            break;
                                        }
                                        sum += x * A[i,j];
                                        if(sum > 1000000000){
                                            sum = -1;
                                            break;
                                        }
                                    }
                                    if(sum == -1 || sum > A[i-1,k]){
                                        break;
                                    }
                                    else if(sum < A[i-1,k]){
                                        c++;
                                        break;
                                    }
                                }
                                if(k == M){
                                    c++;
                                }
                            //}
                            b += c;
                            count += b;
                        }
                    }
                    else{
                        int j;
                        for(j=1;j<M;j++){
                            if(A[i-1,j] < A[i,j]){
                                count += b;
                                break;
                            }
                            else if(A[i-1,j] > A[i,j]){
                                b++;
                                count += b;
                                break;
                            }
                        }
                        if(j == M){
                            b++;
                            count += b;
                        }
                    }
                }
            }
        }
        sb.Append(count+"\n");
    }
    void Read(){
        string[] str = Console.ReadLine().Split(' ');
        N = int.Parse(str[0]);
        M = int.Parse(str[1]);
        A = new long[N,M];
        for(int i=0;i<N;i++){
            str = Console.ReadLine().Split(' ');
            for(int j=0;j<M;j++){
                A[i,j] = Int64.Parse(str[j]);
            }
        }
    }    
}
class Conv{
    public int n;
    public long m;
    public long[] c;
    public Conv(int n0,long m0){
        n = n0;
        m = m0;
        c = new long[n];
        for(int i=0;i<n;i++){
            if(i == 0){
                c[i] = 1;
            }
            else{
                c[i] = c[i-1]*(m+i)/i;
                if(c[i] > 1000000000){
                    c[i] = -1;
                    break;
                }
            }
        }
    }
    public long C(int N){
        return c[N];
    }
}