[编程题]毕业旅行问题

[编程题]毕业旅行问题
时间限制：1秒

空间限制：32768K

小明目前在做一份毕业旅行的规划。打算从北京出发，分别去若干个城市，然后再回到北京，每个城市之间均乘坐高铁，且每个城市只去一次。由于经费有限，希望能够通过合理的路线安排尽可能的省一些路上的花销。给定一组城市和每对城市之间的火车票的价钱，找到每个城市只访问一次并返回起点的最小车费花销。

输入描述:
城市个数n（1<n≤20，包括北京）

城市间的车票价钱 n行n列的矩阵 m[n][n]

输出描述:
最小车费花销 s

输入例子1:
4
0 2 6 5
2 0 4 4
6 4 0 2
5 4 2 0

输出例子1:
13

例子说明1:
共 4 个城市，城市 1 和城市 1 的车费为0，城市 1 和城市 2 之间的车费为 2，城市 1 和城市 3 之间的车费为 6，城市 1 和城市 4 之间的车费为 5，依次类推。假设任意两个城市之间均有单程票可购买，且票价在1000元以内，无需考虑极端情况。

运行超时，但是不知道这种方法与dp矩阵相比差在哪

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] citys = new int[n][n];
        for(int i = 0; i < n; ++i){
            for(int j = 0; j < n; ++j){
                citys[i][j] = sc.nextInt();
            }
        }

        List<Integer> gone = new LinkedList<>();
        for(int i = 1; i < n; ++i) gone.add(i);
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < gone.size(); ++i){
            int temp_int = gone.get(i);
            gone.remove(i);
            min = Math.min(min, fun(temp_int, gone, citys) + citys[0][temp_int]);
            gone.add(i, temp_int);
        }

        System.out.println(min);
    }

    public static int fun(int head, List<Integer> gone, int[][] citys){
        if(gone.size() == 0){
            return citys[head][0];
        }
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < gone.size(); ++i){
            int temp_int = gone.get(i);
            gone.remove(i);
            min = Math.min(min, fun(temp_int, gone, citys) + citys[head][temp_int]);
            gone.add(i, temp_int);
        }

        return min == Integer.MAX_VALUE ? citys[head][0] : min;
    }
}

牛客网上 阿武201807061521133 的代码
链接：https://www.nowcoder.com/questionTerminal/3d1adf0f16474c90b27a9954b71d125d?orderByHotValue=1&page=1&onlyReference=false
来源：牛客网
注意矩阵的横坐标的排列形式，如果是5X5的矩阵，横坐标是
0 1 2 12 3 13 23 123 4 14 24 124 34 134 234 1234
总共16个

public class Main{
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] map = new int[n][n];
        for(int i=0;i<n;i++) {
            for(int j=0;j<n;j++) {
                map[i][j] = in.nextInt();
            }
        }
        //dp[i][j]表示从i出发，经过j集合里的所有节点一次回到0点的最小小费
        int V = 1<<(n-1);  //
        int[][] dp = new int[n][V];
        for(int i=0;i<n;i++) {     // 先求dp表第一列
            dp[i][0] = map[i][0];   //每个城市回到起点的距离
        }
 
        for(int j=1;j<V;j++) {                  // 再求其他列
            for(int i=0;i<n;i++) {              //从i出发，要去包含j = {010101} 的城市
//                dp[i][j] = 100000;               //或者用 0x7ffff表示无穷大
                dp[i][j] = 0x7ffff;
                if(((j >> (i-1)) & 1) == 1) {    //如果已经到过j了，就continue跳出循环
                    continue;
                }
                for(int k=1;k<n;k++) {          //看能不能先到k城市
                    if(((j >> (k-1)) & 1) == 1) {  //能到
                        dp[i][j] = Math.min(dp[i][j], map[i][k] + dp[k][j ^ (1 << (k-1))]);
                    }
                }
            }
        }
        System.out.println(dp[0][(1 << (n-1))-1]);
 
        /*
         *以下为打印dp表
         */
        System.out.printf("%10d",0);
        for(int j = 0;j < 1 << (n - 1) ;j++){
            System.out.printf("%10d",j);
        }
        System.out.println();
        for(int i = 0;i < n;i++){
            System.out.printf("%10d",i);
            for(int j = 0;j < 1 << (n - 1) ;j++){
                if(dp[i][j] == 0x7ffff) dp[i][j] = -1;
                System.out.printf("%10d",dp[i][j]);
            }
            System.out.println();
        }
 
    }
}