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: Accepted)

// 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 bs_max = (1 << n) - 1;
    let mut dp = vec![vec![None; n]; 1 << n];
    dp[1][0] = Some(0);
    for bs in (0..1 << n).filter(|&bs| bs & 1 == 1) {
        for x in (0..n).filter(|&x| bs >> x & 1 == 1) {
            if let Some(crr) = dp[bs][x] {
                for cs in std::iter::successors(Some(bs_max & !bs), |&cs| {
                    if cs == 0 {
                        None
                    } else {
                        Some((cs - 1) & !bs)
                    }
                }) {
                    dp[bs | cs][x].change_max(Some(crr + w[cs | 1 << x]));
                }

                for y in (0..n).filter(|&y| bs >> y & 1 == 0 && adj[x][y] != 0) {
                    dp[bs | 1 << y][y].change_max(Some(crr + adj[x][y]));
                }
            }
        }
    }

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