回溯法 | 旅行商问题（TSP问题）

学习链接：

回溯法解旅行商问题(TSP)、贪心算法：旅行商问题（TSP）

---

今天早上做了无数个梦，然后被紧紧地吸附在床上。挣扎一番后爬起来，已经是9点了。然后我开始研究旅行商问题。

在一个无向图中找到一个可以遍历所有节点的一个最短回路。理论上说可以用全排列列出所有解的下标，然后一个一个试，时间复杂度o(n!)。但是可以用回溯法，用【约束函数】（constraint）判断当前路径是否连通，用【界限函数】（bound）判断当前路径是否比已经求得的最短路径小。这两个判断任意一个不符，则做“剪枝操作”（不再对后续节点进行遍历）。

可以看出回溯法比穷举要高明的多。这个回溯法和八皇后问题也有一些区别。TSP问题需要构造一棵排列树：

根节点为｛０｝

第一层｛０,１｝

第二层｛０,１,２｝，｛０,２,１｝

第三层｛０,１,２,３｝，｛０,１,３,２｝，｛０,２,１,３｝，｛０,２,３,１｝，｛０,３,１,２｝，｛０,３,２,１｝

……

并且回溯法要求对图进行ＤＦＳ操作，即深度优先搜索。因为需要首先首次找到最深处的节点，才能设置当前最优解，好让后续问题能有参考。

Java代码：

 public class Main {
 
     public static void main(String[] args) {
         int[][] adjMatrix={
                 {0,20,6,4},
                 {20,0,5,10},
                 {6,5,0,15},
                 {4,10,15,0},
         };
         TSP problem=new TSP(adjMatrix);
 
     }
 }
 
 class TSP{
     int vexnum=0;//顶点数目
     int adjMatrix[][];
     TSP(int[][] adjMat){
         adjMatrix=adjMat;
         vexnum=adjMatrix.length;
         int init[]={0};
         Backtrack(1,init);
         int a;
         a=0;
     }
     int bestCost=0;
     int[] bestX;//最优解向量
     boolean isTraverseDeep=false;
     //回溯法递归
     //初始x：[0]
     void Backtrack(int t,int[] x){//对顶点t进行操作，父结点的解向量是x，
         if(t>=vexnum){//解向量的第一个元素应该是初始顶点，如0，最后一个元素也是0
             x[t]=0;//最后一个节点赋值：0。
             constraint(x,t);
 
         }else{//所有顶点都解完
             int i,j;
             int cx[]=new int[vexnum+1];
             for(j=0;j<t;j++) cx[j]=x[j];//拷贝父结点
             cx[t]=t;
             if(constraint(cx,t)) Backtrack(t+1,cx);//不交换的情况下进行递归
             //不断递归调用【Backtrack】，进行DFS
             for(i=1;i<t;i++){
                 cx=new int[vexnum+1];
                 for(j=0;j<t;j++) cx[j]=x[j];//拷贝父结点
                 cx[t]=t;
                 swap(cx,i,t);
                 if(constraint(cx,t)) Backtrack(t+1,cx);//交换的情况下进行递归
             }
         }
     }
     boolean constraint(int[] x,int len){//对解进行约束
         int cost=0;
         int i;
         int pre=x[0];
         for(i=1;i<=len;i++){
             int dist=adjMatrix[pre][x[i]];
             if(dist<=0) return false;//不连通，则为否。约束（constraint）函数
             cost+=dist;
             pre=x[i];
         }
         if(isTraverseDeep){//如果已经进行了最底部的遍历，则对这个当前花费进行判别。界限（bound）函数
             if(cost<bestCost){//比最优解要小
                 if(len==vexnum){//已经遍历完
                     bestCost=cost;
                     bestX=x;//设置最优解向量
                 }
                 return true;
             }else return false;
         }else if(len==vexnum){//首次遍历到底部
             bestCost=cost;
             bestX=x;//设置最优解向量
             isTraverseDeep=true;
             return true;
         }
         return true;
     }
     private void swap(int[] nums,int a,int b){
         int tmp=nums[a];
         nums[a]=nums[b];
         nums[b]=tmp;
     }
 }