poj 2288 Islands and Bridges

题意：

定义一个最优哈密顿回路如果把如下描述的值最大化：

有n个城市。一个哈密顿回路C1C2..Cn的值由3个部分组成：

1.这个路径上每个岛的值Vi之和；

2.这个路径上每条边Vi*Vi+1之和；

3.如果路径上连续的三个岛屿CiCi+1Ci+2之间两两互相连通，那么就加上Vi*Vi+1*Vi+2。

求出最优哈密顿回路的值以及个数。

（一条路径及其反转，认为是同一条路径）。

思路：

首先，计算值肯定是跟前两个岛有关系的，此时就可以用当前状态为S，前两个岛为i，前一个岛为j来进行状态的转移。

dp[S|(1<<k)][j][k] = max(dp[S|(1<<k)][j][k],dp[S][i][j] + v[k] + v[j]*v[k] + v[j]*v[k]*v[i])，最后一个部分必须满足两两互相连通才能加。

如果dp[S|(1<<k)][j][k]已经有值并且与当前计算出来的值相同，路径条数直接加上即可。

最后路径条数要减半，因为逆序的路径也是计算了的。

注意dp数组的初始化。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int N = 14;
int dp[1<<N][N][N];
long long num[1<<N][N][N];
int v[N];
bool mp[N][N];
int main()
{
    int t;
    scanf("%d",&t);
    while (t--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        memset(mp,0,sizeof(mp));
        memset(dp,-1,sizeof(dp));
        memset(num,0,sizeof(num));
        for (int i = 0;i < n;i++) scanf("%d",&v[i]);
        for (int i = 0;i < m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            x--,y--;
            mp[x][y] = mp[y][x] = 1;
        }
        if (n == 1)
        {
            printf("%d 1
",v[0]);
            continue;
        }
        for (int i = 0;i < n;i++)
        {
            for (int j = 0;j < n;j++)
            {
                if (i == j) continue;
                if (!mp[i][j]) continue;
                dp[(1<<i)|(1<<j)][i][j] = v[i] + v[j] + v[i]*v[j];
                num[(1<<i)|(1<<j)][i][j] = 1;
            }
        }
        for (int i = 0;i < (1<<n);i++)
        {
            for (int j = 0;j < n;j++)
            {
                for (int k = 0;k < n;k++)
                {
                    if (j == k) continue;
                    if (!mp[j][k]) continue;
                    if (dp[i][j][k] < 0) continue;
                    for (int l = 0;l < n;l++)
                    {
                        if (i&(1<<l)) continue;
                        if (!mp[k][l]) continue;
                        int tmp = v[l] + v[k] * v[l];
                        if (mp[j][k] && mp[j][l] && mp[l][k])
                        {
                            tmp += v[j]*v[k]*v[l];
                        }
                        if (dp[i|(1<<l)][k][l] < dp[i][j][k] + tmp)
                        {
                            dp[i|(1<<l)][k][l] = dp[i][j][k] + tmp;
                            num[i|(1<<l)][k][l] = num[i][j][k];
                        }
                        else if (dp[i|(1<<l)][k][l] == dp[i][j][k] + tmp)
                        {
                            num[i|(1<<l)][k][l] += num[i][j][k];
                        }
                    }
                }
            }
        }
        int maxn = -1;
        long long cnt = 0;
        for (int i = 0;i < n;i++)
        {
            for (int j = 0;j < n;j++)
            {
                if (i == j) continue;
                maxn = max(dp[(1<<n)-1][i][j],maxn);
            }
        }
        if (maxn == -1) printf("0 0
");
        else
        {
            for (int i = 0;i < n;i++)
            {
                for (int j = 0;j < n;j++)
                {
                    if (i == j) continue;
                    if (dp[(1<<n)-1][i][j] == maxn) cnt += num[(1<<n)-1][i][j];
                }
            }
            printf("%d %lld
",maxn,cnt/2);
        }
    }
    return 0;
}