hdu 4309 Seikimatsu Occult Tonneru ( dinic+二进制求最小费用)

题目链接：哆啦A梦传送门

题意：给出n个城市，每个城市有人，现在要使得所有城市的人尽量都掩藏在隧道中。这些城市之间有三种可互相连通的通道。

1. 桥：可以通过桥从u点到v点。但是这个桥坏了，只能给一人通过，不过我们要是花费w钱的话，这座桥就可通过任意次数。
2. 路：可以通过路从u点到v点
3. 隧道：可以通过隧道从u点到v点，此外这个隧道可以掩藏w人。

现在我们要在花费尽可能少的情况下，掩藏更多的人。

输入：第一行 n，m。m条通道

第二行：每个城市的人city[]。

接下来有m行，每行u，v，w，p。

p==0表示路，p>0表示桥，p<0表示隧道。

 

题解：参考博客

这里因为桥可以修也不可修，要直接建模的话，不是那么好建，但我们看到桥最大只有12座，故我们可以暴力枚举1<<12，先求好费用，我们再跑个最大流。

最大流建模：

源点到城市点，权值为该城市的人口。

当为桥时：将u与v建边，如果该桥被修，权值为INF（表示可以通过任意次数），反则权值为1。

当为路时：将u与v建边，权值为INF。

当为隧道时：将u与v建边，权值为INF。将u点到汇点建边，权值为该隧道的容纳量w。

 

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int N=30010;
const int INF=0x3f3f3f3f;

struct edge{
    int from,to,w,next;
}e[N<<1];
int cnt;

int dep[1111],head[1111];
//queue<int> que;


void init(){
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v,int w)
{
    e[cnt].from=u;
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt++;

     e[cnt].from=v;
    e[cnt].to=u;
    e[cnt].w=0;
    e[cnt].next=head[v];
    head[v]=cnt++;
}

int bfs(int s,int t)
{
//    while(!que.empty()) que.pop();
    queue<int> que;
    memset(dep,-1,sizeof(dep));

    dep[s]=0;
    que.push(s);

    while(!que.empty()){
        int u=que.front();
        que.pop();
//        if(u==t) return 1;
            for(int i=head[u];i!=-1;i=e[i].next){
                int w=e[i].w;
                int v=e[i].to;
            if(w&&dep[v]==-1){
                dep[v]=dep[u]+1;
                que.push(v);
                if(v==t) return 1;
            }
        }

    }
    return 0;
}

int dfs(int u,int mi,int t){
    if(u==t||mi==0) return mi;
    int tmp;
    int ret=0;
//    for(int v=1;v<=t;v++){
        for(int i=head[u];i!=-1;i=e[i].next){
            int w=e[i].w;
            int v=e[i].to;
        if(w&&dep[v]==dep[u]+1&&mi-ret>0){ ///mi-ret>0少一次递归，优化
           tmp=dfs(v,min(mi-ret,w),t) ;
           if(!tmp) dep[v]=0;
           e[i].w-=tmp;
            e[i^1].w+=tmp;
            ret+=tmp;
            if(ret==mi) return ret;
        }
    }
    return ret;
}

int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t)){
            ans+=dfs(s,INF,t);
    }
    return ans;
}

int city[1010],ui[1010],vi[1010],w[1010],pi[1010];
int main()
{


       int n,m;
       while(~scanf("%d%d",&n,&m))
       {

           int ans=0,s=0,t=n+1;

           for(int i=1;i<=n;i++)
           {
               scanf("%d",&city[i]);
           }

           int k=0;
           bool flag=1;
           for(int i=1;i<=m;i++)
           {
               scanf("%d%d%d%d",&ui[i],&vi[i],&w[i],&pi[i]);
               if(pi[i]>0) k++;
               if(pi[i]<0) flag=0;
           }
           if(flag){
            puts("Poor Heaven Empire");
            continue;
           }

           int tot=1<<k,temp;

           int cost=0,sum=0;

           for(int i=0;i<tot;i++) ///枚举所有状态
           {

                init();
                ans=0;
                temp=0;
                for(int j=1;j<=n;j++)
                {
                    add(s,j,city[j]);
                }
               for(int j=1;j<=m;j++)
               {
                   if(pi[j]>0) {/// 桥

                    if(i&(1<<temp)){
                            ans+=w[j];
                    add(ui[j],vi[j],INF);
                    }
                    else{
                        add(ui[j],vi[j],1);
                    }
                    temp++;

                   }
                   else if(pi[j]==0){ ///路
                    add(ui[j],vi[j],INF);
                   }
                   else{ ///隧道
                    add(ui[j],vi[j],INF);

                    add(ui[j],t,w[j]);
                   }
               }

               int item=dinic(s,t);
//               printf("item=%d\n",item);
               if(sum<item||(item==sum&&cost>ans)){
                sum=item;
                cost=ans;
               }
           }
           if(sum==0){
            puts("Poor Heaven Empire");
           }
           else{
            printf("%d %d\n",sum,cost);
           }


       }





    return 0;
}