jzoj3290. 【JSOI2013】吃货JYY

题目描述

Description
世界上一共有N个JYY愿意去的城市，分别从1编号到N。JYY选出了K个他一定要乘坐的航班。除此之外，还有M个JYY没有特别的偏好，可以乘坐也可以不乘坐的航班。
一个航班我们用一个三元组(x,y,z)来表示，意义是这趟航班连接城市x和y，并且机票费用是z。每个航班都是往返的，所以JYY花费z的钱，既可以选择从x飞往y，也可以选择从y飞往x。
南京的编号是1，现在JYY打算从南京出发，乘坐所有K个航班，并且最后回到南京，请你帮他求出最小的花费。

Input
输入数据的第一行包含两个整数N和K；
接下来K行，每行三个整数x，y，z描述必须乘坐的航班的信息，数据保证在这K个航班中，不会有两个不同的航班在同一对城市之间执飞；
第K+2行包含一个整数M；
接下来M行，每行三个整数x，y，z 描述可以乘坐也可以不乘坐的航班信息。
Output
输出一行一个整数，表示最少的花费。数据保证一定存在满足JYY要求的旅行方案。

Sample Input
6 3
1 2 1000
2 3 1000
4 5 500
2
1 4 300
3 5 300
Sample Output
3100

Data Constraint
对于10%的数据满足N≤4；
对于30%的数据满足N≤ 7；
对于额外30%的数据满足，JYY可以只通过必须乘坐的K个航班从南京出发到达任意一个城市；
对于100%的数据满足2≤N≤13，0≤K≤78，2 ≤M ≤ 200，1 ≤x,y ≤N，1 ≤z ≤ 10^4。

Hint
样例说明：一个可行的最佳方案为123541。 机票所需的费用为1000+1000+300+500+300=3100。

10%

暴力

70%

随便水

100%

一道特别神奇的DP。。。

因为题目要求的是一个从1出发走完一圈后回到1的路径，所以实际上就是欧拉回路。
（同一条边经过多次算不同的边）
那么欧拉回路的一个性质是：每个点的度数都为偶数
所以只要求出一条从1开始的连通的顶点度数为偶数的路径，就一定是符合要求的答案

考虑状压dp。
设三进制状态F[s],为0表示不在连通块内，1表示度数为奇数，2表示度数为偶数

因为有些边必须走，所以先假设这些边全部走了（答案加上贡献之和）
既然这些边都走了，最后的回路中一定包含跟这些边相邻的点。
为了走完所有必经边，如果走到一个点时有必经边就要把一整个必经边构成的连通块都走完
（我TMD看过的题解中没有一个这么写的）

于是其它就很简单了，每次枚举一个不在连通块的点，找一个已走过的点连过去，如果有必经边相连代价为0，否则为最短路（所有边）

最后判一下回路中有没有1和必经点
结果有可能不是全为偶数点，那么就奇点两两匹配（可以预处理）

code

蛋疼至极的代码。。。
我差点忘了这是道DP题

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define min(a,b) (a<b?a:b)
using namespace std;

const int p[15]={0,1,3,9,27,81,243,729,2187,6561,19683,59049,177147,531441,1594323};
const int P[15]={0,1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192};
int a[15];
int a2[15];
int A[14];
int F[14][14];
bool b[14][14];
int B[14][14];
int c[14][14];
int f[1594323];
int d[1594323];
int g[8192];
bool bz;
int n,M,m,i,j,k,l,s,h,t,ans,S,sum;

void Dfs(int t)
{
    int i;

    if (A[t]==-1) A[t]=j;

    fo(i,1,n)
    if (b[t][i] && !B[t][i])
    {
        B[t][i]=j;
        B[i][t]=j;

        if (c[j][t]<=1)
        c[j][t]++; else c[j][t]--;
        if (c[j][i]<=1)
        c[j][i]++; else c[j][i]--;

        Dfs(i);
    }
}

void dfs()
{
    j=0;
    fo(i,1,n)
    {
        j++;
        Dfs(i);
    }
}

void Read()
{
    memset(F,60,sizeof(F));
    scanf("%d%d",&n,&M);
    fo(i,1,M)
    {
        scanf("%d%d%d",&j,&k,&l);
        s+=l;

        F[j][k]=l;
        F[k][j]=l;
        b[j][k]=1;
        b[k][j]=1;

        A[j]=-1;
        A[k]=-1;
    }
    scanf("%d",&m);
    fo(i,1,m)
    {
        scanf("%d%d%d",&j,&k,&l);

        F[j][k]=min(F[j][k],l);
        F[k][j]=min(F[k][j],l);
    }
}

void Floyd()
{
    fo(k,1,n)
    {
        fo(i,1,n)
        if (i!=k)
        {
            fo(j,1,n)
            if (j!=i && j!=k && F[i][j]>F[i][k]+F[k][j])
            F[i][j]=F[i][k]+F[k][j];
        }
    }
}

void Init()
{
    memset(g,60,sizeof(g));
    g[0]=0;
    fo(i,0,P[n]-1)
    {
        fo(j,1,n-1)
        if (!(i&P[j]))
        {
            fo(k,j+1,n)
            if (!(i&P[k]))
            g[i|P[j]|P[k]]=min(g[i|P[j]|P[k]],g[i]+F[j][k]);
        }
    }
}

void add(int t)
{
    if (a2[t]<=1)
    a2[t]++,s+=p[t]; else a2[t]--,s-=p[t];
}

void Work()
{
    memset(f,60,sizeof(f));
    f[0]=s;
    h=0;t=1;
    d[1]=0;
    while (h<t)
    {
        h++;
        j=d[h];
        fo(i,1,n)
        {
            a[i]=j%3;
            j/=3;
        }

        fo(i,1,n)
        if (!a[i])
        {
            fo(j,1,n)
            if (j!=i && a[j] || !d[h] && j==1)
            {
                s=d[h];

                fo(k,1,n) a2[k]=a[k];

                sum=f[d[h]];
                if (!b[i][j])
                {
                    sum+=F[i][j];
                    add(i);add(j);
                }

                fo(k,1,n)
                {
                    fo(l,1,c[A[i]][k])
                    add(k);
                }

                if (f[s]>sum)
                {
                    f[s]=min(f[s],sum);
                    d[++t]=s;
                }
            }
        }
    }
}

void Answer()
{
    ans=233333333;
    fo(i,0,p[n+1]-1)
    if (f[i]<1000000000)
    {
        if (!(i%3)) continue;

        bz=1;
        j=i;
        fo(k,1,n)
        {
            a[k]=j%3;
            j/=3;
        }

        fo(k,1,n)
        if (A[k] && !a[k])
        {
            bz=0;
            break;
        }
        if (!bz) continue;

        k=0;
        fd(j,n,1)
        k=k*2+(a[j]==1);

        ans=min(ans,f[i]+g[k]);
    }
    printf("%d\n",ans);
}

int main()
{
    Read();
    dfs();
    Floyd();
    Init();
    Work();
    Answer();
}