旅行商问题分析（分支限界法）

一、题目

二、思路

1、dfs

实验要求用多种思路完成，所以一开始就沿用了上一个实验马走棋盘的思路，添加了邻接矩阵来记录有向网的权值。总体思路还是DFS遍历搜索。

过程剪枝：

1、因为要求为最短路径，而一般情况总会存在多条可行路径，在判断过程中需要走过每一条路径才能知道该路径的长度，但如果已知一条可行路径的长度，在计算另一条路径的时候，若还未完成巡回但此时路径长度已经大于已知最短可行路径，那么这条路的最终长度就必定大于已知最短路径，此时就可以不必接下去计算当前路径。

2、之前得出的路径长度可以帮助之后的路径进行快速判断，如果我们尽早得出较短的可行路径，之后的工作也会进行得更快，由剪枝1引出剪枝2，每次选择到下一点路径长度最短的点前进，这样就能较快得到较短的可行路径。

2、分支限界法

　　按照书本上教我们的思路来实现分支限界法，首先对邻接矩阵进行初始化，求出其的最小下界和对应的矩阵，然后以这个矩阵为根节点，开始进行类似二叉树的遍历。

　　在这个过程中，需要保持矩阵每行或每列都必须有一个以上的0，还需要一个函数来找出所有行中最小数中最大的。然后下一步就要决定是否走该行距离为0的点，如果选择走，就将点对应的行和列去掉，若不选择该点，则将该点置为无穷大。并比较选与不选情况下的下界变化，选择下界较小的情况继续进行递归处理，直到矩阵消失或剩下全为无穷大的不可到达点。

　　遇到问题：根据以上的逻辑，在实际解决过程中，出现了爆栈的情况，通过调试发现程序运行情况和书本上不一样，书本上有一些变化并没有说明清楚，那么就需要重新考虑程序的递归出口解决爆栈问题。

　　

最后根据书上的情况得修改为一共三种递归出口判断：

1、  若剩下的全是无穷远或0（默认跳过-1即不存在的）

2、  若剩下全是无穷远

3、  若剩下全是0

若满足以上任意一种判断，可以直接得出当前下界即为最短路径。

三、复杂度分析

以DFS为主要算法，O(e+v)

时间复杂度（V边数+ E顶点数）

实际复杂度比上述要小，因为在实际中并不会完整遍历所有可行路径。

分支限界法完成比较匆忙，代码中要多次循环遍历数组，存在诸多冗余，若不急循环，程序需要的步数及为顶点数，当不断的循环判断使得复杂度难以估计。

　　

三、实现代码

1、DFS

public class Sell {
    static int[][] byGroup;// 邻接矩阵
    static int[] visit;// 0表示未访问 1表示访问
    static int N;// 点的个数
    static int minstep = 10000;// 最小步数

    class ToNode {
        int n;// 第n个点
        int L;//// 当前点到第n个点的距离

        public ToNode(int n, int l) {
            this.n = n;
            this.L = l;
        }
    }

    public static Comparator<ToNode> LComparator = new Comparator<ToNode>() {// 优先队列的比較方法（到下一点的距离近到远
        @Override
        public int compare(ToNode tn1, ToNode tn2) {
            return tn1.L - tn2.L;
        }
    };

    public void init() {
        Scanner sc = new Scanner(System.in);
        System.out.println("please int N:");
        N = sc.nextInt();
        byGroup = new int[N][N];
        visit = new int[N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                System.out.println("please int " + i + "-->" + j + " weight:");
                byGroup[i][j] = sc.nextInt();
            }
        }
        DFS(0, 0);// 从0点开始
    }

    public void DFS(int n, int step) {
        if (visit[n] != 0 || step >= minstep) {// 当前点走过或当前已走长度大于已知最小可行长度
            return;
        }
        if (step != 0) {// 第一次不赋值
            visit[n] = 1;
        }
        int flag = 1;
        for (int k = 0; k < visit.length; k++) {//判断是否走完所有点
            if (visit[n] == 0) {
                flag = 0;
                break;
            }
        }
        if (flag == 1 && n == 0) {// 巡回完成的判断
            System.out.println("巡回完成");
            if (step < minstep) {// 修改最短可行路径长度
                minstep = step;
            }
            System.out.println("now donestep is:" + step);
        }
        Queue<ToNode> nodePriorityQueue = new PriorityQueue<>(N, LComparator);// 每次來個優先隊列從小到大
        for (int i = 0; i < byGroup[0].length; i++) {
            if (i != n) {
                nodePriorityQueue.add(new ToNode(i, byGroup[n][i]));
            }
        }
        while (!nodePriorityQueue.isEmpty()) {// 回溯
            ToNode tn = nodePriorityQueue.poll();
            DFS(tn.n, step + tn.L);
        }
    }

    public static void main(String[] args) {
        Sell s = new Sell();
        s.init();
        System.out.println("mini step is: " + minstep);
    }
}

