Problem:
Score : 900 points

Problem Statement

Mole decided to live in an abandoned mine. The structure of the mine is represented by a simple connected undirected graph which consists of N vertices numbered 1 through N and M edges.
The i-th edge connects Vertices a_i and b_i, and it costs c_i yen (the currency of Japan) to remove it.

Mole would like to remove some of the edges so that there is exactly one path from Vertex 1 to Vertex N that does not visit the same vertex more than once. Find the minimum budget needed to achieve this.

Constraints

2 \leq N \leq 15

N-1 \leq M \leq N(N-1)/2

1 \leq a_i, b_i \leq N

1 \leq c_i \leq 10^{6}

There are neither multiple edges nor self-loops in the given graph.

The given graph is connected.

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1 c_1
:
a_M b_M c_M

Output

Print the answer.

Sample Input 1

4 6
1 2 100
3 1 100
2 4 100
4 3 100
1 4 100
3 2 100

Sample Output 1

200

By removing the two edges represented by the red dotted lines in the figure below, the objective can be achieved for a cost of 200 yen.

Sample Input 2

2 1
1 2 1

Sample Output 2

0

It is possible that there is already only one path from Vertex 1 to Vertex N in the beginning.

Sample Input 3

15 22
8 13 33418
14 15 55849
7 10 15207
4 6 64328
6 9 86902
15 7 46978
8 14 53526
1 2 8720
14 12 37748
8 3 61543
6 5 32425
4 11 20932
3 12 55123
8 2 45333
9 12 77796
3 9 71922
12 15 70793
2 4 25485
11 6 1436
2 7 81563
7 11 97843
3 1 40491

Sample Output 3

133677

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

#include <algorithm>  
#include <iostream>  
#include <sstream>  
#include <string>  
#include <cstring>
#include <vector>  
#include <queue>  
#include <set>  
#include <map>  
#include <cstdio>  
#include <cstdlib>  
#include <cctype>  
#include <cmath>  
#include <list>  
#include <cassert>
#include <ctime>
#include <climits>
using namespace std;  

#define PB push_back  
#define MP make_pair  
#define SZ(v) ((int)(v).size())  
#define FOR(i,a,b) for(int i=(a);i<(b);++i)  
#define REP(i,n) FOR(i,0,n)  
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)  
#define REPE(i,n) FORE(i,0,n)  
#define FORSZ(i,a,v) FOR(i,a,SZ(v))  
#define REPSZ(i,v) REP(i,SZ(v))  
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a,ll b) { return b==0?a:gcd(b,a%b); }

const int MAXN=15;

int n,m;
int e[MAXN][MAXN];

int sum[1<<MAXN];
int mem[1<<MAXN][MAXN];

int go(int left,int at) {
	if(at==n-1) return sum[left|(1<<at)];
	int &ret=mem[left][at];
	if(ret==-1) {
		ret=INT_MIN;
		REP(to,n) if(left&(1<<to)) if(e[at][to]!=-1) {
			int mask=(1<<n)-1-(left-(1<<to));
			for(int g=0;g<(1<<n);g=(g+mask+1)&~mask) {
				assert(((left-(1<<to))&g)==g); assert((g&(1<<to))==0); assert((g&(1<<at))==0); assert(at!=to);
				int cur=go(left-(1<<to)-g,to);
				if(cur==INT_MIN) continue;
				cur+=sum[(1<<at)+g];
				cur+=e[at][to];
				//printf("%x %d: %d->%d g=%x keep=%d (%d,%d)\n",left,at,at+1,to+1,g,cur,sum[(1<<at)+g],e[at][to]);
				if(cur>ret) {
					ret=cur;
				}
			}
		}
		//printf("%x %d: keep=%d\n",left,at,ret);
	}
	return ret;
}

void run() {
	scanf("%d%d",&n,&m);
	REP(i,n) REP(j,n) e[i][j]=-1;
	REP(i,m) { int a,b,c; scanf("%d%d%d",&a,&b,&c); --a,--b; e[a][b]=e[b][a]=c; }

	REP(i,1<<n) {
		sum[i]=0;
		REP(j,n) FOR(k,j+1,n) if((i&(1<<j))&&(i&(1<<k))&&(e[j][k]!=-1)) sum[i]+=e[j][k];
	}
	memset(mem,-1,sizeof(mem));
	int keep=go((1<<n)-1-(1<<0),0);
	int tot=0; REP(i,n) FOR(j,i+1,n) if(e[i][j]!=-1) tot+=e[i][j];
	//printf("tot=%d\n",tot);
	int ret=tot-keep; printf("%d\n",ret);
}

int main() {
	run();
	return 0;
}