1150 Travelling Salesman Problem (25 分)

1150 Travelling Salesman Problem (25 分)

The "travelling salesman problem" asks the following question: "Given a list of cities and the distances between each pair of cities, what is the shortest possible route that visits each city and returns to the origin city?" It is an NP-hard problem in combinatorial optimization, important in operations research and theoretical computer science. (Quoted from "https://en.wikipedia.org/wiki/Travelling_salesman_problem".)

In this problem, you are supposed to find, from a given list of cycles, the one that is the closest to the solution of a travelling salesman problem.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 positive integers N (2<N≤200), the number of cities, and M, the number of edges in an undirected graph. Then Mlines follow, each describes an edge in the format City1 City2 Dist, where the cities are numbered from 1 to N and the distance Dist is positive and is no more than 100. The next line gives a positive integer K which is the number of paths, followed by K lines of paths, each in the format:

n C​1​​ C​2​​ ... C​n​​

where n is the number of cities in the list, and C​i​​'s are the cities on a path.

Output Specification:

For each path, print in a line Path X: TotalDist (Description) where X is the index (starting from 1) of that path, TotalDist its total distance (if this distance does not exist, output NA instead), and Description is one of the following:

• TS simple cycle if it is a simple cycle that visits every city;
• TS cycle if it is a cycle that visits every city, but not a simple cycle;
• Not a TS cycle if it is NOT a cycle that visits every city.

Finally print in a line Shortest Dist(X) = TotalDist where X is the index of the cycle that is the closest to the solution of a travelling salesman problem, and TotalDist is its total distance. It is guaranteed that such a solution is unique.

Sample Input:

6 10
6 2 1
3 4 1
1 5 1
2 5 1
3 1 8
4 1 6
1 6 1
6 3 1
1 2 1
4 5 1
7
7 5 1 4 3 6 2 5
7 6 1 3 4 5 2 6
6 5 1 4 3 6 2
9 6 2 1 6 3 4 5 2 6
4 1 2 5 1
7 6 1 2 5 4 3 1
7 6 3 2 5 4 1 6

Sample Output:

Path 1: 11 (TS simple cycle)
Path 2: 13 (TS simple cycle)
Path 3: 10 (Not a TS cycle)
Path 4: 8 (TS cycle)
Path 5: 3 (Not a TS cycle)
Path 6: 13 (Not a TS cycle)
Path 7: NA (Not a TS cycle)
Shortest Dist(4) = 8

=============================================

题意：

n个城市，m条无向带权边。

给定 k 组访问序列，对每一组，请你判断是否是TS cycle。

TS cycle满足：

1.源点 == 终点

2.访问了所有城市

3.相邻点必须都能到达

TS simple cycle满足:

在TS cycle的基础上，如果每个城市仅访问一次(源点除外)即是。

所以，访问了 n + 1次的TS cycle就是 simple cycle。

题解：

（PS：如果觉得混乱，请直接看代码，回头再看题解。）

邻接矩阵存无向图，每一组访问序列存放在数组中。

设置flag变量，如果有不可到达的点（不满足TS cycle条件3），flag = 0 并停止访问。不必输出开销sum，输出NA。

如果源点 != 源点 or 没有访问所有的城市（不满足TS cycle条件1 或 2），输出Not a TS cycle。

3个条件都满足则是TS cycle，进一步判断是 simple cycle ? (这组序列总数 == n + 1)，接下来相应输出。

 

这里又又又又用了set去重计数，统计了访问的不相同的城市个数。(拿小本本记下...)

=============================================

#include <iostream>
#include <vector>
#include <set>
using namespace std;
int e[300][300], n, m, k, ans = 0xfffffff, ansid;
vector<int> v;
void check(int index){//检查每组访问序列
	int sum = 0, cnt, flag = 1;
	cin >> cnt;
	set<int> s;
	v.resize(cnt);
	for(int i = 0; i < cnt; i++){
		scanf("%d", &v[i]);
		s.insert(v[i]);//去重计数
	}
	for(int i = 0; i < cnt - 1; i++){
		if(e[v[i]][v[i + 1]] == 0){//不可达时，flag=0并停止访问
			flag = 0;
            break;
		}
		sum += e[v[i]][v[i + 1]];//sum统计访问开销
	}
	printf("Path %d: ", index);
	if(flag == 0){//不满足条件3
		printf("NA (Not a TS cycle)\n");
	} else if(v[0] != v[cnt - 1] || s.size() != n){//不满足条件1，2
		printf("%d (Not a TS cycle)\n", sum);
	} else if(cnt != n + 1){//都满足则是Ts cycle，进一步判断是simple cycle？
		printf("%d (TS cycle)\n", sum);
		if(sum < ans){//更新最小开销和序号
			ans = sum;
			ansid = index;
		}
	} else{
		printf("%d (TS simple cycle)\n", sum);
		if(sum < ans){//同上
			ans = sum;
			ansid = index;
		}
	}
}
int main(){
	cin >> n >> m;
	for(int i = 0; i < m; i++){
		int t1, t2, t;
		scanf("%d%d%d", &t1, &t2, &t);
		e[t1][t2] = e[t2][t1] = t;
	}
	cin >> k;
	for(int i = 1; i <= k; i++)//检查每组访问序列
		check(i);
	printf("Shortest Dist(%d) = %d\n", ansid, ans);
	return 0;
}