【算法设计与分析】旅行售货员问题（回溯算法）

问题描述：某售货员要到若干城市去推销商品，已知各城市之间的路程，他要选定一条从驻地出发，经过每个城市一遍，最后回到住地的路线，使总的路程最短。

算法描述：回溯法，排列树。

假设起点为 1，算法开始时 x = [1, 2, 3, ..., n]

x[1 : n]有两重含义 x[1 : i]代表前 i 步按顺序走过的城市， x[i + 1 : n]代表还未经过的城市。利用Swap函数进行交换位置。

若i = n 时，处在排列树的叶节点的父节点上，此时算法检查图G是否存在一条从顶点x[n-1] 到顶点x[n] 有一条边，和从顶点x[n] 到顶点x[1] 也有一条边。若这两条边都存在，则发现了一个旅行售货员的回路即：新旅行路线），算法判断这条回路的费用是否优于已经找到的当前最优回路的费用bestcost，若是，则更新当前最优值bestcost和当前最优解bestx。

若i < n 时，检查x[i - 1]至x[i]之间是否存在一条边, 若存在，则x [1 : i ] 构成了图G的一条路径，若路径x[1: i] 的耗费小于当前最优解的耗费，则算法进入排列树下一层，否则剪掉相应的子树。

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开始搜索，搜索x[2:n]的全排列
        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=1; i<v.length; i++){
            if (i == v.length-1) {
                System.out.print(v[i]);
                break;
            }
            System.out.print(i + "->");
        }
    }
}
// 运行结果：
//  最少花费：25.0
//  0->1->3->2->4