bzoj 4479: [Jsoi2013]吃货jyy 欧拉回路+状压dp

题意

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

分析

很容易想到可以找到一条总1开始回到1的路径，当且仅当所有走过的边组成的图，满足每个点的度数均为偶数。
一开始想的是状压每个点的度数是奇数还是偶数，然后发现无法判断该图是否是连通图。
正解是逐个加点来构成一个连通图，用三进制来状压，0,1,2分别表示不在连通图中，在连通图中且度为奇数，在连通图中且度为偶数。
转移的时候考虑枚举一个不在连通图中的点，然后有两种转移，一种是该点通过一条必须要走的边与连通图相连，那么贡献为0；一种是通过与某个点j的最短路径来与连通图相连，同时这两个点的度数奇偶性都要变化。
这时我们求出了组成某些连通图的最小代价，但这不一定满足所有点的度数都是偶数。这时就可以把所有奇度数点拿出来用最短路两两匹配，取最小值即可。这个匹配可以先dp预处理出来。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#define MIN(x,y) x=min(x,y)
#define inf 0x3f3f3f3f
using namespace std;

const int N=15;

int n,m,dis[N][N],cnt,last[N],g[9005],f[1600005],bin[N],pow[N],a[N],deg[N];
struct edge{int to,next,w;}e[N*10];
queue<int> que;

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void addedge(int u,int v,int w)
{
    e[++cnt].to=v;e[cnt].w=w;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].w=w;e[cnt].next=last[v];last[v]=cnt;
}

void floyd()
{
    for (int k=1;k<=n;k++)
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++)
                MIN(dis[i][j],dis[i][k]+dis[k][j]);
}

void pre_dp()
{
    memset(g,inf,sizeof(g));
    g[0]=0;
    for (int i=0;i<bin[n];i++)
        for (int j=1;j<=n;j++)
            if (!(i&bin[j-1]))
                for (int k=j+1;k<=n;k++)
                    if (!(i&bin[k-1]))
                        MIN(g[i^bin[j-1]^bin[k-1]],g[i]+dis[j][k]);
}

void dp()
{
    memset(f,inf,sizeof(f));
    f[2]=0;que.push(2);
    while (!que.empty())
    {
        int s=que.front(),tot=0;que.pop();
        for (int i=1;i<=n;i++) if (s/pow[i-1]%3>0) a[++tot]=i;
        for (int i=1;i<=n;i++)
            if (s/pow[i-1]%3==0)
            {
                for (int j=last[i];j;j=e[j].next)
                    if (s/pow[e[j].to-1]%3>0)
                    {
                        int s1=s+pow[i-1]*2;
                        if (f[s]>=f[s1]) continue;
                        if (f[s1]==inf) que.push(s1);
                        f[s1]=f[s];
                    }
                for (int j=1;j<=tot;j++)
                {
                    int s1=s+pow[i-1];
                    s1+=(s/pow[a[j]-1]%3==1)?pow[a[j]-1]:-pow[a[j]-1];
                    if (f[s]+dis[i][a[j]]>=f[s1]) continue;
                    if (f[s1]==inf) que.push(s1);
                    f[s1]=f[s]+dis[i][a[j]];
                }
            }
    }
}

void calc()
{
    int ans=inf;
    for (int s=0;s<pow[n];s++)
    {
        int flag=0;
        for (int i=1;i<=n;i++) if (last[i]&&!(s/pow[i-1]%3)) {flag=1;break;}
        if (flag) continue;
        int now=s;
        for (int i=1;i<=n;i++) if (deg[i]&1) now+=(s/pow[i-1]%3==1)?pow[i-1]:-pow[i-1];
        int s1=0;
        for (int i=1;i<=n;i++) if (now/pow[i-1]%3==1) s1^=bin[i-1];
        MIN(ans,f[s]+g[s1]);
    }
    for (int i=1;i<=cnt;i+=2) ans+=e[i].w;
    printf("%d",ans);
}

int main()
{
    n=read();m=read();
    bin[0]=pow[0]=1;
    for (int i=1;i<=n;i++) bin[i]=bin[i-1]*2,pow[i]=pow[i-1]*3;
    memset(dis,inf,sizeof(dis));
    for (int i=1;i<=m;i++)
    {
        int x=read(),y=read(),z=read();
        dis[x][y]=dis[y][x]=min(dis[y][x],z);
        deg[x]++;deg[y]++;
        addedge(x,y,z);
    }
    m=read();
    while (m--)
    {
        int x=read(),y=read(),z=read();
        dis[x][y]=dis[y][x]=min(dis[y][x],z);
    }
    floyd();
    pre_dp();
    dp();
    calc();
    return 0;
}