HDU 4309 Seikimatsu Occult Tonneru 状压枚举+网络流

这题其他的建模都很常见，只有一种特殊边就是第一次走过免费，之后再次走只花一次的钱就可以永久免费。 所以我下面就只说这个边怎么处理了。

我只碰到过第一次免费，然后每次走都要花一定的钱的情况，这种表示还没碰到过。。

然而我没有注意到，这题和12星座有关，于是这样的边最多只有12个？然后就可以状压枚举，因为第一次走是不用花钱的，我们可以直接加一条容量为1的边。之后状压枚举的时候，哪位为1就是花钱重建了哪座桥，计算花费的总和，再在原来的图上加一条容量为INF的边。这样就很方便了。

然后偷懒，枚举过程中重新建边的时候以为普通的边不用重建了，然后TLE了一次，之后发现加边过程中把head数组给改了，所以每次枚举时这张图还是必须全部重建的。

还是对状压不够敏感啊，下次看到数字在10左右的时候一定要警觉起来啊。

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

using namespace std;
const int MAXN = 210;
const int INF = 0x3f3f3f3f;
const int MAXM = 10000;
struct Edge
{
    int to,cap,flow,nex;
    Edge() {}
    Edge(int to,int cap,int flow,int nex):to(to),cap(cap),flow(flow),nex(nex) {}
}edge[MAXM];

struct node
{
    int u,v,cost,p;
}bri[MAXN],oth[MAXM];
int n,m,dis[MAXN],num[MAXN],tol,head[MAXN],ttol,cnt,c2;

void addedge(int u,int v,int cap)
{
    edge[tol]=Edge(v,cap,0,head[u]); head[u]=tol++;
    edge[tol]=Edge(u,0,0,head[v]); head[v]=tol++;
}

void init()
{
    memset(head,-1,sizeof head);
    tol=ttol=cnt=c2=0;
}

bool bfs(int s,int t)
{
    queue<int> que;
    memset(dis,-1,sizeof dis);
    dis[s]=0;
    que.push(s);
    while (!que.empty())
    {
        int u=que.front();que.pop();
        for (int i=head[u];~i;i=edge[i].nex)
        {
            int v=edge[i].to;
            if (dis[v]==-1 && edge[i].cap>edge[i].flow)
            {
                dis[v]=dis[u]+1;
                if (v==t) return true;
                que.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int t,int cap)
{
    if (u==t) return cap;
    int flow=0,f;
    for (int i=head[u];~i;i=edge[i].nex)
    {
        int v=edge[i].to;
        if (dis[v]==dis[u]+1 && edge[i].cap>edge[i].flow)
        {
            f=dfs(v,t,min(cap-flow,edge[i].cap-edge[i].flow));
            edge[i].flow += f;
            edge[i^1].flow -= f;
            flow += f;
            if (flow == cap) break;
        }
    }
    if (!flow) dis[u]=-1;
    return flow;
}

int dicnic(int s,int t)
{
    int flow=0,a;
    while (bfs(s,t))
        while ((a=dfs(s,t,INF))>0)
            flow+=a;
    return flow;
}

int main()
{
    while (scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for (int i=1;i<=n;i++)  scanf("%d",&num[i]);
        for (int i=1;i<=m;i++)
        {
            int u,v,w,p;
            scanf("%d%d%d%d",&u,&v,&w,&p);
            if (p<=0)
            {
                oth[c2].u=u;
                oth[c2].v=v;
                oth[c2].cost=w;
                oth[c2].p=p;
                c2++;
            }
            else
            {
                bri[cnt].u=u;bri[cnt].v=v;bri[cnt].cost=w;
                cnt++;
            }
        }
        int ans=0,cost=INF,X=1<<cnt,tmpcost,tmpans;
        for (int i=0;i<X;i++)
        {
            tol=0;
            memset(head,-1,sizeof head);
            for (int j=1;j<=n;j++) if (num[j]) addedge(0,j,num[j]);
            for (int j=0;j<c2;j++)
            {
                if (oth[j].p<0)
                    addedge(oth[j].u,n+1,oth[j].cost);
                addedge(oth[j].u,oth[j].v,INF);
            }
            for (int j=0;j<cnt;j++) addedge(bri[j].u,bri[j].v,1);
            tmpcost=0;
            int j=0;
            while (j<cnt && (1<<j)<=i)
            {
                if ( (i & (1<<j)) !=0 )
                {
                    addedge(bri[j].u,bri[j].v,INF);
                    tmpcost += bri[j].cost;
                }
                j++;
            }
            tmpans=dicnic(0,n+1);
            if (tmpans > ans)
            {
                ans=tmpans;
                cost=tmpcost;
            }
            else if (tmpans == ans)
                cost  = min(cost,tmpcost);
        }
        if (ans != 0)
            printf("%d %d\n",ans,cost);
        else
            printf("Poor Heaven Empire\n");
    }
    return 0;
}