/** * 10.回溯法_旅行售货员问题 * * @author Matt */
public class Bttsp {
    static int n = 4; // 城市数量
    static int[] x; // 当前路径
    static int[] bestx; // 最优路径
    static float bestc; // 最少花费
    static float cc; // 当前花费
    static float m = Float.MAX_VALUE; // 设置最大值-无穷大
    // 邻接矩阵（可达城市之间的花费按二元矩阵表示）
    static float[][] a = { { 0, 0, 0, 0, 0 }, 
            { 0, m, 30, 6, 4 }, 
            { 0, 30, m, 5, 10 }, 
            { 0, 6, 5, m, 20 },
            { 0, 4, 10, 20, m } }; 
    public static float tsp(int[] v) {
        x = new int[n + 1]; // 创建n个城市
        for (int i = 0; i <= n; i++) {
            x[i] = i; // 先进行赋值初始化
        }
        bestc = Float.MAX_VALUE; // 初始化，设置最少花费为浮点型的最大值
        bestx = v; // 最优路径为v
        cc = 0; // 当前花费为0
        backtrack(2); // 从2开始搜索
        return bestc; // 返回最优值
    }

    private static void backtrack(int i) {
        // 当i等于n的情况
        if (i == n) {
            // 若点n-1和点n有连线且点1和n有连线且比最优路径短
            if (a[x[n - 1]][x[n]] < Float.MAX_VALUE && a[x[n]][1] < Float.MAX_VALUE
                    && (bestc == Float.MAX_VALUE || cc + a[x[n - 1]][n] + a[x[n]][1] < bestc)) {
                for (int j = 1; j <= n; j++) {
                    bestx[j] = x[j]; // 将最优路径保存进bestx
                }
                // 最优值
                bestc = cc + a[x[n - 1]][x[n]] + a[x[n]][1];
            }
        } else {
            for (int j = i; j <= n; j++) {
                // 点i-1和点j是否存在路径且比最优路径短
                if (a[x[i - 1]][x[j]] < Float.MAX_VALUE
                        && (bestc == Float.MAX_VALUE || cc + a[x[i - 1]][x[j]] < bestc)) {
                    // 进一步查找
                    swap(x, i, j);
                    cc += a[x[i - 1]][x[i]];
                    backtrack(i + 1); // 查找子树
                    cc -= a[x[i - 1]][x[i]];
                    swap(x, i, j);
                }
            }
        }
    }

    // 对当前解路径中的i和j进行替换
    private static void swap(int[] x, int i, int j) {
        int temp = x[i];
        x[i] = x[j];
        x[j] = temp;
    }

    public static void main(String[] args) {
        // a下标从1开始，0用来凑数
        int[] v = new int[5];
        float bestc = tsp(v);
        System.out.println("最少花费：" + bestc);
        // 路径
        for (int i : v) {
            if (i == v.length-1) {
                System.out.print(i);
                break;
            }
            System.out.print(i + "->");
        }
    }
}
// 运行结果：
// 最少花费：25.0
// 0->1->3->2->4