POJ2288（状压DP）

题目大意：在一个无向图中G(V,E)中(|V|<=13)，每一个点有一个点权，并有哈密顿路径（指从起点开始不重复经过一点到终点的路径）。

现在规定哈密顿路径的代价如下：1,所有的点权之和；2,哈密顿路径中相邻点点权乘积之和；3,哈密顿路径中相邻的三个点若形成环，则3的答案加上这三个点的乘积。

1式+2式+3式即为这条哈密顿路径的代价。如果还不懂题意：请看下图：

问题为：求出最大哈密顿路径的代价与哈密顿路径的方案数。规定：路径1-2-3与3-2-1是一样的，但1-2-3与2-3-1是不一样的。

【解题思路】

首先，简化问题，先不考虑方案数，这样的话：

(1)式：设当前点集为set，要计算a,b这两个点(a,b之间必须有连边)。则f[set][a][b] = v[a] + max(f[set-a][b][c] | b->c);边界条件：f[{a}][0][a] = v[a];

(2)式：与(1)式同理，f[set][a][b] = v[a] * v[b] + max(f[set-a][b][c] | b->c); 边界条件：f[{a,b}][a][b] = v[a] * v[b]

(3)式：与(2)式同理，f[set][a][b] = max(f[set-a][b][c] + （若a->b->c->a，则加上v[a]*v[b]*v[c]） )。

所以，(1),(2),(3)式可以一起算，则：f[set][a][b] = v[a] + v[a] * v[b] + f[set-a][b][c] + （若a->b->c->a，则加上v[a]*v[b]*v[c]） )。边界：f[{a,b}][a][b] = v[a]+v[b] + v[a]*v[b]。

至此，就可以用集合动态规划（基于状态压缩的动态规划），用二进制来表示集合的状态。

最后的问题是：该怎样求方案数？

其实，在DP时加多一个方案数组，就可以算出来了。

则这一题的时间复杂度为O(2^n*n^3)。

注意：这一题非常多坑！！！首先，图有可能是不连通的，这时，要输出0 0；其次，图的点数有可能为1，这时，要输出v[1] 1；再其次，方案数有可能会爆int，还要用long long处理；再再其次，转移时还要判断上一个阶段是否可行，也就是初始化时要设为-1，然后转移时再判断f[set'][b][c]是否不为-1，再再再其次，因为题目要求1-2-3和3-2-1是一样的，所以总方案数要除以2。

附上代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>

using namespace std;
typedef long long LL;
#define Maxn 14

int v[Maxn];
LL f[1<<Maxn][Maxn][Maxn];
LL num[1<<Maxn][Maxn][Maxn];//第1个坑 
bool bo[Maxn][Maxn];

int n,m;

LL ans,sum,rr;

int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		
		ans = sum = 0;
		
		memset(v,0,sizeof(v));
		
		for(int i=0;i<n;i++) 
			scanf("%d",&v[i]);
		
		memset(f,-1,sizeof(f));
		memset(num,0,sizeof(num));
		memset(bo,0,sizeof(bo));
		
		int z,y;
		for(int i=1;i<=m;i++)
		{
			scanf("%d%d",&z,&y);
			z--; y--;
			bo[z][y] = bo[y][z] = true;
		}
		
		if(n==1)//第2个坑 
		{
			printf("%d 1\n",v[0]);
			continue;
		}
		
		for(int a=0;a<n;a++)//预处理边界值 
		for(int b=0;b<n;b++)
		if(a!=b && bo[a][b])
		{
			f[(1<<b)|(1<<a)][a][b] = v[a] * v[b] + v[a] + v[b];
			num[(1<<a)|(1<<b)][a][b] = 1;
		}
		
		int p = 1<<n;
		for(int set=0;set<p;set++)
		for(int a=0;a<n;a++)
		for(int b=0;b<n;b++)
		if(a!=b && bo[a][b] && (set&(1<<a)) && (set&(1<<b)) )
		{
			for(int c=0;c<n;c++)
			if(a!=c && b!=c && bo[b][c] && (set&(1<<c)) && f[set-(1<<a)][b][c]!=-1)//第3个坑 
			{
				z = (0LL+v[a]) * v[b] + 0LL+f[set-(1<<a)][b][c] + (bo[a][c]?v[a]*v[b]*v[c]:0LL) + v[a];
				if(f[set][a][b] < z)
				{
					num[set][a][b] = num[set-(1<<a)][b][c];
					f[set][a][b] = z;
				}
				else if(f[set][a][b] == z)
					num[set][a][b]+=num[set-(1<<a)][b][c];
			}
		}
		
		rr=0;
		ans = -1;
		for(int a=0;a<n;a++)
		for(int b=0;b<n;b++)
		if(a!=b)
		{
			if(ans<f[p-1][a][b])
			{
				rr=0LL+num[p-1][a][b];
				ans = f[p-1][a][b];
			}
			else if(ans == f[p-1][a][b]) rr+=0LL+num[p-1][a][b];
		}
		if(ans==-1)//第4个坑 
		{
			printf("0 0\n");
		}
		else
		cout<<ans<<" "<<rr/2<<endl;//第5个坑 
	}
	return 0;
}

转载于:https://www.cnblogs.com/ouqingliang/p/9245254.html