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 Rust (1.15.1) (judge verdict: Wrong Answer)

#![allow(unused_imports, unused_variables, dead_code)]
use std::io::*;
use std::fmt::*;
use std::str::*;
use std::cmp::*;
use std::collections::*;

trait InputValue {
    fn parse(s: &str) -> Self;
}

fn read<T: InputValue>() -> T {
    let mut buf = String::new();
    let _ = stdin().read_line(&mut buf);
    T::parse(&buf.trim())
}

fn readnc<T: InputValue>() -> Vec<T> {
    let mut vec = vec![];
    let line: String = read();
    for token in line.split_whitespace() {
        vec.push(T::parse(token));
    }
    vec
}

fn readn<T: InputValue>(n: usize) -> Vec<T> {
    let mut vec = vec![];
    for _ in 0..n {
        vec.push(read());
    }
    vec
}

macro_rules! parse_single_value {
    ($($t:ty),*) => {
        $(
            impl InputValue for $t {
                fn parse(s: &str) -> $t { s.parse().unwrap() }
            }
        )*
	}
}
parse_single_value!(i32, i64, f32, f64, usize, String);

macro_rules! parse_tuple {
	($($t:ident),*) => {
		impl<$($t),*> InputValue for ($($t),*) where $($t: InputValue),* {
			fn parse(s: &str) -> ($($t),*) {
				let mut tokens = s.split_whitespace();
				let t = ($($t::parse(tokens.next().unwrap())),*);
				t
			}
		}
	}
}
parse_tuple!(A, B);
parse_tuple!(A, B, C);

// ===


struct UnionFind {
    n: usize,
    rank: Vec<usize>,
    parent: Vec<usize>,
    value: Vec<usize>
}

impl UnionFind {
    fn new(n: usize) -> Self {
        let mut p = vec![0; n];
        for i in 0..n {
            p[i] = i;
        }
        UnionFind { n: n, rank: vec![0; n], parent: p, value: vec![0; n] }
    }

    fn find(&mut self, a: usize) -> usize {
        if self.parent[a] == a {
            return a;
        }
        let par = self.parent[a];
        self.parent[a] = self.find(par);
        self.parent[a]
    }

    fn unite(&mut self, a: usize, b: usize) {
        let a = self.find(a);
        let b = self.find(b);
        if a == b {
            return;
        }
        let total = min(self.value[a], self.value[b]);
        self.value[b] = total;
        self.value[a] = total;

        let ra = self.rank[a];
        let rb = self.rank[b];
        if ra < rb {
            self.parent[a] = b;
        } else {
            self.parent[b] = a;
            if ra == rb {
                self.rank[a] += 1;
            }
        }
    }

    fn same(&mut self, a: usize, b: usize) -> bool {
        self.find(a) == self.find(b)
    }
}

fn solve_sub(left_edges: &mut Vec<(usize, usize, i32)>, picked_edges: &Vec<(usize, usize, i32)>, n: usize,  ptn: usize) -> i32 {
    let mut ret = 0;
    let mut uf = UnionFind::new(n);
    for i in 0..n {
        if ptn & (1<<i) >= 1 {
            uf.value[i] = i;
        } else {
            uf.value[i] = n;
        }
    }

    left_edges.sort_by_key(|a| -a.2);

    for &mut (a, b, c) in left_edges {
        let aa = uf.find(a);
        let bb = uf.find(b);
        if uf.value[aa] != uf.value[bb] && uf.value[aa] != n && uf.value[bb] != n {
            ret += c;
            continue
        }
        uf.unite(a, b);
    }

    ret
}

fn main() {
    let (n, m): (usize, usize) = read();
    let mut graph: Vec<Vec<(usize, i32)>> = vec![vec![]; n];
    let mut table: Vec<Vec<i32>> = vec![vec![0; n]; n];
    for i in 0..m {
        let (a, b, c): (usize, usize, i32) = read();
        graph[a-1].push((b-1, c));
        graph[b-1].push((a-1, c));
        table[a-1][b-1] = c;
        table[b-1][a-1] = c;
    }

    let mut dp = vec![vec![-1; n]; 1<<n];
    let mut dpfrom = vec![vec![0; n]; 1<<n];
    dp[1][0] = 0;

    for p in 0..(1<<n) {
        for now in 0..n {
            if dp[p][now] == -1 {
                continue
            }
            let base = dp[p][now];
            for &(j, c) in &graph[now] {
                if (p & (1<<j)) != 0 {
                    continue
                }
                let tp = p | (1<<j);
                let tc = base + c;
                if dp[tp][j] < tc {
                    dp[tp][j] = tc;
                    dpfrom[tp][j] = now;
                }
            }
        }
    }

    let mut best = 1e9 as i32;
    for p in 0..(1<<n) {
        if dp[p][n-1] != -1 {
            let mut le = vec![];
            let mut ae = vec![];

            let mut np = p;
            let mut now = n-1;
            while np != 1 {
                let tn = dpfrom[np][now];
                ae.push((now, tn, table[now][tn]));
                table[now][tn] = 0;
                table[tn][now] = 0;
                np ^= 1<<now;
                now = tn;
            }

            for i in 0..n {
                for j in i+1..n {
                    if table[i][j] != 0 {
                        le.push((i, j, table[i][j]));
                    }
                }
            }

            best = min(best, solve_sub(&mut le, &ae, n, p));

            // fukugen
            for &(a, b, c) in &ae {
                table[a][b] = c;
                table[b][a] = c;
            }
        }
    }

    println!("{}", best);
}