#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stack>

using namespace std;

const double EPS=(1e-10);
typedef long long ll;
typedef pair<int,int> pii;
bool EQ(double a,double b){
  return abs((a)-(b))<EPS;
}
void fast_stream(){
	std::ios_base::sync_with_stdio(0);
}

int N;
int c[11][11];

const int MAX_SIZE = 10000;

struct edge{
	int to;
	int cost;
};

class Situation{
public:
    vector<int> seq;
	int cost;
	Situation(int cost_,vector<int> &seq_){
		cost=cost_;
        seq=seq_;
    }
	Situation();
	bool operator<(const Situation &s)const{
		return s.cost < this->cost;
	}
};

int V;
const int MAX_V = 5000;
map<vector<int>,int> d;
const int INF = 1000000000;
int res;

void dijkstra(vector<int> s){
	priority_queue<Situation> que;
    d[s] = 0;
    que.push(Situation(0,s));
	while(!que.empty()){
		Situation p = que.top();
		que.pop();
        if(d.count(p.seq)!=0&&d[p.seq] < p.cost)
			continue;
        // ツ各ツ偲ュツ禿シツづェツ妥鳴つヲ
        for(int i=0;i<N;i++){
            for(int j=i+1;j<N;j++){
                vector<int> nseq=p.seq;
                swap(nseq[i],nseq[j]);
                int ct=c[i][j];
                if(d.count(nseq)==0||d[nseq]>d[p.seq]+ct){
                    d[nseq]=d[p.seq]+ct;
                    que.push(Situation(d[nseq],nseq));
                }
            }
        }
	}
}

void solve(){
    cin>>N;
    for(int i=0;i<N;i++)for(int j=0;j<N;j++)cin>>c[i][j];
    vector<int> v;
    for(int i=0;i<N;i++)v.push_back(i);
    res=0;
    dijkstra(v);
    for(map<vector<int>,int>::iterator it=d.begin();it!=d.end();it++)res=max(res,it->second);
    cout<<res<<endl;
}


int main(){
    solve();

    return 0;
}
### Prompt

Develop a solution in Cpp to the problem described below:

Problem statement

There is a permutation with $ 1,2, ..., N $ sorted. I want to select two different numbers $ i $, $ j $ and replace them repeatedly to make them sorted (in the order of $ 1,2, ..., N $). Every time you replace the numbers $ i $, $ j $, you need $ c_ {i, j} $.

Let $ f (p) $ be the minimum cost required to sort $ p $ for the permutation $ p $. Find the maximum possible value of $ f (p) $.

Constraint

* $ 2 \ leq N \ leq 8 $
* $ 0 \ leq c_ {i, j} \ leq 10 ^ 5 $
* $ c_ {i, j} = c_ {j, i} $
* $ c_ {i, i} = 0 $



input

Input follows the following format. All given numbers are integers.


$ N $
$ c_ {1,1} $ $ c_ {1,2} $ $ ... $ $ c_ {1, N} $
$ c_ {2,1} $ $ c_ {2,2} $ $ ... $ $ c_ {2, N} $
$ ... $
$ c_ {N, 1} $ $ c_ {N, 2} $ $ ... $ $ c_ {N, N} $

output

Output the maximum value on one line.

Example

Input

3
0 1 3
1 0 8
3 8 0


Output

5

### Response

```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stack>

using namespace std;

const double EPS=(1e-10);
typedef long long ll;
typedef pair<int,int> pii;
bool EQ(double a,double b){
  return abs((a)-(b))<EPS;
}
void fast_stream(){
	std::ios_base::sync_with_stdio(0);
}

int N;
int c[11][11];

const int MAX_SIZE = 10000;

struct edge{
	int to;
	int cost;
};

class Situation{
public:
    vector<int> seq;
	int cost;
	Situation(int cost_,vector<int> &seq_){
		cost=cost_;
        seq=seq_;
    }
	Situation();
	bool operator<(const Situation &s)const{
		return s.cost < this->cost;
	}
};

int V;
const int MAX_V = 5000;
map<vector<int>,int> d;
const int INF = 1000000000;
int res;

void dijkstra(vector<int> s){
	priority_queue<Situation> que;
    d[s] = 0;
    que.push(Situation(0,s));
	while(!que.empty()){
		Situation p = que.top();
		que.pop();
        if(d.count(p.seq)!=0&&d[p.seq] < p.cost)
			continue;
        // ツ各ツ偲ュツ禿シツづェツ妥鳴つヲ
        for(int i=0;i<N;i++){
            for(int j=i+1;j<N;j++){
                vector<int> nseq=p.seq;
                swap(nseq[i],nseq[j]);
                int ct=c[i][j];
                if(d.count(nseq)==0||d[nseq]>d[p.seq]+ct){
                    d[nseq]=d[p.seq]+ct;
                    que.push(Situation(d[nseq],nseq));
                }
            }
        }
	}
}

void solve(){
    cin>>N;
    for(int i=0;i<N;i++)for(int j=0;j<N;j++)cin>>c[i][j];
    vector<int> v;
    for(int i=0;i<N;i++)v.push_back(i);
    res=0;
    dijkstra(v);
    for(map<vector<int>,int>::iterator it=d.begin();it!=d.end();it++)res=max(res,it->second);
    cout<<res<<endl;
}


int main(){
    solve();

    return 0;
}
```