双调旅行商问题

欧氏旅行售货员问题是对给定的平面上n 个点确定一条连接这n 个点的长度最短的哈密顿回路。由于欧氏距离满足三角不等式，所以欧氏旅行售货员问题是一个特殊的具有三角不等式性质的旅行售货员问题。它仍是一个NP 完全问题。最短双调TSP 回路是欧氏旅行售货员问题的特殊情况。平面上n 个点的双调TSP 回路是从最左点开始，严格地由左至右直到最右点，然后严格地由右至左直至最左点，且连接每一个点恰好一次的一条闭合回路。

编程任务：

给定平面上n 个点，编程计算这n 个点的最短双调TSP 回路。

数据输入：

由文件input.txt 给出输入数据。第1 行有1 个正整数n，表示给定的平面上的点数。接下来的n 行中，每行2 个实数，分别表示点的x 坐标和y 坐标。

结果输出:

将计算的最短双调TSP 回路的长度（保留2 位小数）输出到文件output.txt 。

输入文件示例

input.txt

7

0 6

1 0

2 3

5 4

6 1

7 5

8 2

输出文件示例

output.txt

25.58

题解：

首先对点按x坐标排序

设$dis[i][j]$的含义为从第i个点走到最左点，再从最左点走到第j个点的最短双调路径，从只有两个点的情形开始推，则初始化$dis[1][2]=dist(p[1],p[2])$

对于每个新加入的点j：

• 首先计算$i<j-1$时的情形，此时从$i$到$j$的双调路径上，$j-1$就是$j$的上一个点，因此$dis[i][j]=dis[i][j-1]+dist(p[j-1],p[j])$
  • 有没有可能这样求出的点不是$i$到$j$的最优路径长度呢？
  • 我们假设$dis[i][j]$就是最优路径长度，从第$j-1$个点把这条最优路径划分成两段，那么必然的，$dis[i][j-1]$和$dist(j-1,j)$都必须是最优的，前者，是我们在上一层循环中已求解的最优答案；后者，是$j-1$到$j$的直线距离，必然是最优路径，因此，$dis[i][j]=dis[i][j-1]+dist(p[j-1],p[j])$得到的路径确实是最优路径。
• 然后计算$i=j-1$的情形，此时由于$j-1$已经作为了起点，因此，到达$j$之前经过的上一个点是不确定的，所以，要在$1$到$j-2$中枚举路径最优的那个中转点
• 最后，$j$等于最右点时，我们就已经算好了$dis[n-1][n]$的双调最优路径，只需加上$n-1$到$n$的直线距离就可以得到最优回路。

#include 
#include 
#include 
#include 
using namespace std;
const double inf = 10086;
double dis[51][51];
int n;

struct Point {
    double x, y;
    bool operator<(const Point& p) {
        return x < p.x || (x == p.x && y < p.y);
    }
    bool operator>(const Point& p) {
        return x > p.x || (x == p.x && y > p.y);
    }
}p[51];

void qsort(int l, int r) {
    if (l < r) {
        int i = l, j = r;
        Point mid = p[l + (r - l) / 2];
        while (i <= j) {
            while (p[i] < mid)
                i++;
            while (p[j] > mid)
                j--;
            if (i <= j) {
                Point t = p[i]; p[i] = p[j], p[j] = t;
                i++, j--;
            }
        }
        qsort(l, j);
        qsort(i, r);
    }
}

double dist(const Point& a, const Point& b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> p[i].x >> p[i].y;
    }
    qsort(1, n);
    dis[1][2] = dist(p[1], p[2]);
    for (int j = 3; j <= n; j++) {
        for (int i = 1; i <= j - 2; ++i) {
            dis[i][j] = dis[i][j - 1] + dist(p[j - 1], p[j]);
        }
        dis[j - 1][j] = inf;
        for (int k = 1; k <= j - 2; ++k) {
            double tmp = dis[k][j - 1] + dist(p[k], p[j]);
            dis[j - 1][j] = min(tmp, dis[j - 1][j]);
        }
    }
    dis[n][n] = dis[n - 1][n] + dist(p[n - 1], p[n]);
    cout << fixed << setprecision(2) << dis[n][n];
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64