PAT甲级 -- 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 M lines 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

19 分

说说我的思路： 

1. 先判断是不是TS cycle，如果输入路径上的城市数目少于N+1个，不可能构成循环，如果路径上第一个城市与最后一个城市不是同一个，也不是TS cycle，没有把每个城市都访问（set去重）以及某两点间不可达也不是 TS cycle（用flag来记录）

2. 如果是cycle，此时需要判断是不是simple cycle，如果只有7个点，是simple cycle，如果不是，则肯定是TS cycle，不是 simple cycle。

3. 肯定有逻辑不严密处，所以得19分

#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <cmath>
#include <algorithm>
using namespace std;

const int MAXN = 205;
const int INF = 1000000000;
int G[MAXN][MAXN];
bool visit[MAXN] = {false};

int N, M, K, n;
int minPath = INF, minNum = 0;

int main() 
{
	fill(G[0], G[0]+MAXN*MAXN, INF);
	scanf("%d%d", &N, &M);
	for (int i = 0; i < M; i++)
	{
		int c1, c2, len;
		scanf("%d%d%d", &c1, &c2, &len);
		G[c1][c2] = len;
		G[c2][c1] = len;
	}
	scanf("%d", &K);
	for (int u = 1; u <= K; u++)
	{
		bool flag = true; //是不是TS
		scanf("%d", &n);
		vector<int> path(n);
		set<int> s;
		for (int i  = 0; i < n; i++)
		{
			scanf("%d", &path[i]);
			s.insert(path[i]);
		}
		printf("Path %d: ", u);
		int pathDist = 0;
		for (int i = 0; i < path.size()-1; i++)
		{
			if (G[path[i]][path[i+1]] != INF)  
			{
				pathDist += G[path[i]][path[i+1]];
			}else
			{
				flag = false;
				pathDist = 0;
				break;
			}
		}
		if (n < N -1 || s.size() != N || path[0] != path[path.size()-1])
		{
			flag = false;
		}

		if (pathDist == 0)
		{
			printf("NA ");
		}else
		{
			
			printf("%d ", pathDist);
		}

		if (flag == false)
		{
			printf("(Not a TS cycle)\n");
		}else
		{
             if (pathDist <= minPath)
    	     {
			     minPath = pathDist;
				 minNum = u;
			 }
			
			if (n == 7)
			{
				printf("(TS simple cycle)\n");
			}else
			{
               
				printf("(TS cycle)\n");
			}
		}
		
	}
	printf("Shortest Dist(%d) = %d", minNum, minPath);
	return 0;
}

 柳神的代码：

1. flag记录不可达，如果不可达，直接输出NA， not ts cycle

2. 第一个点和最后一个点不一样，不是cycle

3. cnt != n+1 ，不是simple cycle

4. 前三个都没有满足，则是simple cycle

5. 注意最小值的更新

#include <iostream>
#include <vector>
#include <set>
using namespace std;
int e[300][300], n, m, k, ans = 99999999, ansid;
vector<int> v;
void check(int index) {
	int sum = 0, cnt, flag = 1;
	scanf("%d", &cnt);
	set<int> s;
	vector<int> v(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;
		sum += e[v[i]][v[i+1]];
	}
	if (flag == 0) {
		printf("Path %d: NA (Not a TS cycle)\n", index);
	} else if(v[0] != v[cnt-1] || s.size() != n) {
		printf("Path %d: %d (Not a TS cycle)\n", index, sum);
	} else if(cnt != n + 1) {
		printf("Path %d: %d (TS cycle)\n", index, sum);
		if (sum < ans) {
			ans = sum;
			ansid = index;
		}
	} else {
		printf("Path %d: %d (TS simple cycle)\n", index, sum);
		if (sum < ans) {
			ans = sum;
			ansid = index;
		}
	}
}
int main() {
	scanf("%d%d", &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;
	}
	scanf("%d", &k);
	for (int i = 1; i <= k; i++) check(i);
	printf("Shortest Dist(%d) = %d\n", ansid, ans);
	return 0;
}