算法论文：旅行商问题的求解方法(动态规划法和贪心法)
旅行商问题的求解方法
摘要
旅行商问题（TSP问题）时是指旅行家要旅行n个城市然后回到出发城市，要求各个城市经历且仅经历一次，并要求所走的路程最短。该问题又称为货郎担问题、邮递员问题、售货员问题，是图问题中最广为人知的问题。本文主要介绍用蛮力法、动态规划法、贪心法和分支限界法求解TSP问题，其中重点讨论动态规划法和贪心法，并给出相应求解程序。
关键字：旅行商问题；动态规划法；贪心法；分支限界法
1引言
旅行商问题(TSP)是组合优化问题中典型的NP-完全问题，是许多领域内复杂工程优化问题的抽象形式。研究TSP的求解方法对解决复杂工程优化问题具有重要的参考价值。关于TSP的完全有效的算法目前尚未找到，这促使人们长期以来不断地探索并积累了大量的算法。归纳起来，目前主要算法可分成传统优化算法和现代优化算法。在传统优化算法中又可分为：最优解算法和近似方法。最优解算法虽然可以得到精确解，但计算时间无法忍受，因此就产生了各种近似方法，这些近似算法虽然可以较快地求得接近最优解的可行解，但其接近最优解的程度不能令人满意。但限于所学知识和时间限制，本文重点只讨论传统优化算法中的动态规划法、贪心法和分支限界法，并对蛮力法做简单介绍，用以比较。
2正文
2.1蛮力法
2.1.1蛮力法的设计思想
蛮力法所依赖的基本技术是扫描技术，即采用一定的策略将待求解问题的所有元素一次处理一次，从而找出问题的解。一次处理所有元素的是蛮力法的关键，为了避免陷入重复试探，应保证处理过的元素不再被处理。在基本的数据结构中，一次处理每个元素的方法是遍历。
2.1.2算法讨论
用蛮力法解决TSP问题，可以找出所有可能的旅行路线，从中选取路径长度最短的简单回路。如对于图1，我们求解过程如下：
（1）路径：1->2->3->4->1；路径长度：18；
（2）路径：1->2->4->3->1；路径长度：11；
（3）路径：1->3->2->4->1；路径长度：23；
（4）路径：1->3->4->2->1；路径长度：11；
（5） 路径：1->4->2->3->1；路径长度：18；
（6） 路径：1->4->3->2->1；路径长度：18；
从中，我们可以知道，路径（2）和（4）路径长度最短。
我们还应注意到，图1中，有3对不同的路径，对每对路径来说，不同只是路径的方向，因此，可以将这个数量减半，则可能的解有（n-1）！/2个。这是一个非常大的数，随着n 的增长，TSP 问题的可能解也在迅速增长。如：
一个10城市的TSP 问题有大约有180,000个可能解。一个20城市的TSP 问题有大约有60,000,000,000,000,000个可能解。 一个50城市的TSP 问题有大约1062个可能解，而一个行星上也只有1021升水。因此，我们可以知道用蛮力法求解TSP 问题，只能解决问题规模很小的实例。
2.2动态规划法
2.2.1动态规划法的设计思想
动态规划法将待求解问题分解成若干个相互重叠的子问题，每个子问题对应决策过程的一个阶段，一般来说，子问题的重叠关系表现在对给定问题求解的递推关系（也就是动态规划函数）中，将子问题的解求解一次并填入表中，当需要再次求解此子问题时，可以通过查表获得该子问题的解而不用再次求解，从而避免了大量重复计算。
2.2.2TSP 问题的动态规划函数
假设从顶点i 出发，令'(,)d i V 表示从顶点i 出发经过'V 中各个顶点一次且仅一次，最后回到出发点i 的最短路径长度，开始时，{}'V V i =-，于是，TSP 问题的动态规划函数为：
{}{}{}''(,)min (,)()
(,)()ik ki d i V c d k V k k V d k c k i =+-∈=≠
2.2.3算法讨论
（1）for (i=1; i d[i][0]=c[i][0]; （2）for (j=1; j< n-12 -1; j++) for (i=1; i if (子集V[j]中不包含i) 对V[j]中的每个元素k ，计算V[m] == V[j]-k; d[i][j]=min(c[i][k]+d[k][m]); （3）对V[n-12 -1]中的每一个元素k ，计算V[m] == V[n-12 -1]-k; d[0][ n-12 -1]=min(c[0][k]+d[k][m]); （4）输出最短路径长度d[0][ n-12 -1]; 2.3.4时间复杂性 T()(2)n n O n =? 和蛮力法相比，动态规划法求解TSP 问题，把原来的时间复杂性是O(n!)的排列问题，转化为组合问题，从而降低了算法的时间复杂性，但它仍需要指数时间。 2.3贪心法 2.3.1贪心法的设计思想 贪心法在解决问题的策略上目光短浅，只根据当前已有的信息就做出选择，而且一旦做出了选择，不管将来有什么结果，这个选择都不会改变。换言之，贪心法并不是从整体最优考虑，它所做出的选择只是在某种意义上的局部最优。这种局部最优选择并不总能获得整体最优解，但通常能获得近似最优解。 2.3.2最近邻点策略求解TSP 问题 贪心法求解TSP 问题的贪心策略是显然的，至少有两种贪心策略是合理的：最近邻点策略和最短链接策略。本文仅重点讨论最近邻点策略及其求解过程。 最近邻点策略：从任意城市出发，每次在没有到过的城市中选择距离已选择的城市中最近的一个，直到经过了所有的城市，最后回到出发城市。 2.3.3算法讨论 1．P={ }; 2．V=V-{u0}; u=u0; //从顶点u0出发 3．循环直到集合P 中包含n-1条边 3.1查找与顶点u 邻接的最小代价边(u, v)并且v 属于集合V ； 3.2 P=P+{(u, v)}; 3.3 V=V-{v}; 3.4 u=v; //从顶点v 出发继续求解 2.3.4时间复杂性 2()T O n = 但需注意，用最近邻点贪心策略求解TSP 问题所得的结果不一定是最优解。当图中顶点个数较多并且各边的代价值分布比较均匀时，最近邻点策略可以给出较好的近似解，不过，这个近似解以何种程度近似于最优解，却难以保证。 2.4分支限界法 2.4.1分支限界法的设计思想 假设求解最大化问题，解向量为12(,,...,)n X x x x =，其中，i x 的取值范围为某个有穷集合i S ，||(1)i i S r i n =≤≤。在使用分支限界法搜索问题的解空间树时，首先根据限界函数估算目标函数的界[down, up]，然后从根结点出发，扩展根结点的1r 个孩子结点，从而构成分量1x 的1r 种可能的取值方式。对这1r 个孩子结点分别估算可能取得的目标函数值1()bound x ，其含义是以该孩子结点为根的子树所可能取得的目标函数值不大于1()bound x ，也就是部分解应满足： 1121212()(,)...(,,...,)...(,,...,)k n bound x bound x x bound x x x bound x x x ≥≥≥≥≥ 本文本欲详细讨论该算法，但无奈在编程问题中，尚有问题有待解决，时间所限，不得已放弃。本人编程过程中所用算法思想与老师课上所教略有不同，在寻找下界时，是首先把每个结点所能到达的各个结点及其可能的路径算出来，并添加到PT表中，但最后，不知是何原因，在还有一个城市尚未加入时，PT表的添加出现了问题，思忖良久，仍未解决，时间所限，迫不得已，留待以后有时间再另行研究，本文就只给出动态规划法和贪心法的具体求解过程。 3结论 本文主要重点讨论了动态规划法和贪心法求解TSP问题算法，并附录给出了相应程序。 3.1动态规划法思想 动态规划法中对于顶点元素生成的子集本文中用字符串形式存储，然后再用递归方法按照子集中元素个数从小到大开始赋值。因为后面元素个数较多的子集与前面比其元素个数少1的子集间有一定对应关系，所以用递归方式，可以简便很多。个人觉得这算本文的一大特色。另，在计算d[i][j] =min(c[i][k]+d[k][j-1])时，获得d[k][j-1]的过程比较困难，运用字符串后，我们就可以首先找到指定字符，然后去掉该字符，返回剩余字符串，在与V[]逐个比较，找到与其相等的V[]中元素对应下标，此下标即为j-1；具体求解过程可参考附录源程序，有详细说明。在求解最佳路径所经过城市顺序时，本文是通过边查找d[i][j]边记录路径的，这样可以省掉很多麻烦，另，路径也是采用字符串形式的数组，数组规模与存储城市间距离的c[][]数组相同，由于很多元素均不需赋值，这样做可能会浪费内存空间，但是目前还没找到更好地求解方法。 3.2贪心法思想 贪心法中，由于贪心法相对动态规划法要简单很多，每次在查找最近城市时所得的顶点均为最后该法最佳路径所经过的城市编号，规模相对较小，容易确定，操作相对简单，所以本文用数组V[]存放最佳路径所经过的城市编号顺序相对来说方便很多。另外，本文用path[]整型数组存放所经路径的长度，最后相加即可得最短路径。 3.3两者比较 动态规划法相对贪心法来说虽然要精确些，但代码相对繁杂很多，对时间和空间要求很多，仅适用于城市数量较小的情况。贪心法虽然比较简单，实现起来比较容易，但不是很精确，当图中顶点个数较多并且各边的代价值分布比较均匀时，贪心法可以给出较好的近似解，不过，这个近似解以何种程度近似于最优解，却难以保证。 另外，动态规划法有一个明显的缺点，就是出发城市只能是第0个城市（城市从0开始编号），若出发城市改变，则必须以该城市为第0个城市顺序给其他城市编号，输入城市间距离。由于若出发城市任意，编码的难度大大增加，所以最后不得已放弃，但这大大地限制了程序的通用性。而对于贪心法，本文很好地避免了这个问题，一旦城市编号确定，可以从任意城市出发，这也是本文中贪心法优于动态规划法的一点。 3.4优点 本文程序优点，各个子函数功能分隔很明显，没有大量集中在一个函数里面，而是分成了几个不同功能的小函数，这样程序可阅读性提高。另外，程序中有详细注释，程序中变量取名都是根据变量的性质和所代表的含义命名的，也相应提高了程序的可读性。 对于动态规划法，城市个数可以在算法时间允许的范围内任意，于这点来说，通用性较好；对于贪心法，出发城市可以任意，城市个数也可以任意，通用性较好。 4建议 当城市个数较少时，用动态规划法求出最优解；当城市个数较多并且各边的代价值分布比较均匀时，贪心法可以给出较好的近似解。 5参考文献 （1）《计算机算法分析与设计》第二版，王晓东编著，电子工业出版社 （2）Java语言与面向对象程序设计（第2版）印旻、王行言编著，清华大学出版社 （3）求解TSP算法，周康、强小利、同小军、许进，计算机工程与应用 6附录 6.1动态规划法 6.1.1源代码 package exp2; import java.util.Scanner; public class TSPDynamic { String[] V;//顶点生成的子集，这里把每一个子集用一个字符串表示 int[][] c;//顶点间距离 int[][] d;//存放迭代结果 int N; //城市个数 String[][] path;//用于存放每种选择下经过的城市 static int IFINITE= 99999;//无穷大距离表示城市自己到达自己时，距离无穷大，不作为考虑因素 //构造函数 public TSPDynamic(){ initialC(); initialV1(); } //初始化数组c[]，即顶点间距离 public void initialC(){ Scanner in = new Scanner( System.in ); System.out.println("请输入城市个数：（注意根据实际情况城市个数不可小于1！）"); N = in.nextInt(); if(N <= 1){ S ystem.out.println("不符合要求，请认真核对！"); S ystem.exit(0);//输入错误，结束！ } System.out.println("请输入城市相邻城市间距离（城市从0开始编号，且出发城市为第0个城市！）： "); c = new int[N][N];//为c分配空间 for(int i = 0 ; i < N ; i ++) for(int j = 0 ; j < N ; j ++){ c[i][j] = in.nextInt(); //输入时，按城市编号从小到大，如若两城市间没有公路相连，则距离为无穷大。本城市与本城市间距离也为无穷大。 } } //初始化顶点生成的子集的对外调用函数 public void initialV1(){ V = new String[(int)Math.pow(2,N-1)];//为V分配空间 initialV(0,0); } //具体的初始化顶点生成的子集 //本程序使用递归调用方法初始化V，并按照数字大小顺序排序。。另，子集使用字符型形式存放的 //我们是按照子集中元素个数从小到大逐个添加的，后面的子集是前面对应子集加上一个元素组成的，故用递归 public void initialV(int m , int len) {//m代表下一个即将初始化的V数组的元素的下标；len是最后一个初始化的元素的长度if(m > (int)Math.pow(2,N-1) - 1)return;//如果全部顶点已初始化完成，则返回。 if(m == 0)V[m ++] = "";//初始化出发顶点，即V[0] else{ int i = m - 1; while(i >= 0 && V[i].length() == len)//找与最后一个初始化的V[m-1]子集内元素个数相同的集合，把指针i指向满足条件的集合 i --; i ++;//把指针i指向满足条件的第一个集合 while(i < m){ int ch;//用于表示下一个即将加入子集的数字 if(i == 0)ch = 0;//如果i指向V中第一个元素 else{ String chStr = "" + V[i].charAt(V[i].length() - 1);//找出V[i]中最后一个数字 ch = Integer.parseInt(chStr);//转换成整型 } //比ch大而又比N-1(因为这里顶点是从0开始的)小的数字应该加在子集中 while(ch < N - 1) V[m ++] = V[i] + (++ ch); i ++;//对已存在的自己逐个扫描添加 } } initialV(m,V[m - 1].length());//递归调用 } //判断自己V[j]中是否存在指定元素，即行号i boolean exclude(int i , int j){ String str = "" + i;//把i转换成字符串 if(V[j].contains(str)) //{System.out.println(i + "i"); return false;//如若存在，则返回false else return true; } //获得子集V[j]中除指定元素k外的元素，用字符串形式表示 public String getSubString(int k , int j){ if(V[j].length() == 1)return"";//如果子集中只有一个元素，则返回空串 else{ if(k == 0) return V[j].substring(1,V[j].length());//如果k是第一个元素，则返回其后面的元素 else if(k == V[j].length() - 1) return V[j].substring(0, V[j].length()-1);//如果k是最后一个元素，则返回其前面的元素 else return (V[j].substring(0, k) + V[j].substring(k+1, V[j].length()));//返回除k外的元素 } } //找出V[]中与str相同元素的下标号,即找出上一个子集 public int stringEqual(String str){ //if(str.equals(""))return 0; int i = 0; while(i < V.length){ if(V[i].equals(str)) return i; i ++; } return -1;//如若没找到，则返回错误符号-1 } //求最小距离 public int min(int i , int j){ int k = 0;//用于记录V[j]中元素个数 String vStr = "" + V[j].charAt(k);//铭记V[j].charAt(k)得到的是字符型，转换成整形后是字母对应的ASC码！！！！ int v = Integer.parseInt(vStr);//把位置k处的字符转换成整形 String str = getSubString(k,j);//获得V[j]中除位置k处外的字符串 //System.out.println("min" + str + stringEqual(str) + v); if(stringEqual(str) == -1)System.exit(0); int min = c[i][v] + d[v][stringEqual(str)];//先把最小的距离赋值给从V[j] 中第一个顶点出发的距离 //System.out.println(min); //stringEqual(str)表示返回与上面获得的字符串相同的V中元素的下标，即找上一个子集 path[i][j] = path[v][stringEqual(str)] + i; k ++; //寻找最小距离 while(k < V[j].length()){ vStr = "" + V[j].charAt(k); v = Integer.parseInt(vStr); str = getSubString(k,j); if(min > c[i][v] + d[v][stringEqual(str)]){ min = c[i][v] + d[v][stringEqual(str)]; path[i][j] = path[v][stringEqual(str)] + i; } k ++; } //V[j].substring(beginIndex, endIndex) //System.out.println(path[i][j]); return min;//返回最小值 } //处理函数 public void dynamic(){ d = new int[N][(int)Math.pow(2,N-1)];//分配空间 path = new String[N][(int)Math.pow(2,N-1)]; for(int i = 1 ; i < N ; i ++){//初始化第一列 d[i][0] = c[i][0]; path[i][0] = "0" + i;//初始化第一个元素，即为出发城市顶点 //System.out.print(d[i][0] + " "); } //初始化后面的元素 int j = 1; for( ; j < (int)Math.pow(2,N-1) -1 ; j ++) for(int i = 1 ; i < N ; i ++){ if(exclude(i,j))//判断V子集中是否包含当前顶点，即V[j]中是否包含i { //System.out.println("done！" + i + " " + j); d[i][j] = min(i , j);//寻找最小距离 } } d[0][j] = min(0,j);//初始化组后一列 } //输出中间结果，各个数组，用于调试程序 public void print(){ for(int i = 0 ; i < (int)Math.pow(2,N-1) ; i ++) System.out.print(V[i] + " "); //for(int i = 0 ; i < c.length ; ) System.out.println(); for(int i = 0 ; i < N ; i ++){ for(int j = 0 ; j < N ; j ++) System.out.print(c[i][j] + " "); System.out.println(); } for(int i = 0 ; i < N ; i ++){ for(int j = 0 ; j < (int)Math.pow(2,N-1) ; j ++) System.out.print(d[i][j] + " "); System.out.println(); } } //输出最短路径 public void printShortestPath(){ //输出所经城市 System.out.print("经过城市："); String str = path[0][(int)Math.pow(2,N-1) - 1]; //System.out.println(str); System.out.print(str.charAt(str.length() - 1)); for(int i = str.length() - 2 ; i >= 0 ; i --){ System.out.print("->" + str.charAt(i)); } System.out.println("会有最短路径"); System.out.println("最短路径为：" + d[0][(int)Math.pow(2,N-1) - 1]); } //主函数 public static void main(String[] args) { TSPDynamic TSP = new TSPDynamic(); TSP.dynamic();//求最短路径 //TSP.print(); TSP.printShortestPath();//输出最短路径 } } //测试数据 /*99999 3 6 7 5 99999 2 3 6 4 99999 2 3 7 5 99999 */ 6.1.2结果（1） （2） （3） （4） 6.2贪心法 6.2.1源代码 package exp2; import java.util.Scanner; public class TSPGreedNode { int[] V;//存放旅行所经过的城市顶点 int[][] c;//存放每两座城市间的距离，注意：若路径不存在或同一城市间距离为无穷大int[] path;//存放旅行所经过的每两座城市间的距离 int N;//城市个数 int shortestPath;//表示最短路径 int u0;//出发城市编号 static int IFINITE= 99999;//无穷大距离表示城市自己到达自己时，距离无穷大，不作为考虑因素 public TSPGreedNode (){ initialC(); } //得到最短路径 public int getShortestPath(){ for(int i = 0 ; i < N ; i ++){ shortestPath += path[i]; } return shortestPath; } //初始化数组c[]，即顶点间距离 public void initialC(){ Scanner in = new Scanner( System.in ); System.out.println("请输入城市个数：（注意根据实际情况城市个数不可小于1！） "); N = in.nextInt(); if(N <= 1){ S ystem.out.println("不符合要求，请认真核对！"); S ystem.exit(0);//输入错误，结束！ } System.out.println("请输入城市相邻城市间距离（城市从0开始编号，且出发城市为第0个城市！）： "); c = new int[N][N];//为c分配空间 for(int i = 0 ; i < N ; i ++) for(int j = 0 ; j < N ; j ++){ c[i][j] = in.nextInt(); //输入时，按城市编号从小到大，如若两城市间没有公路相连，则距离为无穷大。本城市与本城市间距离也为无穷大。 } } public void tspGreedNode(){ Scanner in = new Scanner( System.in ); System.out.println("请输入出发城市编号（注意城市从0开始编号，请按照输入城市间距离即初始化c[][]时顺序计算）："); u0 = in.nextInt(); V = new int[N + 1]; path = new int[N]; int k = 0; V[k] = u0; while(k < N){ i nt min = IFINITE; k ++; f or(int i = 0 ; i < N ; i ++){ int mark = 0; for(int j = 0 ; j < k ; j ++) if(V[j] == i) mark = 1; if(mark == 0 && c[V[k - 1]][i] < min){ min = c[V[k - 1]][i]; V[k] = i; } } p ath[k - 1] = min; } V[k] = u0; path[k - 1] = c[V[k - 1]][V[k]]; } //输出最短路径下所经城市，两城市间距离和最短路径 public void print(){ shortestPath = 0; System.out.println("按照下列方式旅游会使所走路程最短："); for(int i = 0 ; i < N ; i ++){ System.out.println("从" + V[i] +"->" + V[i + 1] + ",所经路程为：" + path[i]); shortestPath += path[i]; } System.out.println("总路程为：" + shortestPath); } /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub TSPGreedNode gd = new TSPGreedNode(); gd.tspGreedNode(); gd.print(); } } /*99999 3 3 2 6 3 99999 7 3 2 3 7 99999 2 5 2 3 2 99999 3 6 2 5 3 99999*/ 6.2.2结果 (1) (2) (3) (4) 实验三、0-1背包问题（贪心算法） 实验代码： #include printf("物品总数为：7\n"); printf("物品重量和价值分别为：\n"); printf("\n重量价值\n"); for (i=1;i<=n;i++) printf("%d %d \n",w[i],v[i]); int m=15; int array[8][100]={0}; Knapsack(v,w,x,m,7,array); printf("背包能装的最大价值为: %d\n",array[1][m]); printf("贪心算法的解为: "); for(i=1;i<=n;i++) { if(i==1) printf("%d",x[i]); else printf(" %d",x[i]); } printf("\n"); return 0; } 测试截图为： 旅行商问题（ＴｒａｖｅｌｉｎｇＳａｌｅｓｍａｎＰｒｏｂｌｅｍ，简称ＴＳＰ）是一个著名的组合优化问题：给定ｎ个城市，有一个旅行商从某一城市出发，访问每个城市各一次后再回到原出发城市，要求找出的巡回路径最短。如果用图论来描述，那就是已知带权图Ｇ＝ （Ｃ，Ｌ），寻出总权值最小的Ｈａｍｉｌｔｏｎ圈。其中Ｃ＝｛ｃ１，ｃ２，…，ｃｎ｝表示ｎ个城市的集合，Ｌ＝｛ｌｉｊ｜ｃｉ，ｃｊ∈Ｃ｝是集合Ｃ中元素（城市）两两连接的集合，每一条边ｌｉｊ，都存在与之对应的权值ｄｉｊ，实际应用中ｄｉｊ可以表示距离、费用、时间、油量等。 ＴＳＰ的描述虽然简单， 解决起来却很困难。最简单思路是用穷举法把所有可能的巡回路径全部列出来，最短的一个就是最优解，但这样只能处理很小规模的问题。旅行商问题属于 ＮＰ－ｃｏｍｐｌｅｔｅ问题， 是ＮＰ（ｎｏｎ－ｄｅｔｅｒｍｉｎｉｓｔｉｃｐｏｌｙ－ｎｏｍｉｎａｌ）问题中最难的一类，不能在多项式时间内求解。如果有ｎ座城市，那么巡游路径共有（ｎ－１）！／２条，计算的时间和（ｎ－１）！成正比。当 城市数ｎ＝２０，巡回路径有１．２×１０１８种，ｎ＝１００， 巡回路径就有多达４．６×１０１５５种，而据估计宇宙中基本粒子数“仅仅只有”１０８７个。 尽管如此，随着算法研究的逐步深入和计算机技术飞速提高，对ＴＳＰ问题的研究不断取得进展。７０年来，被征服的ＴＳＰ规模从几十个城市增加到上万个城市。目前的最高记录是在２００４年５月，找到的巡游瑞典２４９７８个城镇的最优路径 （ｓｗ２４９７８）， 花费了８４．８个ＣＰＵ年。图１展示了ＴＳＰ的研究进展，最近的二三十年时间里，被攻克的ＴＳＰ规模高速增长，差不多是每十年增加一个数量级。照这样发展下去的话，再过２０年就能解决上百万个城市的ＴＳＰ，有专家甚至已经为此准备好了数据：全球１９０，４７１１个城市的坐标。当然，能不能达到这 个目标，有赖于未来计算技术的发展。 图１ＴＳＰ的发展 字母后面的数字表示城市数，“ｓｗ２４９７８”就是瑞典的 ２４９７８个城镇。 一、应用 旅行商问题具有重要的实际意义和工程背景。它一开始 是为交通运输而提出的，比如飞机航线安排、送邮件、快递服务、设计校车行进路线等等。实际上其应用范围扩展到了许多其他领域，下面举几个实例。 印制电路板转孔是ＴＳＰ应用的经典例子，在一块电路板上打成百上千个孔，转头在这些孔之间移动，相当于对所有的孔进行一次巡游。把这个问题转化为ＴＳＰ，孔相当于城市，孔到孔之间的移动时间就是距离。 为了避免大气干扰，使光学系统达到其衍射极限分辨率，欧美发达国家提出发展空间光干涉仪和综合孔径望远镜的计划。美国航空航天局有一个卫星群组成空间天文台（Ｓｐａｃｅ－ｂａｓｅｄＯｂｓｅｒｖａｔｏｒｉｅｓ）的计划， 用来探测宇宙起源和外星智慧生命。欧洲空间局也有类似的Ｄａｒｗｉｎ计划。对天体成像的时候，需要对两颗卫星的位置进行调整，如何控制卫星，使消耗的燃料最少，可以用ＴＳＰ来求解。这里把天体看作城市，距离就是卫星移动消耗的燃料。 美国国家卫生协会在人类基因排序工作中用ＴＳＰ方法绘制放射性杂交图。把ＤＮＡ片断作为城市，它们之间的相似程度作为城市间的距离。法国科学家已经用这种办法作出了老鼠的放射性杂交图。 此外，旅行商问题还有电缆和光缆布线、晶体结构分析、数据串聚类等多种用途。更重要的是，它提供了一个研究组合优化问题的理想平台。很多组合优化问题，比如背包问题、分配问题、车间调度问题，和ＴＳＰ同属ＮＰ－ｃｏｍｐｌｅｔｅ类，它们都是同等难度的，如果其中一个能用多项式确定性算法解决，那么其他所有的ＮＰ－ｃｏｍｐｌｅｔｅ类问题也能用多项式确定性算法解决。很多方法本来是从ＴＳＰ发展起来的，后来推广到其他ＮＰ－ｃｏｍｐｌｅｔｅ类问题上去。 二、ＴＳＰ求解方法 求解旅行商问题的方法可以分为两大类，一类是精确算法，目的是要找到理论最优解；另一类是近似算法，不强求最优解，只要找到“足够好”的满意解就可以了。 （一）精确算法 如前面所述，穷举法和全局搜索算法属于精确算法，但 旅行商问题概述 郭靖扬 （电子科技大学光电信息学院， 四川成都６１００５４） 【摘要】旅行商问题是组合优化的经典问题，应用广泛，而且长期以来被作为ＮＰ－ｃｏｍｐｌｅｔｅ问题的理想研究平台。文章介绍 了旅行商问题的基础知识、应用，以及常用的求解方法。 【关键词】旅行商问题；组合优化；ＮＰ－ｃｏｍｐｌｅｔｅ；ｋ－ｏｐｔ；智能算法【中图分类号】ＴＰ１８２【文献标识码】Ａ【文章编号】１００８－１１５１（２００６）０８－０２２９－０２大众科技 ＤＡＺＨＯＮＧＫＥＪＩ２００６年第８期（总第９４期） Ｎｏ．８，２００６ （ＣｕｍｕｌａｔｉｖｅｌｙＮｏ．９４） 【收稿日期】２００６－０３－１８【作者简介】郭靖扬（１９８０－），四川宜宾人，电子科技大学光电信息学院硕士研究生。 ２２９－－ 分治法 1 分割成独立的子问题 2 递归解决子问题 3 合并求得初始问题的解 动态规划算法 1.描述最优解的结构特征 2.定义最优解决方案的递归形式 3.以自底向上的方式计算最优解决方案的值 4.从计算信息构造出最优解决方案 贪婪算法步骤 1.确定问题的优化结构 2.得到递归解 3.证明某个最优选择是贪婪选择 4.贪婪选择将产生唯一一个非空子问题 5.用递归算法实现贪婪策略 6.将递归算法转换为迭代算法 贪婪算法设计 1. 通过作出某种贪婪选择，将初始优化问题转换为唯一的一个子问题来求解 2. GREEDY CHOICE（证明贪婪选择） 作出该贪婪选择后，可以保证初始优化问题存在最优解3.OPTIMAL SUBSTRUCTURE（证明优化基础） 贪婪选择+唯一子问题=最优解 贪婪算法正确性 1. 贪婪选择特性（局部最优导致全局最优） 2. 优化基础的特性（贪婪选择+唯一子问题的最优解?初始问题的最优解） 作业选择 ?贪婪选择特性 存在最优解包含贪婪选择，即Sij在选择最先完成的作业am ?优化基础 If an optimal solution to subproblem Sij includes activity ak ? it must contain optimal solutions to Sik and Skj Solution to Sij=(Solution to Sik)∪{ak}∪(Solution to Skj)动态规划解） Similarly, am + optimal solution to Smj ? optimal sol. Solution to Sij = {am} ∪(Solution to Smj) （贪婪选择解） 动态规划与贪婪算法比较 ?Dynamic programming –每步选择–选择与子问题解相关 –自底向上，即从规模下的子问题逐步求解规模大的子问题?Greedy algorithm –首先作出贪婪选择–求解贪婪选择后产生的唯一子问题–后续贪婪选择与前面的选择有关，但与子问题的解无关 –自顶向下，问题规模逐步缩小 动态规划和分治法 ?子问题非独立 –子问题求解依赖其子问题的解 –分治法通过递归方式解决性质相同的子问题 –动态规划每次解决一个子问题，并将结果存储在表格中4 ?适合优化问题 –通过适当的选择来获得问题的最优解 –找到具有最优解决方案及其最优值：装配线排程方案以及该方案的生产时间 –导致最优的解决方案可能不止一个 ? （允许负权值边） –如果从源顶点s没有可抵达的负权值回路，返回‘真’）（其余的返回‘假’，无解 –遍历所有的边|V–1|次，每次对每条边执行一次缩短运算–对图进行拓扑排序)(依据拓扑排序对边进行缩短操作 于每一个顶点, 对始于该顶点的每条边进行缩短操作) (DGA中没有负权值回路, 因此存在最短路径) – (不存在负权值边界) – (S: 集合中顶点的最短路径已经确定) (Q: V – S, 极小优先队列) ? (d[v]) (Q中的值是最短路径的估计) ?重复的从Q中选择具有最短估计距离的顶点进行处理 The Ford-Fulkerson Method(不断的增大流, 直到达到流的极大值)(通过剩余流和剩余流图实现) 增量算法（An Incremental Algorithm） Alg.: GREEDY-ACTIVITY-SELECTOR(s, f, n) 1. A ← {a1} 2. i ← 1 3. for m ← 2 to n 4. do if sm ≥ fi ? activity am is compatible with ai 5. then A ← A ∪ {am} 6. i ← m ? ai is most recent addition to A 7. return A 动态规划： 装配线排程 e1 + a1,1 if j = 1 f1[j] = min(f1[j - 1] + a1,j ,f2[j -1] + t2,j-1 + a1,j) if j ≥ 2 矩阵链相乘 m[i,j]=0 if i = j min{m[i,k]+m[k+1,j]+pi-1pkpj} if i < j Matrix-Chain-Order(p) 1. n ←length[p]-1; 2. for i ←1 to n 3. m[i, i] ←0; 4. for l ←2 to n 5. for i ←1 to n –l +1 6. j ←i + l -1; 7. m[i, j] ←∞; 8. for k ←i to j -1 9. q ←m[i, k] + m[k+1, j] + pI-1pkpj; 10. if q < m[i, j] 11. m[i, j] ←q; 12. s[i, j] ←k; 13. return m and s 最长共同子序列 LCS-Length(X,Y) 1. m ←length[X]; 2. n ←length[Y]; 3. for i ←1 to m 4. c[i, 0] ←0; 5. for j ←0 to n 6. c[0, j] ←0; 《算法分析与设计》 课程实验 专业年级：信息与计算科学 学生学号： 学生姓名： 实验题目：用贪婪法求解背包问题 指导老师： 实验时间：20xx年xx月x日 一、实验内容 用贪婪法求解背包问题 要求：用非递归实现 二、实验步骤 2.1、理解算法思想和问题要求； 2.2、写出每个操作的算法 非递归算法： greedbag() { int N; int c; int[] w; int[] v; Scanner scan=new Scanner(System.in); System.out.print("输入背包的容量:"); c=scan.nextInt(); System.out.print("输入物品的数量:"); N=scan.nextInt(); System.out.print("分别输入物品的价值:"); v=new int[N]; for(int i=0;i 动态规划算法原理及其应用研究 系别：x x x 姓名：x x x 指导教员： x x x 2012年5月20日 摘要：动态规划是解决最优化问题的基本方法，本文介绍了动态规划的基本思想和基本步骤，并通过几个实例的分析，研究了利用动态规划设计算法的具体途径。关键词：动态规划多阶段决策 1.引言 规划问题的最终目的就是确定各决策变量的取值，以使目标函数达到极大或极小。在线性规划和非线性规划中，决策变量都是以集合的形式被一次性处理的；然而，有时我们也会面对决策变量需分期、分批处理的多阶段决策问题。所谓多阶段决策问题是指这样一类活动过程：它可以分解为若干个互相联系的阶段，在每一阶段分别对应着一组可供选取的决策集合；即构成过程的每个阶段都需要进行一次决策的决策问题。将各个阶段的决策综合起来构成一个决策序列，称为一个策略。显然，由于各个阶段选取的决策不同，对应整个过程可以有一系列不同的策略。当过程采取某个具体策略时，相应可以得到一个确定的效果，采取不同的策略，就会得到不同的效果。多阶段的决策问题，就是要在所有可能采取的策略中选取一个最优的策略，以便得到最佳的效果。动态规划是一种求解多阶段决策问题的系统技术，可以说它横跨整个规划领域（线性规划和非线性规划）。在多阶段决策问题中，有些问题对阶段的划分具有明显的时序性，动态规划的“动态”二字也由此而得名。动态规划的主要创始人是美国数学家贝尔曼（Bellman）。20世纪40年代末50年代初，当时在兰德公司（Rand Corporation）从事研究工作的贝尔曼首先提出了动态规划的概念。1957年贝尔曼发表了数篇研究论文，并出版了他的第一部著作《动态规划》。该著作成为了当时唯一的进一步研究和应用动态规划的理论源泉。在贝尔曼及其助手们致力于发展和推广这一技术的同时，其他一些学者也对动态规划的发展做出了重大的贡献，其中最值得一提的是爱尔思（Aris）和梅特顿（Mitten）。爱尔思先后于1961年和1964年出版了两部关于动态规划的著作，并于1964年同尼母霍思尔（Nemhauser）、威尔德（Wild）一道创建了处理分枝、循环性多阶段决策系统的一般性理论。梅特顿提出了许多对动态规划后来发展有着重要意义的基础性观点，并且对明晰动态规划路径的数 贪心算法与动态规划的比较 【摘要】介绍了计算机算法设计的两种常用算法思想：贪心算法与动态规划算法。通过介绍两种算法思想的基本原理，比较两种算法的联系和区别。通过背包问题对比了两种算法的使用特点和使用范围。 【关键字】动态规划；贪心算法；背包问题 1、引言 为了满足人们对大数据量信息处理的渴望，为解决各种实际问题，计算机算法学得到了飞速的发展，线性规划、动态规划、贪心策略等一系列运筹学模型纷纷运用到计算机算法学中，产生了解决各种现实问题的有效算法。虽然设计一个好的求解算法更像是一门艺术而不像是技术，但仍然存在一些行之有效的、能够用于解决许多问题的算法设计方法，你可以使用这些方法来设计算法，并观察这些算法是如何工作的。一般情况下，为了获得较好的性能，必须对算法进行细致的调整。但是在某些情况下，算法经过调整之后性能仍无法达到要求，这时就必须寻求另外的方法来求解该问题。本文针对部分背包问题和0/ 1 背包问题进行分析，介绍贪心算法和动态规划算法的区别。 2、背包问题的提出 给定n种物品( 每种物品仅有一件) 和一个背包。物品i的重量是w i，其价值为p i，背包的容量为M。问应如何选择物品装入背包，使得装入背包中的物品的总价值最大,每件物品i的装入情况为x i，得到的效益是p i*x i。 ⑴部分背包问题。在选择物品时，可以将物品分割为部分装入背包，即0≤x i≤1 ( 贪心算法)。 ⑵0/ 1背包问题。和部分背包问题相似，但是在选择物品装入时要么不装，要么全装入，即x i = 1或0。( 动态规划算法) 。 3、贪心算法 3.1 贪心算法的基本要素 能够使用贪心算法的许多例子都是最优化问题，每个最优化问题都包含一组限制条件和一个优化函数，符合限制条件的问题求解方案称为可行解；使优化函数取得最佳值的可行解称为最优解。此类所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到(这是贪心算法与动态规划的主要区别) 。 3.2贪心策略的定义 贪心策略是指从问题的初始状态出发，通过若干次的贪心选择而得出最优值( 或较优解) 的一种解题方法。贪心策略总是做出在当前看来是最优的选择，也就是说贪心策略并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解，而许多问题自身的特性决定了该问题运用贪心策略可以得到最优解或较优解。(注：贪心算法不是对所有问题都能 贪心算法的应用 课程名称：算法设计与分析 院系：计算机科学与信息工程学院 学生姓名：**** 学号：********** 专业班级：********************************** 指导教师：****** 201312-27 贪心算法的应用 摘要：顾名思义，贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。当然，希望贪心算法得到的最终结果也是整体最优的。虽然贪心算法不能对所有问题都得到整体最优解，但对许多问题它能产生整体最优解。如单源最短路经问题，最小生成树问题等。在一些情况下，即使贪心算法不能得到整体最优解，其最终结果却是最优解的很好近似。贪心算法求问题一般具有两个重要性质：贪心选择性质和最优子结构性质。所谓贪心选择性是指所求问题的整体最优解可以通过一系列局部最优解的选择，即贪心选择达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法主要区别。当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用动态规划算法或贪心算法求解的关键特征。 背包问题是一个经典的问题，我们可以采用多种算法去求解0/1背包问题，比如动态规划法、分支限界法、贪心算法、回溯法。在这里我们采用贪心法解决这个问题。 关键词：贪心法背包问题最优化 目录 第1章绪论 (3) 1.1 贪心算法的背景知识 (3) 1.2 贪心算法的前景意义 (3) 第2章贪心算法的理论知识 (4) 2.1 问题的模式 (4) 2.2 贪心算法的一般性描述 (4) 第3章背包问题 (5) 3.1 问题描述 (5) 3.2 问题分析 (5) 3.3算法设计 (5) 3.4 测试结果与分析 (10) 第4章结论 (12) 参考文献 (13) 附件 (13) 动态规划是对最优化问题的一种新的算法设计方法。由于各种问题的性质不同，确定最优解的条件也互不相同，因而动态规划的没计法对不同的问题，有各具特色的表示方式。不存在一种万能的动态规划算法。但是可以通过对若干有代表性的问题的动态规划算法进行讨论，学会这一设计方法。 多阶段决策过程最优化问题 ——动态规划的基本模型 在现实生活中，有一类活动的过程，由于它的特殊性，可将过程分成若干个互相联系的阶段，在它的每一阶段都需要作出决策，从而使整个过程达到最好的活动效果。因此各个阶段决策的选取不能任意确定，它依赖于当前面临的状态，又影响以后的发展。当各个阶段决策确定后，就组成一个决策序列，因而也就确定了整个过程的一条活动路线。这种把一个问题看做是一个前后关联具有链状结构的多阶段过程就称为多阶段决策过程，这种问题称为多阶段决策最优化问题。 【例题1】最短路径问题。图中给出了一个地图，地图中每个顶点代表一个城市，两个城市间的连线代表道路，连线上的数值代表道路的长度。现在，想从城市A到达城市E，怎样走路程最短，最短路程的长度是多少? 【分析】把从A到E的全过程分成四个阶段，用k表示阶段变量，第1阶段有一个初始状态A，两条可供选择的支路ABl、AB2；第2阶段有两个初始状态B1、 B2，B1有三条可供选择的支路，B2有两条可供选择的支路……。用dk(x k，x k+1)表示在第k阶段由初始状态x k到下阶段的初始状态x k+1的路径距离，Fk(x k)表示从第k阶段的x k到终点E的最短距离，利用倒推方法求解A到E的最短距离。具体计算过程如下： S1：K=4，有：F4(D1)=3，F4(D2)=4，F4(D3)=3 S2: K=3，有： F3(C1)=min{d3(C1,D1)+F4(D1),d3(C1,D2)+F4(d2)}=min{8,10}=8 F3(C2)=d3(C2,D1)+f4(D1)=5+3=8 F3(C3)=d3(C3,D3)+f4(D3)=8+3=11 F3(C4)=d3(C4,D3)+f4(D3)=3+3=6 #include { /*if(mincost <= cost[cur][i]+cost[i][start]) { continue; //其作用为结束本次循环。即跳出循环体中下面尚未执行的语句。区别于break } */ visit[i] = 1; //递归调用时，防止重复调用 int value = cost[cur][i] + imin(num-1, i); if(mincost > value) { mincost = value; } visit[i] = 0;//本次递归调用完毕，让下次递归调用 } } return mincost; } int main() { int i,j; // int k,e,w; n=4; int cc[4][4]={{0,10,15,20}, {5,0,9,10}, {6,13,0,12}, {8,8,9,0}}; for(i=0; i #include<> #define N 100 typedef struct bao{ int num; float w; float v; }; typedef struct avg{ int num; ( float val; float w; float v; }; struct bao b[N]; struct avg d[N]; int n; float c; ^ void Sort() { int i,j,k; struct avg temp[N]; for(i=0;i float x[N],sum = 0; for(i=0;i 算法分析与设计实验报告 第 4 次实验 } 附录：完整代码 #include 动态规划算法和贪心算法的比较与分析 1、最优化原理 根据一类多阶段问题的特点,把多阶段决策问题变换为一系列互相联系的单阶段问题,然后逐个加以解决。解决这类问题的最优化原理:一个过程的最优决策具有这样的性质,即无论其初始状态和初始决策如何,其今后诸策略对以第一个决策所形成的状态作为初始状态的过程而言,必须构成最优策略。简而言之,一个最优策略的子策略,对于它的初态和终态而言也必是最优的。 2、动态规划 2.1 动态规划算法 动态规划是运筹学的一个分支，与其说它是一种算法，不如说它是一种思维方法更贴切。因为动态规划没有固定的框架，即便是应用到同一道题上，也可以建立多种形式的求解算法。许多隐式图上的算法，例如求单源最短路径的Dijkstra算法、广度优先搜索算法，都渗透着动态规划的思想。还有许多数学问题，表面上看起来与动态规划风马牛不相及，但是其求解思想与动态规划是完全一致的。因此，动态规划不像深度或广度优先那样可以提供一套模式，需要的时候，取来就可以使用。它必须对具体问题进行具体分析、处理，需要丰富的想象力去建立模型，需要创造性的思想去求解。 动态规划算法的基本思想是将待求解问题分解成若干子问题，先求解子问题，然后从这些子问题的解得到原问题的解。值得注意的是，用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的。 最优化原理是动态规划的基础。任何一个问题，如果失去了这个最优化原理的支持，就不可能用动态规划方法计算。能采用动态规划求解的问题都要满足两个条件:①问题中的状态必须满足最优化原理;②问题中的状态必须满足无后效性。 所谓无后效性是指下一时刻的状态只与当前状态有关，而和当前状态之前的状态无关，当前的状态是对以往决策的总结。 2.2 动态规划算法的基本要素 算法设计与分析实验报告 题目：贪心算法背包问题 专业：JA V A技术xx——xxx班 学号： 姓名： 指导老师： 实验三：贪心算法背包问题 一、实验目的与要求 1、掌握背包问题的算法 2、初步掌握贪心算法 二、实验题： 问题描述：与0-1背包问题相似，给定n种物品和一个背包。物品i的重量是wi，其价值为vi，背包的容量为c。与0-1背包问题不同的是，在选择物品i装入背包时，背包问题的解决可以选择物品i的一部分，而不一定要全部装入背包，1< i < n。 三、实验代码 import java.awt.*; import java.awt.event.*; import javax.swing.*; public class er extends JFrame { private static final long serialVersionUID = -1508220487443708466L; private static final int width = 360;// 面板的宽度 private static final int height = 300;// 面板的高度 public int M; public int[] w; public int[] p; public int length; er() { // 初始Frame参数设置 this.setTitle("贪心算法"); setDefaultCloseOperation(EXIT_ON_CLOSE); setSize(width, height); Container c = getContentPane(); c.setLayout(new BoxLayout(c, BoxLayout.Y_AXIS)); setLocation(350, 150); // 声明一些字体样式 Font topF1 = new Font("宋体", Font.BOLD, 28); Font black15 = new Font("宋体", Font.PLAIN, 20); Font bold10 = new Font("宋体", Font.BOLD, 15); // 声明工具栏及属性设置 JPanel barPanel = new JPanel(); JMenuBar topBar = new JMenuBar(); topBar.setLocation(1, 1); barPanel.add(topBar); // 面板1和顶部标签属性设置 JPanel p1 = new JPanel(); JLabel topLabel = new JLabel("背包问题"); 实验四“0-1”背包问题 一、实验目的与要求 熟悉C/C++语言的集成开发环境； 通过本实验加深对贪心算法、动态规划算法的理解。 二、实验内容: 掌握贪心算法、动态规划算法的概念和基本思想，分析并掌握“0-1”背包问题的求解方法，并分析其优缺点。 三、实验题 1.“0-1”背包问题的贪心算法 2.“0-1”背包问题的动态规划算法 说明：背包实例采用教材P132习题六的6-1中的描述。要求每种的算法都给出最大收益和最优解。 设有背包问题实例n=7，M=15,，(w0,w1,。。。w6)=（2,3,5,7,1,4,1），物品装入背包的收益为：（p0，p1，。。。，p6）=（10,5,15,7,6,18,3）。求这一实例的最优解和最大收益。 四、实验步骤 理解算法思想和问题要求； 编程实现题目要求； 上机输入和调试自己所编的程序； 验证分析实验结果； 整理出实验报告。 五、实验程序 // 贪心法求解 #include 算法设计与分析大作业 班级：电子154 姓名：吴志勇 学号： 1049731503279 任课老师：李瑞芳 日期： 2015.12.25 算法设计与分析课程论文 0-1背包问题的算法设计策略对比与分析 0 引言 对于计算机科学来说，算法的概念是至关重要的。在一个大型软件系统的开发中，设计出有效的算法将起到决定性的作用。通俗的讲，算法是解决问题的一种方法。也因此，《算法分析与设计》成为计算科学的核心问题之一，也是计算机科学与技术专业本科及研究生的一门重要的专业基础课。算法分析与设计是计算机软件开发人员必修课，软件的效率和稳定性取决于软件中所采用的算法；对于一般程序员和计算机专业学生，学习算法设计与分析课程，可以开阔编程思路，编写出优质程序。通过老师的解析，培养我们怎样分析算法的“好”于“坏”，怎样设计算法，并以广泛用于计算机科学中的算法为例，对种类不同难度的算法设计进行系统的介绍与比较。本课程将培养学生严格的设计与分析算法的思维方式，改变随意拼凑算法的习惯。本课程要求具备离散数学、程序设计语言、数据结构等先行课课程的知识。 1 算法复杂性分析的方法介绍 算法复杂性的高低体现在运行该算法所需要的计算机资源的多少上，所需的资源越多，该算法的复杂性越高；反之，所需资源越少，该算法的复杂性越低。对计算机资源，最重要的是时间与空间（即存储器）资源。因此，算法的复杂性有时间复杂性T(n)与空间复杂性S(n)之分。 算法复杂性是算法运行所需要的计算机资源的量，这个量应集中反映算法的效率，并从运行该算法的实际计算机中抽象出来，换句话说，这个量应该只依赖要解决的问题规模‘算法的输入和算法本身的函数。用C表示复杂性，N,I和A表示问题的规模、算法的输入和算法本身规模，则有如下表达式： C=F(N,I,A) T=F(N，I,A) S=F(N，I,A) 其中F(N,I,A)是一个三元函数。通常A隐含在复杂性函数名当中，因此表达式中一般不写A。 即：C=F(N,I) T=F(N,I) S=F(N,I) 算法复杂性中时间与空间复杂性算法相似，所以以下算法复杂性主要以时间复杂性为例： 算法的时间复杂性一般分为三种情况：最坏情况、最好情况和平均情况。下面描述算法复杂性时都是用的简化的复杂性算法分析，引入了渐近意义的记号O,Ω，θ，和o。 O表示渐近上界Ω表示渐近下界： θ表示同阶即：f(n)= O(g(n))且 f(n)= Ω（g(n)） 2 常见的算法分析设计策略介绍 2.1 递归与分治策略 分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。 直接或间接地调用自身的算法称为递归算法。用函数自身给出定义的函数称为递归函数。 由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。 分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。 递归算法举例： 共11页第1页 T S P问题算法分析集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289- 算法第二次大作业 TSP问题算法分析 021251班 王昱（02125029） 一．问题描述 “TSP问题”常被称为“旅行商问题”，是指一名推销员要拜访多个地点时，如何找到在拜访每个地点一次后再回到起点的最短路径。 TSP问题在本实验中的具体化：从A城市出发，到达每个城市并且一个城市只允许访问一次，最后又回到原来的城市，寻找一条最短距离的路径。 二．算法描述 2.1分支界限法 2.1.1算法思想 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。 在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。 此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。 2.1.2算法设计说明 设求解最大化问题，解向量为X=(x1,…,xn)，xi的取值范围为Si，|Si|=ri。在使用分支限界搜索问题的解空间树时，先根据限界函数估算目标函数的界[down,up]，然后从根结点出发，扩展根结点的r1个孩子结点，从而构成分量x1的r1种可能的取值方式。 对这r1个孩子结点分别估算可能的目标函数bound(x1)，其含义：以该结点为根的子树所有可能的取值不大于bound(x1)，即： bound(x1)≥bound(x1,x2)≥…≥bound(x1,…,xn) 若某孩子结点的目标函数值超出目标函数的下界，则将该孩子结点丢弃；否则，将该孩子结点保存在待处理结点表PT中。 再取PT表中目标函数极大值结点作为扩展的根结点，重复上述。 直到一个叶子结点时的可行解X=(x1,…,xn)，及目标函数值 bound(x1,…,xn)。 2.2A*算法 算法思想 对于某一已到达的现行状态,如已到达图中的n节点,它是否可能成为最佳路径上的一点的估价,应由估价函数f(n)值来决定。假设g*(n)函数值表示从起始节点s到任意一个节点n的一条最佳路径上的实际耗散值。h*(n)函数值表示从任意节点n到目标节点ti的最佳路径的实际耗散值。其中ti是一个可能的目标节点。f*(n)函数值表示从起始s，通过某一指定的n到达目标节点ti的一条最佳路径的实际耗散值，并有 f*(n)=g*(n)+h*(n)。 实验项目三 用蛮力法、动态规划法和贪心法求解0/1 背包问题 实验目的 1、学会背包的数据结构的设计，针对不同的问题涉及到的对象的数据结构的设计也不同； 2、对0-1背包问题的算法设计策略对比与分析。 实验内容： 0/1背包问题是给定n 个重量为{w 1, w 2, … ,wn }、价值为{v 1, v 2, … ,vn }的物品和一个容量为C 的背包，求这些物品中的一个最有价值的子集，并且要能够装到背包中。 在0/1背包问题中，物品i 或者被装入背包，或者不被装入背包，设xi 表示物品i 装入背包的情况，则当xi =0时，表示物品i 没有被装入背包，xi =1时，表示物品i 被装入背包。根据问题的要求，有如下约束条件和目标函数： 于是，问题归结为寻找一个满足约束条件式1，并使目标函数式2达到最大的解向量X =(x 1, x 2, …, xn )。 背包的数据结构的设计： typedef struct object { int n;//物品的编号 int w;//物品的重量 int v;//物品的价值 }wup; wup wp[N];//物品的数组，N 为物品的个数 int c;//背包的总重量 1、蛮力法 蛮力法是一种简单直接的解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。蛮力法的关键是依次处理所有的元素。 用蛮力法解决0/1背包问题，需要考虑给定n 个物品集合的所有子集，找出所有可能的子集（总重量不超过背包容量的子集），计算每个子集的总价值，然后在他们中找到价值最大的子集。 所以蛮力法解0/1背包问题的关键是如何求n 个物品集合的所有子集，n 个物品的子集有2的n 次方个，用一个2的n 次方行n 列的数组保存生成的子集，以下是生成子集的算法： ?????≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i （式1） ∑=n i i i x v 1max （式2）贪心算法0-1背包问题(算法实验代码)
旅行商问题概述_郭靖扬
分治、贪心、动态规划算法要点复习
算法设计实验_贪心算法背包问题
动态规划算法原理与的应用
贪心算法与动态规划的比较
【精选】贪心算法的应用
经典算法——动态规划教程
货郎担问题或旅行商问题动态规划算法
C语言版贪心算法背包问题
背包问题(贪心算法)
动态规划算法和贪心算法的比较与分析
贪心算法背包问题
背包问题-贪心法和动态规划法求解
0-1背包问题的算法设计策略对比与讲解
TSP问题算法分析
实验项目三 用蛮力法、动态规划法和贪心法求解背包问题
相关文档
- 背包问题-贪心法和动态规划法求解
- 第二讲 贪心法和动态规划法PPT课件
- 第5课贪心与动态规划
- 用蛮力法、动态规划法和贪心法求解0 1背包问题
- 分治、贪心、动态规划算法要点复习
- 用蛮力法、动态规划法和贪心法求解01背包问题
- 10. 贪心与动态规划专题(一)
- 贪心法与动态规划(1)
- 0-1背包问题(动态规划和贪心法实现)
- 动态规划算法和贪心算法的比较与分析
- 用蛮力法、动态规划法和贪心法求解0 1背包问题
- 0-1背包问题-贪心法和动态规划法求解1
- 算法论文：旅行商问题的求解方法(动态规划法和贪心法)
- 动态规划和贪心的区别
- 用蛮力法、动态规划法和贪心法求解0-1背包问题
- 贪心法&动态规划法&分支限界法
- 第三讲 贪心法
- 贪心算法与动态规划
- 0-1背包问题-贪心法和动态规划法求解
- 分治法与动态规划法