2、分支限界法

public class Sell2 {
    static int[][] group = { { -2, 17, 7, 35, 18 }, { 9, -2, 5, 14, 19 }, { 29, 24, -2, 30, 12 },
            { 27, 21, 25, -2, 48 }, { 15, 16, 28, 18, -2 } };
    //-1表示不存在 -2表示无穷大到不了
    //static int[] flag;//初始化时判断
    static int[] hmin;// 每行对应的最小值
    static int bound;
    static int N = 5;
    static int[] hz = new int[5];// 用来记录该行是否已经全为-1

    public void init() {// 初始化分支界限树的根节点
        Scanner sc = new Scanner(System.in);
        System.out.println("please int N:");
        // N = sc.nextInt();
        // group = new int[N][N];
        // group
        int[] flag = new int[N];
        hmin = new int[N];
        /*
         * for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) {
         * System.out.println("please int " + i + "-->" + j + " weight:"); group[i][j] =
         * sc.nextInt(); } }
         */
        int minh;
        for (int i = 0; i < group[0].length; i++) {// 对行找最小并减去
            minh = 10000;
            for (int j = 0; j < group[0].length; j++) {// 找当前行的最小值
                if (group[i][j] != -1 && group[i][j] != -2 && group[i][j] < minh) {
                    minh = group[i][j];
                }
            }
            bound += minh;
            for (int j = 0; j < group[0].length; j++) {// 对每个数减去最小值并给flag赋值
                if (group[i][j] != -1 && group[i][j] != -2) {
                    group[i][j] -= minh;
                    if (group[i][j] == 0) {
                        flag[j] = 1;
                    }
                }
            }
        }
        int minl;
        for (int i = 0; i < flag.length; i++) {
            if (flag[i] != 1) {// 第i列
                minl = 10000;
                for (int j = 0; j < group[0].length; j++) {// 找当前列的最小值
                    if (group[j][i] != -1 && group[j][i] != -2 && group[j][i] < minl) {
                        minl = group[j][i];
                    }
                }
                bound += minl;
                for (int j = 0; j < group[0].length; j++) {// 对每个数减去最小值并给flag赋值
                    if (group[j][i] != -1 && group[i][j] != -2) {
                        group[j][i] -= minl;
                    }
                }
            }
        }
    }

    int minh = 10000;
    int bigMin = 0;// 所有行的最小数中最大的

