TSP

旅行商问题,即TSP问题(Traveling Salesman Problem)又译为旅行推销员问题、货郎担问题,是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市,他必须选择所要走的路径,路径的限制是每个城市只能拜访一次,而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。一般分2大类:

  • 完全图:两两城市间都有直达的路线,这条路线不需要经过中间其他节点
  • 非完全图:偶尔有两个城市间的路线需要经过其他中间节点

除了常规的回溯+dfs外,还可以采用述动态规划方法,时间复杂度相对搜索算法来说要高一些,但可以求得最优结果。复杂度近似N*2^(n-1)。

解决这个问题,最需要表达的就是城市选择集合,为程序实现方便,这里用二进制串表示集合。比如集合{1,3,5,6,7}表示成二进制串用1110101,其中集合里面有的数对应的位数写成1,没有的写成0。

则要判断第3位是不是1,就把 1110101右移(3-1)位,得到11101,然后结果和00001进行 & 运算,如果结果是1说明第3位是1,否则说明第3位是0。

标注一下,

对于第y个城市,他的二进制表达为,1<<(y-1)
对于数字x,要看它的第i位是不是1,那么可以通过判断布尔表达式 (((x >> (i - 1) ) & 1) == 1的真值来实现。
要使用动态规划,需要问题本身有最优子结构,我们需要找到要解决的问题的子问题。

题目要求,从0出发,经过[1,2,3]这几个城市,然后回到0,使得花费最少。要实现这个要求,需要从下面三个实现方案中选择花费最少的方案。

1、 从0出发,到1,然后再从1出发,经过[2,3]这几个城市,然后回到0,使得花费最少。

2、 从0出发,到2,然后再从2出发,经过[1,3]这几个城市,然后回到0,使得花费最少。

3、 从0出发,到3,然后再从3出发,经过[1,2]这几个城市,然后回到0,使得花费最少。

可以发现,三个小的解决方案的最优解,构成了大的解决方案,所以这个问题具有最优子结构,可以用动态规划来实现。

设置一个二维的动态规划表dp,定义符号{1,2,3}表示经过[1,2,3]这几个城市,然后回到0。

那么题目就是求dp[0][{1,2,3}]。将{1,2,3}表示成二进制,就是111,对应10进制的7,所以题目是在求dp[0][7];

要求三个方案的最小值意味:

dp[0][{1,2,3}] = min{ C01+dp[1][{2,3}] ,C02+dp[2][{1,3}] ,C03+dp[3][{1,2}]}

其中C01 表示从0出发到1的距离。

dp[1][{2,3}] = min{ C12+dp[2][{3}] ,C13+dp[3][{1}]}

dp[2][{3}] = C23+dp[3][{}]

dp[3][{}]就是从3出发,不经过任何城市,回到0的花费,所以dp[3][{}] = C30

先确定一下dp表的大小,有n个城市,从0开始编号,那么dp表的行数就是n,列数就是2^(n-1),即1 << (n – 1),集合{1,2,3}的子集个数。在求解的时候,第一列的值对应这从邻接矩阵可以导出,后面的列可以有前面的列和邻接矩阵导出。所以求出的动态规划表就是:

初始化第一列,即j=0

for(int i =0;i <n;i++){                      
    dp[i][0] = C[i][0];                        
}
计算第二列:
j = 1;       //可以把j带入
for(int i = 0;i < n;i++){
    dp[i][j] = C[i][1]+dp[1][0]
}

后面的规律比较麻烦的一点在于要集合和二进制转换:

先看我们要求的最终结果:从0出发,经过{1,2,3},最后回到起点,这里的{1,2,3}对应的就是111=7(忘了就查上表)

不难得出:dp[0][7] = min{C01 + dp[1][6], C02+ dp[2][5], C03 + dp[3][3]}

实际上就3种选择,算最小值,一个for循环搞定,但注意到列数好像并没有规律,6,5,3必须要明确出一个算法我们才能用循环搞定。

先看去k=1的路,列6 = (111) ^ (1)得到,(1) = 1城市二进制

再看去k=2的路,列5 = (111) ^ (10)得到。(10) = 2城市二进制

最后看去k=3的路,列3 = (111) ^ (100)得到。(100) = 3城市二进制

公式出来了,列数=j城市的二进制表达=j(1<<(k-1)),我们开始开始构建循环。

但有2个要注意:

1、求dp[2][3]的时候。就是求从2出发,经过{1,2},显然不合理,因为{1,2}包含2了,也就是3包含了城市2,这种情况需要忽略掉。也就是判断数字3的二进制位的第2位是不是1,是1就表示不合理。判断条件为之前说到的:(((x >> (i - 1) ) & 1) == 1

2、求dp[2][5]的时候。就是求从2出发,经过{1,3},这时不会有k=2这条路,因为{1,3}并不含有2,需要排除掉。也就是判断数字5的二进制位的第2位是不是1,是1就可以走,不是1就不用算了。

根据以上的推导,最后求dp表的代码实现就是:

for(int j = 1;j < 1 << (n - 1);j++){        
    for(int  i= 0;i < n;i++){               
        dp[i][j] = 0x7ffff;
        if(((j >> (i - 1)) & 1) == 1){          
            continue;   
        }   
        for(int k = 1;k < n;k++){       
            if(((j >> (k - 1)) & 1) == 0){
                continue;                           
            }
            if(dp[i][j] > C[i][k] + dp[k][j ^ (1 << (k - 1))]){
                dp[i][j] = C[i][k] + dp[k][j ^ (1 << (k - 1))];
            }
        }
    }
}

最终程序的返回值就是dp表左上角的那个数字return dp[0][(1<<(cityCount - 1)) - 1];

一个完整运行的例子是:

public class TravelingSalesman {
    public static void main(String[] args) {
        int cityCount = 4;
        int[][] roadInfo = new int[][]{
             {0, 1, 10},
             {1, 0, 10},
             {1, 3, 25},
             {3, 1, 25},
             {3, 2, 30},
             {2, 3, 30},
             {0, 2, 15},
             {2, 0, 15},
             {1, 2, 35},
             {2, 1, 35}
        };
        
        int roadmap[][] = new int[cityCount][cityCount];        //转成邻接矩阵方便取数
        int dp[][] = new int [cityCount][1 << (cityCount - 1)];
        string path[][] = new string [cityCount][1 << (cityCount - 1)];
        for(int i = 0;i < cityCount;i++){
            for(int j = 0;j < cityCount;j++){    
                roadmap[i][j] = 0x7ffff;                        //用0x7ffff表示无穷大
            }
        }
        for(int i = 0;i < roadInfo.length;i++){                 //邻接矩阵
            roadmap[roadInfo[i][0]][roadInfo[i][1]] = roadInfo[i][2];
        }
 
        for(int i =0;i <cityCount;i++){                          //先求dp表第一列
            dp[i][0] = roadmap[i][0];                            //求出了每个城市回到起点的距离了。
            path[i][j]=i;                                        //记录初始路径。
        }
                                                
        for(int j = 1;j < 1 << (cityCount - 1);j++){             //再求其他列
            for(int  i= 0;i < cityCount;i++){                    //从i出发,要去包含j = {010101}的    城市
                dp[i][j] = 0x7ffff;
                if(((j >> (i - 1)) & 1) == 1){                   //如果已经到过j了,就continue
                    continue;    
                }    
                for(int k = 1;k < cityCount;k++){                 //看能不能先到k城市
                    if(((j >> (k - 1)) & 1) == 0){
                        continue;                                 //不能先到k城市,continue;
                    }
                    if(dp[i][j] > roadmap[i][k] + dp[k][j ^ (1 << (k - 1))]){
                        dp[i][j] = roadmap[i][k] + dp[k][j ^ (1 << (k - 1))];
                        path[i][j]=i+path[k][j ^ (1 << (k - 1))]; //找到更短路径,覆盖之前结果。
                    }
                }
            }
        }
        System.out.println(dp[0][(1<<(cityCount - 1)) - 1]);
        System.out.println(path[0][(1<<(cityCount - 1)) - 1]);
    }
}

猜你喜欢

转载自blog.csdn.net/ThreeAspects/article/details/105828178
TSP