P1523 旅行商简化版

P1523 旅行商简化版

题目背景

欧几里德旅行商(Euclidean Traveling Salesman)问题也就是货郎担问题一直是困扰全世界数学家、计算机学家的著名问题。现有的算法都没有办法在确定型机器上在多项式时间内求出最优解，但是有办法在多项式时间内求出一个较优解。

为了简化问题，而且保证能在多项式时间内求出最优解，J.L.Bentley提出了一种叫做bitonic tour的哈密尔顿环游。它的要求是任意两点(a,b)之间的相互到达的代价dist(a,b)=dist(b,a)且任意两点之间可以相互到达，并且环游的路线只能是从最西端单向到最东端，再单项返回最西端，并且是一个哈密尔顿回路。

题目描述

著名的NPC难题的简化版本

现在笛卡尔平面上有n(n<=1000)个点，每个点的坐标为(x,y)(-2^31<x,y<2^31，且为整数)，任意两点之间相互到达的代价为这两点的欧几里德距离，现要你编程求出最短bitonic tour。

输入输出格式

输入格式：

第一行一个整数n

接下来n行，每行两个整数x,y，表示某个点的坐标。

输入中保证没有重复的两点，

保证最西端和最东端都只有一个点。

输出格式：

一行，即最短回路的长度，保留2位小数。

输入输出样例

输入样例#1：

7
0 6
1 0
2 3
5 4
6 1
7 5
8 2

输出样例#1：

25.58

 

分析：

下面提供两种方法，刷表法和填表法

 

1、刷表法

代码是从前往后刷表

【1】题意：旅行商问题，不过要求只能单向走，就是有n个地方，要求从西往东，到最东面的地方，在从东往西返回，经过每个点一次，求最短路径

【2】分析：由于有了方向的限制，这题不再是NP难题，我们可以假设有两个人一起从西往东走，走过的点不能重复，这样就有f[ i ][ j ]表示第一个人走到i，第二个人走到j 的最短路径，要求i<j，且0到j的点都被经过了，这样很容易想到，j+1的点不是被第一个人走，就是被第二个人走，所以有转移方程f[ i ][ j+1]=min{ f[ i ] [ j ]+d[ j ] [ j +1] } f[ j ] [ j+1 ]=min{ f[ i ][ j ]+d[ i ][ j+1 ] }，第一个转移方程很容易理解，第二个方程可以这么理解，两个人可以指前面一个人，和后面一个人，当后面的人走到前面，当然就对换过来了，不影响结果

【3】最后，预处理f[ 0 ][ 1]还有扫描 一遍答案就行了，这题算是一类DP吧，思路挺有启发性的

#include <cmath>
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int mm=1111;
struct data
{
    double x,y;
}g[mm];
double d[mm][mm],f[mm][mm];
int i,j,k,n;
bool cmp(const data &a,const data &b)
{
    return a.x<b.x;
}
double mdis(const data &a, const data &b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int main()
{
    scanf("%d",&n);
    for(i=0;i<n;++i)
        scanf("%lf%lf",&g[i].x,&g[i].y);
    sort(g,g+n,cmp);
    for(i=0;i<n;++i)
        for(j=i+1;j<n;++j)
        {
            d[i][j]=mdis(g[i],g[j]);
            f[i][j]=1e30;
        }
    f[0][1]=d[0][1];
    for(i=0;i<n;++i)
        for(j=i+1;j<n;++j)
        {
            f[i][j+1]=min(f[i][j+1],f[i][j]+d[j][j+1]);
            f[j][j+1]=min(f[j][j+1],f[i][j]+d[i][j+1]);
        }
    double ans=1e30;
    for(j=0;j<n-1;++j)
        ans=min(ans,f[j][n-1]+d[j][n-1]);
    printf("%.2lf
",ans);
    return 0;
}

2、填表法

代码是从后往前填表

遍历一整个图， 从开始位置走到末尾，再走回开始位置，并且不能重复；

由于题目并没有对输入数据按X从小到大排序，所以先排序，然后预处理出每两个点之间的欧几里得距离。

f(i,j)表示 从 1->max(i,j) 已经全部遍历切没有重复的最短路；

那么可知F(i , j) = F(j , i); 于是就规定 i > j;

如果 i = n - 1; 那么就强行将j跳到末尾位置；f(i, j) = dis(i, n) + dis(j, n);

其余可知 f(i,j) = max ( f(i+1, j) + dis(i, i +1), f(i+1, i) + dis(j, i+1)) 原本应写成f(i, i+1)， 但由于规定所以写成这样；

最终状态为f(2, 1);

接着就是naive的输出啦；

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
typedef long long Lovelive;
using namespace std;

const int maxn = 1000 + 10;
int n;
struct Node {
    double x, y;    
}node[maxn];
double dis[maxn][maxn], f[maxn][maxn];

bool cmp(Node a, Node b) {
    return a.x < b.x;    
}

int main() {
    scanf("%d",&n);    
    for(int i = 1; i <= n; i++) scanf("%lf%lf",&node[i].x,&node[i].y);
    sort(node+1, node+n+1, cmp);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            dis[i][j] = sqrt((node[i].x-node[j].x)*(node[i].x-node[j].x) + (node[i].y-node[j].y)*(node[i].y-node[j].y));

    for(int i = n-1; i >= 2; i--)
        for(int j = 1; j < i; j++)
            if(i == n-1) f[i][j] = dis[i][n] + dis[j][n];
            else f[i][j] = min (f[i+1][j] + dis[i][i+1], f[i+1][i] + dis[j][i+1]);
    printf("%.2lf",f[2][1] + dis[1][2]);
    return 0;
}