    public void tree() {
        System.out.println(bound);
        int x, y = 0;// 每次对应的要或不要的点(x,y)
        // ********************************************************如果
        if (isDone1() == 1 || isDone2() == 0 || isDone3() == 0) {// 判断完成
            System.out.println("okk");
            System.exit(1);
        }
        x = findh();// 每行最小中最大的那个数的行
        for (int i = 0; i < N; i++) {
            if (group[x][i] == 0) {
                y = i;
            }
        }
        if (need(x, y) > dontneed(x, y)) {// 不要这个点
            group[x][y] = -2;
            // 检测每行是否都有0
            int havaz = 0;
            for (int i = 0; i < N; i++) {
                havaz = 0;
                for (int j = 0; j < N; j++) {
                    if (group[i][j] == 0) {
                        havaz = 1;// 有0
                    }
                }
                if (havaz == 0) {// 第i行没0
                    bound += hmin[i];
                    for (int t = 0; t < N; t++) {
                        if (group[i][t] != -2 && group[i][t] != -1) {
                            group[i][t] -= hmin[i];
                        }
                    }
                }
            }
            tree();// 递归
        } else {// 要这个点
            hz[x] = 1;
            if (group[y][x] != -1) {
                group[y][x] = -2;
            }
            for (int i = 0; i < N; i++) {// 把行消除
                group[x][i] = -1;
            }
            for (int i = 0; i < N; i++) {// 把列消除
                group[i][y] = -1;
            }
            // 检测每行是否都有0
            int havaz = 0;
            for (int i = 0; i < N; i++) {
                if (hz[i] != 1) {
                    havaz = 0;
                    for (int j = 0; j < N; j++) {
                        if (group[i][j] == 0) {
                            havaz = 1;// 有0
                        }
                    }
                    if (havaz == 0) {
                        bound += hmin[i];
                        for (int t = 0; t < N; t++) {
                            if (group[i][t] != -2 && group[i][t] != -1) {
                                group[i][t] -= hmin[i];
                            }
                            // group[i][t] -= hmin[i];
                        }
                    }
                }

            }
            tree();// 递归
        }
    }

    // 要和不要这个点对应的bound
    private int need(int x, int y) {
        int needbound = bound;
        for (int i = 0; i < N; i++) {// 去掉行
            group[x][i] = -1;
        }
        for (int i = 0; i < N; i++) {// 去掉列
            group[i][y] = -1;
        }
        // 检测每行是否都有0
        int havaz;
        for (int i = 0; i < N; i++) {
            if (hz[i] != 1) {
                havaz = 0;
                for (int j = 0; j < N; j++) {
                    if (group[i][j] == 0) {
                        havaz = 1;// 有0
                    }
                }
                if (havaz == 0) {
                    needbound += hmin[i];
                }
            }

        }
        return needbound;
    }

    private int dontneed(int x, int y) {
        int dontneedbound = bound;
        // 检测每行是否都有0 (去掉xy点)
        int havaz;
        for (int i = 0; i < N; i++) {
            if (hz[i] != 1) {
                havaz = 0;
                for (int j = 0; j < N; j++) {
                    if (i != x && j != y && group[i][j] == 0) {
                        havaz = 1;// 有0
                    }
                }
                if (havaz == 0) {// 这行没0
                    dontneedbound += hmin[i];
                }
            }
        }
        return dontneedbound;
    }

    private int findh() {// 找出每行最小中最大的那个数在哪一行
        int bigMin = 0;// 所有行的最小数中最大的
        int minh, h = 0;
        for (int i = 0; i < group[0].length; i++) {// 对行找最小并减去
            if (hz[i] != 1) {
                minh = 10000;
                for (int j = 0; j < group[0].length; j++) {// 找当前行的最小值
                    if (group[i][j] != -1 && group[i][j] != -2 && group[i][j] != 0 && group[i][j] < minh) {
                        minh = group[i][j];
                    }
                }
                hmin[i] = minh;// 更新当前行的最小值
                if (minh >= bigMin) {
                    bigMin = minh;
                    h = i;
                }
            }

        }
        return h;
    }

    private int isDone1() {// 判断是否完成
        int zn = 0;// 0的个数 如果只剩一个0就完成
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (group[i][j] == 0) {
                    ++zn;
                }
            }
        }
        return zn;// 返回当前一共有几个0
    }

    private int isDone2() {// 判断是否完成 如果除了-2就是0或-1 也算完成
        int haszt = 0;// 不是0和-2的个数
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (group[i][j] != 0 || group[i][j] != -2 || group[i][j] != -1) {
                    ++haszt;
                }
            }
        }
        return haszt;
    }

    private int isDone3() {// 判断3
        int haszt = 0;// 不是-2的个数
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (group[i][j] != -2) {
                    ++haszt;
                }
            }
        }
        return haszt;
    }

    public static void main(String[] args) {
        Sell2 s2 = new Sell2();
        s2.init();
        s2.tree();
        System.out.println("bound:" + bound);
    }
}