Problem:
Score : 1200 points

Problem Statement

We have a weighted directed graph with N vertices numbered 0 to N-1.

The graph initially has N-1 edges. The i-th edge (0 \leq i \leq N-2) is directed from Vertex i to Vertex i+1 and has a weight of 0.

Snuke will now add a new edge (i → j) for every pair i, j (0 \leq i,j \leq N-1,\ i \neq j).
The weight of the edge will be -1 if i < j, and 1 otherwise.

Ringo is a boy. A negative cycle (a cycle whose total weight is negative) in a graph makes him sad.
He will delete some of the edges added by Snuke so that the graph will no longer contain a negative cycle.
The cost of deleting the edge (i → j) is A_{i,j}. He cannot delete edges that have been present from the beginning.

Find the minimum total cost required to achieve Ringo's objective.

Constraints

3 \leq N \leq 500

1 \leq A_{i,j} \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_{0,1} A_{0,2} A_{0,3} \cdots A_{0,N-1}
A_{1,0} A_{1,2} A_{1,3} \cdots A_{1,N-1}
A_{2,0} A_{2,1} A_{2,3} \cdots A_{2,N-1}
\vdots
A_{N-1,0} A_{N-1,1} A_{N-1,2} \cdots A_{N-1,N-2}

Output

Print the minimum total cost required to achieve Ringo's objective.

Sample Input 1

3
2 1
1 4
3 3

Sample Output 1

2

If we delete the edge (0 → 1) added by Snuke, the graph will no longer contain a negative cycle.
The cost will be 2 in this case, which is the minimum possible.

Sample Input 2

4
1 1 1
1 1 1
1 1 1
1 1 1

Sample Output 2

2

If we delete the edges (1 → 2) and (3 → 0) added by Snuke, the graph will no longer contain a negative cycle.
The cost will be 1+1=2 in this case, which is the minimum possible.

Sample Input 3

10
190587 2038070 142162180 88207341 215145790 38 2 5 20
32047998 21426 4177178 52 734621629 2596 102224223 5 1864
41 481241221 1518272 51 772 146 8805349 3243297 449
918151 126080576 5186563 46354 6646 491776 5750138 2897 161
3656 7551068 2919714 43035419 495 3408 26 3317 2698
455357 3 12 1857 5459 7870 4123856 2402 258
3 25700 16191 102120 971821039 52375 40449 20548149 16186673
2 16 130300357 18 6574485 29175 179 1693 2681
99 833 131 2 414045824 57357 56 302669472 95
8408 7 1266941 60620177 129747 41382505 38966 187 5151064

Sample Output 3

2280211

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for(int i = int(a); i < int(b); i++)
#define rer(i, a, b) for(int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
typedef complex<double> comp;
void Debug() {cerr << '\n'; }
template<class FIRST, class... REST>void Debug(FIRST arg, REST... rest){
	cerr<<arg<<" ";Debug(rest...);}
template<class T>ostream& operator<<(ostream& out,const vector<T>& v) {
	out<<"[";if(!v.empty()){rep(i,0,sz(v)-1)out<<v[i]<<", ";out<<v.back();}out<<"]";return out;}
template<class S, class T>ostream& operator<<(ostream& out,const pair<S, T>& v){
	out<<"("<<v.first<<", "<<v.second<<")";return out;}
const int MAX_N = 500010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = (1 << 30) - 1;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
mt19937 rng; //use it by rng() % mod, shuffle(all(vec), rng)
///////////////////////////////////////////////////////////////////////////////////////////////////

int N;
ll A[510][510];
ll U[510][510];
ll D[510][510];

ll dp[2][510][510];

void solve() {
	cin >> N;
	rep(i, 0, N) {
		rep(j, 0, N) {
			if(i == j) continue;
			cin >> A[i][j];
		}
	}
	rep(i, 0, N) {
		rep(j, 0, i) {
			U[i][j + 1] = U[i][j] + A[j][i];
		}
	}
	rep(i, 0, N) {
		rep(j, 0, i) {
			D[i][j + 1] = D[i][j] + A[i][j];
		}
	}
	rep(i, 0, 2) {
		rep(j, 0, N + 1) {
			rep(k, 0, N + 1) {
				dp[i][j][k] = linf;
			}
		}
	}
	dp[1][0][0] = 0;
	int now = 1, nex = 0;
	rep(i, 1, N) {
		rep(j, 0, N) {
			rep(k, 0, N) {
				dp[nex][j][k] = linf;
			}
		}
		rer(j, N, 0) {
			rer(k, N, 0) {
				if(dp[now][j][k] == linf) continue;
				MIN(dp[now][k][i], dp[now][j][k]);
			}
		}
		rep(j, 0, N) {
			rep(k, 0, N) {
				// debug(i, j, k, dp[i][j][k], U[i][i] - U[i][k], D[i][j]);
				MIN(dp[nex][j][k], dp[now][j][k] + (U[i][i] - U[i][k]) + D[i][j]);
			}
		}
		swap(now, nex);
	}
	ll res = linf;
	rep(j, 0, N) {
		rep(k, 0, N) {
			// debug(N, j, k, dp[N][j][k]);
			MIN(res, dp[now][j][k]);
		}
	}
	cout << res << "\n";
}

uint32_t rd() {
	uint32_t res;
#ifdef __MINGW32__
	asm volatile("rdrand %0" :"=a"(res) ::"cc");
#else
	res = std::random_device()();
#endif
	return res;
}

int main() {
#ifndef LOCAL
	ios::sync_with_stdio(false);
    cin.tie(0);
#endif
    cout << fixed;
	cout.precision(20);
    cerr << fixed;
	cerr.precision(6);
	rng.seed(rd());
#ifdef LOCAL
	//freopen("in.txt", "wt", stdout); //for tester
	if(!freopen("in.txt", "rt", stdin)) return 1;
#endif	
	solve();
    cerr << "Time: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
	return 0;
}