欧几里得旅行商问题 java与c++实现
双调欧几里得旅行商问题是一个经典动态规划问题。《算法导论（第二版）》思考题15-1
旅行商问题描述：平面上n个点，确定一条连接各点的最短闭合旅程。这个解的一般形式为NP的（在多项式时间内可以求出）
J.L. Bentley 建议通过只考虑双调旅程(bitonictour)来简化问题,这种旅程即为从最左点开始，严格地从左到右直至最右点，然后严格地从右到左直至出发点。下图(b)显示了同样的7个点的最短双调路线。在这种情况下，多项式的算法是可能的。事实上，存在确定的最优双调路线的O(n*n)时间的算法。
上图中，a是最短闭合路线，这个路线不是双调的。b是最短双调闭合路线
以上截取来自：http://blog.csdn.net/xiajun07061225/article/details/8092247
/**
* 欧几里得旅行商(travelling salesman problem)问题
* 分解模型：
* 一个人从Pi严格递减的走到P1，然后再严格递增的回到Pj，求总路径的最小值,其中P1,P2,...,Pj的
* 所有节点都要走一次，求最短的路径；
* 对于1 <= i <= j <= n, 我们定义P(i, j)是一条包含了P1, P2, P3 ...Pj的途径
* 这条路径可以分成2部分：递减序列与递增序列：起点是Pi(1 <= i <= j)，拐点是P1，
* 终点是Pj, P[i, j]为其最小值；路径为（Pi-_>Pm-->P1-->Pn-->Pj，其中1<m<i<n<j）
* 动态规划方程：
* p[i,j]为最小值，dist(m,n)为m与n的直接距离
* p[1,2]=dist(1,2)
* i<j-1时，从P(i+1)到Pj之间的点必然出现在递增序列中
* p[i,j]=p[i,j-1]+dist(j-1,j)
* i=j-1时，假设P1到Pi之间的一个中间节点Pk，使得p[k,i]+dist(k,j)最小，也就是说，找到了
* 将P1到Pj的所有节点走一遍的最短路径
* p[i,j]=min{p[k,i]+dist(k,j)}(其中1<=k<=i)
* p[k,i]又可以按照以上方式继续找出最小路径
*
* 对于欧几里得旅行商问题，要求的最短路径是p[n,n]
* p[n,n]=p[n-1,n]+dist(n-1,n);
*
*
*/</pre><pre name="code" class="html">
以下是C++实现，来自：http://blog.csdn.net/xiajun07061225/article/details/8092247
#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
const int n = 7;//点的数目
const int MaxVal = 999999;
const int MaxLen = 201;
struct tagPoint{
double x,y;
};
//计算点i和点j之间的直线距离
double distance(tagPoint *points,int i,int j)
{
return sqrt((points[i].x - points[j].x) * (points[i].x - points[j].x) +
(points[i].y - points[j].y) * (points[i].y - points[j].y));
}
double DP(tagPoint *points,int n)
{
double b[MaxLen][MaxLen];//记录最短路径的长度
//计算所有情况下的b[i][j]，1 <= i <= j
//初始化
b[1][2] = distance(points,1,2);
for (int j = 3;j <= n;++j)
{
//i < j-1
for (int i = 1;i <= j - 2;++i)
{
b[i][j] = b[i][j - 1] + distance(points,j - 1,j);
}
//i = j - 1,b[i][j] = min(b[k][j - 1] + distance(k,j));
b[j - 1][j] = MaxVal;
for (int k = 1;k <= j - 2;++k)
{
double temp = b[k][j - 1] + distance(points,k,j);
if (temp < b[j - 1][j])
{
b[j - 1][j] = temp;
}
}
}
b[n][n] = b[n - 1][n] + distance(points,n - 1,n);
return b[n][n];
}
int main()
{
int NUM;
while(cin >> NUM)
{
tagPoint *points = new tagPoint[NUM + 1];
for (int i = 1;i <= NUM;++i)
{
cin >> points[i].x;
cin >> points[i].y;
}
double minDis = DP(points,NUM);
//设置输出格式：精确到小数点后2位
cout.setf(ios::fixed);
cout << setprecision(2) << minDis << endl;
}
}以下是java实现，基本思想是一样的。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import org.omg.CORBA.PRIVATE_MEMBER;
/**
* @date 2014-09-20
* @author acer
* 欧几里得旅行商(travelling salesman problem)问题
* 分解模型：
* 一个人从Pi严格递减的走到P1，然后再严格递增的回到Pj，求总路径的最小值,其中P1,P2,...,Pj的
* 所有节点都要走一次，求最短的路径；
* 对于1 <= i <= j <= n, 我们定义P(i, j)是一条包含了P1, P2, P3 ...Pj的途径
* 这条路径可以分成2部分：递减序列与递增序列：起点是Pi(1 <= i <= j)，拐点是P1，
* 终点是Pj, P[i, j]为其最小值；路径为（Pi-_>Pm-->P1-->Pn-->Pj，其中1<m<i<n<j）
* 动态规划方程：
* p[i,j]为最小值，dist(m,n)为m与n的直接距离
* p[1,2]=dist(1,2)
* i<j-1时，从P(i+1)到Pj之间的点必然出现在递增序列中
* p[i,j]=p[i,j-1]+dist(j-1,j)
* i=j-1时，假设P1到Pi之间的一个中间节点Pk，使得p[k,i]+dist(k,j)最小，也就是说，找到了
* 将P1到Pj的所有节点走一遍的最短路径
* p[i,j]=min{p[k,i]+dist(k,j)}(其中1<=k<=i)
* p[k,i]又可以按照以上方式继续找出最小路径
*
* 对于欧几里得旅行商问题，要求的最短路径是p[n,n]
* p[n,n]=p[n-1,n]+dist(n-1,n);
* 解释：Pn-->Pn,如果第一个点是Pn-1，那么上面的式子显然成立；
* 如果第一个点是Pk,（1<=k<=n-2），那么Pn-1一定在Pk-->Pn的递增序列中，所以
* p[n,n]=p[k,n]+dist(k,n)=p[k,n-1]+dist(n-1,n)+dist(k,n);
* 其中p[n-1,n]=p[k,n-1]+dist(k,n)
* 所以 p[n,n]=p[n-1,n]+dist(n-1,n)必然成立;
*
*
*/
public class TSProblem {
public static void main(String[] args) {
// TODO Auto-generated method stub
String line=null;//读取每一行的输入数据
int[][] pointXY;//记录横纵坐标
System.out.print("请输入点的个数N：");
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader bReader=new BufferedReader(isr);
try {
line=bReader.readLine().toString();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
int n=Integer.parseInt(line);//记录点的个数
pointXY=new int[n][2];
System.out.println("请输入每个点的坐标，坐标格式为:x,y (以EOF结束输入)");
Scanner scn=new Scanner(System.in);
int i=0;
while(!"EOF".equals(line=scn.nextLine())){
String[] p=line.split(",");
int j=0;
for(String str:p){
pointXY[i][j++]=Integer.parseInt(str);
}
i++;
if(i>=n){
System.out.println("输入的点数已经足够，自动结束输入");
break;//退出输入
}
}
//System.out.println("ok");
int length=pointXY.length;
TSProblem tsp=new TSProblem(pointXY,length);
}
public TSProblem(int[][] points,int length){
//points中存储所有的节点，乱序排列
//1、首先将所有的节点按照x坐标顺序排列，可选用多种排序方式，这里采用快排，时间复杂度为o(nlogn)
points=this.QuickSort(points, 0, length-1);
// //打印排序后的点
// for(int i=0;i<length;i++){
// System.out.println(points[i][0]+","+points[i][1]);
// }
//2、找到最短路径
double leastDis=DP(points, length);
System.out.println("最短路径为："+leastDis);
}
//计算最短旅行路径
double DP(int[][] points,int length){
//p用于记录最短路径的长度
double[][] p=new double[length][length];
p[0][1]=dist(points, 0, 1);
for(int j=2;j<length;j++){
//case1:i<j-1
// p[i,j]=p[i,j-1]+dist(j-1,j)
for(int i=0;i<j-1;i++){
p[i][j]=p[i][j-1]+dist(points, i, j);
}
//case2:i=j-1
// p[i,j]=min{p[k,i]+dist(k,j)}(其中1<=k<=i)
p[j-1][j]=Float.MAX_VALUE;
double temp=0;
for(int k=0;k<j-1;k++){
temp=p[k][j-1]+dist(points, k, j);
if(temp<p[j-1][j]){
p[j-1][j]=temp;
}
}
}
p[length-1][length-1]=p[length-2][length-1]+dist(points, length-2, length-1);
//返回Pn-->Pn，即最短路径
return p[length-1][length-1];
}
//计算两点之间的直接距离dist(i,j)
double dist(int[][] point ,int i,int j){
double distance=0;
distance=Math.sqrt(Math.pow((point[j][0] -point[i][0]),2)
+Math.pow((point[j][1]-point[i][1]),2));
return distance;
}
//快排
int[][] QuickSort(int[][] num,int left,int right){
/**
* 1、先从数列中取出一个数作为基数
* 2、大数置于该数的右边，小数置于该数的左边
* 3、重复步骤1,2
*/
if(left<right){
int tempX=num[left][0];//设置基数，不唯一
int tempY=num[left][1];
int i=left,j=right;
while(i<j){
while(i<j&&num[j][0]>=tempX)
j--; //右边的数小于基数时退出
if(i<j){
//如果在右边找到一个数小于基数，num[i]此时为空，将该数填到num[i]
num[i][0]=num[j][0];
num[i][1]=num[j][1];
i++;
}
while(i<j&&num[i][0]<tempX)
i++; //左边的数大于基数时退出
if(i<j){
//如果在左边找到一个数大于基数，num[j]此时为空，将该数填到num[j]
num[j][0]=num[i][0];
num[j][1]=num[j][1];
j--;
}
}//当i=j时退出
//num[i]为空值，将基数填入
num[i][0]=tempX;
num[i][1]=tempY;
QuickSort(num, left, i-1);//左边快排
QuickSort(num, i+1, right);//右边快排
}
//返回已经排好序的数组
return num;
}
}
