Problem:
Traveling Salesman Problem

For a given weighted directed graph G(V, E), find the distance of the shortest route that meets the following criteria:

It is a closed cycle where it ends at the same point it starts.

It visits each vertex exactly once.

Input

|V| |E|
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1

|V| is the number of vertices and |E| is the number of edges in the graph. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively.

si and ti represent source and target vertices of i-th edge (directed) and di represents the distance between si and ti (the i-th edge).

Output

Print the shortest distance in a line. If there is no solution, print -1.

Constraints

2 ≤ |V| ≤ 15

0 ≤ di ≤ 1,000

There are no multiedge

Sample Input 1

4 6
0 1 2
1 2 3
1 3 9
2 0 1
2 3 6
3 2 4

Sample Output 1

16

Sample Input 2

3 3
0 1 1
1 2 1
0 2 1

Sample Output 2

-1

Solution in OCaml (judge verdict: Accepted)

open Printf
open Scanf

module P = struct
  type path = Len of int | Inf | Unk

  let min l1 l2 =
    match l1, l2 with
      Len x, Len y when x < y -> Len x
    | Len x, Len y -> Len y
    | Len x, _ -> Len x
    | _, Len y -> Len y
    | _, _ -> Inf
                
  let add l1 l2 =
    match l1, l2 with
      Len x, Len y -> Len (x + y)
    | _, _ -> Inf
                
  let get = function
      Len x -> x
    | Inf -> (-1)
    | _ -> failwith "get"
end
             
let () =
  let nv, ne = scanf "%d %d " (fun x y -> (x, y)) in
  let g = Array.make_matrix nv nv P.Inf in
  let memo = Array.make_matrix (1 lsl nv) nv P.Unk in
  let set_g n =
    let rec loop x =
      if x = 0 then ()
      else let s, t, d = scanf "%d %d %d " (fun x y z -> (x, y, z)) in
           g.(s).(t) <- P.Len d;
           loop (x-1) in
    loop n in
  let rec search s v =
    match memo.(s).(v) with
      P.Unk -> 
      let rec loop u l =
        if u = nv then l
        else
          if s lsr u land 1 = 0 then loop (u+1) (P.min l (P.add g.(v).(u) (search (s lor (1 lsl u)) u)))
          else loop (u+1) l
      in
      let ml = loop 0 P.Inf in
      memo.(s).(v) <- ml; ml
    | x -> x in
  set_g ne;
  memo.((1 lsl nv) - 1 ).(0) <- P.Len 0;
  printf "%d\n" (P.get (search 0 0))