HDU 5418 TSP + 状态压缩

      第一次写状态压缩的题目，遇到很多瓶颈， 不过好在都解决了， 状态压缩确实很难想象，但是如果仔细认真的一步一步做，一定也可以轻松A出来。
      下面对遇到的瓶颈进行总结：(我做的是求一个最短路的题目)     
      先说一下思路，Ps：也是借鉴的其他人。     
      首先是输入的时候，因为可能两点之间有很多路，所以要在Map数组里面存入那条最短边。 存入之后用弗洛伊德求出各个点之间的最短路，进行dp，dp数组分成二维，第一维表示状态，第二位表示终点。所有未知状态都有已知状态推出，然后用三层循环来表示，第一层表示状态需要2^n，第二三层，枚举每个终点和中间点，需要n^2 总共时间复杂度需要2^n * n^2 这个比深搜n!要好。      
      (1)首先刚开始纠结状态，该怎么样处理状态，其实只需要从1 到  1<<n枚举所有的状态即可。       
      (2)在枚举终点时，要判断状态中是否包含这个点。只有不包含这个点时，才去枚举中间节点到终点和起点到中间节点的和来更新。       
      (3)然后以状态中所有的1为中间点来判断。     
      (4)以上都比较好想，我觉得对我最难的就是那个状态，想了很久，就是枚举到终点怎么在状态中加入终点， 最后借鉴了他人的才想到有或运算。这个是比较难的一点。

代码如下：

#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF = 0x1f1f1f1f;
const int Max = 20;
int Map[20][20];
int dp[1<<Max][Max];

//用弗洛伊德求出各个点的最短路 
void floyd(int n)
{
	for(int k = 1; k <= n; k++)
	{
		for(int i = 1; i <= n; i++)
		{
			for(int j = 1; j <= n; j++)
			{
				Map[i][j] = min(Map[i][k] + Map[k][j], Map[i][j]); 
			}
		}
	}
}

int Minroad(int n)
{
	int i, j, ans = INF, k;
    floyd(n);
    memset(dp, INF, sizeof(dp));
    dp[1][1] = 0;
	for(i = 1; i < 1<<n; i++)
	{
		for(j = 2; j <= n; j++)
		{
			if(i & (1<<(j-1)))// 必须保证状态不包含终点 
			    continue;
			for(k = 1; k <= n; k++)//枚举中间节点 
			{ 
			    if(i & (1 << (k-1)))//必须保证为1才能成为中间节点 
			    {
			       //用或运算来进行状态转移。 
				   dp[i|(1<<(j-1))][j] = min(dp[i|(1<<(j-1))][j], (dp[i][k] + Map[k][j]));
				}
			}
		}
	}
	for(i = 2; i <= n; i++)
	    ans = min(ans,dp[(1<<n)-1][i] + Map[i][1]);
    return ans == INF?0:ans; 
}

int main()
{
	int  cas, n, m, i;
    scanf("%d",&cas);
	while(cas--)
	{
	    scanf("%d%d",&n,&m);
	    memset(Map, INF, sizeof(Map));
	    for(i = 1; i <= n; i++)
	        Map[i][i] = 0;
	    for(i = 0; i < m; i++)
	    {
	    	int a, b, c;
	    	scanf("%d%d%d",&a,&b,&c);
	    	//存储最小边 
	    	Map[a][b] = min(Map[a][b], c);
	    	Map[b][a] = min(Map[b][a], c);
		}
		printf("%d\n",Minroad(n));
    }
    return 0;
}