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.42.0) (judge verdict: Wrong Answer)

// ordtools {{{
#[allow(dead_code)]
mod ordtools {
    pub trait Ordtools: PartialOrd + Sized {
        fn change_min(&mut self, mut rhs: Self) {
            if self > &mut rhs {
                *self = rhs;
            }
        }

        fn change_max(&mut self, mut rhs: Self) {
            if self < &mut rhs {
                *self = rhs;
            }
        }
    }

    impl<T: PartialOrd + Sized> Ordtools for T {}
}
// }}}
// dbg {{{
#[allow(dead_code)]
mod dbg {
    use std::fmt::{Debug, Formatter};

    #[derive(Clone)]
    pub struct Tabular<'a, T: Debug>(pub &'a [Vec<T>]);
    impl<'a, T: Debug> Debug for Tabular<'a, T> {
        fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
            for i in 0..self.0.len() {
                writeln!(f, "{:2} | {:?}", i, &self.0[i])?;
            }
            Ok(())
        }
    }

    #[derive(Clone)]
    pub struct BooleanTable<'a>(pub &'a [Vec<bool>]);
    impl<'a> Debug for BooleanTable<'a> {
        fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
            for i in 0..self.0.len() {
                writeln!(f, "{:2} | {:?}", i, BooleanSlice(&self.0[i]))?;
            }
            Ok(())
        }
    }

    #[derive(Clone)]
    pub struct BooleanSlice<'a>(pub &'a [bool]);
    impl<'a> Debug for BooleanSlice<'a> {
        fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
            write!(
                f,
                "{}",
                self.0
                    .iter()
                    .map(|&b| if b { '#' } else { '.' })
                    .collect::<String>()
            )?;
            Ok(())
        }
    }
}
// }}}

use ordtools::Ordtools;
use proconio::{input, marker::Usize1};

fn main() {
    input!(n: usize, m: usize, abc: [(Usize1, Usize1, u32); m]);

    let all = abc.iter().map(|&(_, _, c)| c).sum::<u32>();

    let mut adj = vec![vec![0; n]; n];
    (0..n).for_each(|i| adj[i][i] = 0);
    for (a, b, c) in abc {
        adj[a][b] = c;
        adj[b][a] = c;
    }

    let mut w = vec![0; 1 << n];
    for mask in 0..1 << n {
        for i in (0..n).filter(|&i| mask >> i & 1 == 1) {
            for j in (i + 1..n).filter(|&j| mask >> j & 1 == 1) {
                w[mask] += adj[i][j];
            }
        }
    }

    let mut dp = vec![vec![0; n]; 1 << n];
    for bs in 1..1 << n {
        for cs in std::iter::successors(Some((1 << n) & !bs), |aug| {
            let cs = (aug - 1) & !bs;
            if cs == 0 {
                None
            } else {
                Some(cs)
            }
        }) {
            for x in (0..n).filter(|&x| bs >> x & 1 == 1) {
                for y in (0..n).filter(|&y| cs >> y & 1 == 1 && adj[x][y] != 0) {
                    let z = dp[bs][x] + w[cs] + adj[x][y];
                    dp[bs | cs][y].change_max(z);
                }
            }
        }
    }

    let max_span = (0..1 << n).map(|bs| dp[bs][n - 1]).max().unwrap();
    println!("{}", all - max_span);
}