POJ-2288 状压dp Hamilton回路

题意：Hamilton回路的权值为：

1、经过的每条边的两个点的点权和

2、连续经过两点的乘积

3、如果三条边形成三角形则再加上三个点权的乘积

求最大值+路径条数

思路：10来个点用一个小的邻接矩阵就可以判断是否相连，判断三角形就可以在dp加一维记录前两个点的信息，枚举的时候多枚举到前2个点

即dp[state][pre][now]，表示当前为state、前一个点pre、当前点now的最大权值，路径条数跟最短路条数的记录方法一样

错的地方：没判断dp[state][pre][now] == -1就WA了，加上就A了，我之前明明都加上了i & (1<<j)这类点与状态冲突的判断，原因我猜是初始化+刷表法，-1是不合法不存在的状态，没加上会导致后面别的状态被刷了

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#define LL long long
#define INF 0x3f3f3f3f
#define debug(x) cout << #x << " = " << x << endl
using namespace std;

LL dp[1<<13][14][14], num[1<<13][14][14];
LL a[14];
bool d[14][14];

int main() {
    int t, n, m;
    scanf("%d", &t);
    while (t--){
        scanf("%d%d", &n, &m);
        memset(d, 0, sizeof d);
        for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
        for (int i = 0; i < m; i++){
            int u, v;
            scanf("%d%d", &u, &v);
            u--, v--;
            d[u][v] = d[v][u] = 1;
        }
        if (n == 1){
            printf("%lld 1
", a[0]);
            continue;
        }
        memset(dp, -1, sizeof dp);
        memset(num, 0, sizeof num);
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                if (!d[i][j]) continue;
                if (i == j) continue;
                dp[(1<<i)+(1<<j)][i][j] = a[i]+a[j]+a[i]*a[j];
                num[(1<<i)+(1<<j)][i][j] = 1;
            }
        }
        //dp[state][pre][now]
        for (int i = 3; i < (1<<n); i++){
            for (int j = 0; j < n; j++){
                if (!(i & (1 << j))) continue;
                for (int k = 0; k < n; k++){
                    if (!(i & (1 << k))) continue;
                    if (!d[j][k]) continue;
                    if (dp[i][j][k] == -1) continue;
                    for (int r = 0; r < n; r++){
                        if (i & (1 << r)) continue;
                        if (!d[k][r]) continue;
                        LL tmp = dp[i][j][k] + a[r] + a[k]*a[r];
                        if (d[j][r]) tmp += a[j]*a[k]*a[r];
                        int nxt = i + (1 << r);
                        if (tmp > dp[nxt][k][r]){
                            dp[nxt][k][r] = tmp;
                            num[nxt][k][r] = num[i][j][k];
                        }
                        else if (tmp == dp[nxt][k][r])
                            num[nxt][k][r] += num[i][j][k];
                    }
                }
            }
        }
        LL ans = -1, sum = 0;
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                if (i == j) continue;
                if (!d[i][j]) continue;
                if (dp[(1<<n)-1][i][j] > ans){
                    ans = dp[(1<<n)-1][i][j];
                    sum = num[(1<<n)-1][i][j];
                }
                else if (ans == dp[(1<<n)-1][i][j])
                    sum += num[(1<<n)-1][i][j];
            }
        }
        if (ans == -1) printf("0 0
");
        else printf("%lld %lld
", ans, sum/2);
    }
    return 0;
}