hdu 3605 /状态合并最大流

题意:N个人去m个星球,给出n个人可以去哪些星球的01矩阵。求是否能满足所有人都去。(n到10万,m<=10)

一看,起先一瞬间就建图,准备秒了,人向星球连边,直接最大流判断是否为n,提交超时。。。是啊,10W*10=100W条边,铁定超时。。

后来经牛提示:注意,m<10!  人的可以去星球,一共最多有10个,那只有 2^10次种情况,就是说x部与Y部连线情况很多点是一样的(所给的01矩阵,最多10W行,10列,必然有很多行是一样的)。所以X部只留1024个点,这些点中,点i含j个人的状态,者源点向其连边j,该点向可以去的连边,流量inf.

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxv=2000,maxe=200000;
int nume=0;int head[maxv];int e[maxe][3];
void inline adde(int i,int j,int c)
{
    e[nume][0]=j;e[nume][1]=head[i];head[i]=nume;
    e[nume++][2]=c;
    e[nume][0]=i;e[nume][1]=head[j];head[j]=nume;
    e[nume++][2]=0;
}
int ss,tt,n,m;
int vis[maxv];int lev[maxv];
bool bfs()
{
    for(int i=0;i<tt+1;i++)
      vis[i]=lev[i]=0;
    queue<int>q;
    q.push(ss);
    vis[ss]=1;
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        for(int i=head[cur];i!=-1;i=e[i][1])
        {
            int v=e[i][0];
            if(!vis[v]&&e[i][2]>0)
            {
                lev[v]=lev[cur]+1;
                vis[v]=1;
                q.push(v);
            }
        }
    }
    return vis[tt];
}
int dfs(int u,int minf)
{
    if(u==tt||minf==0)return minf;
    int sumf=0,f;
    for(int i=head[u];i!=-1&&minf;i=e[i][1])
    {
        int v=e[i][0];
        if(lev[v]==lev[u]+1&&e[i][2]>0)
        {
            f=dfs(v,minf<e[i][2]?minf:e[i][2]);
            e[i][2]-=f;e[i^1][2]+=f;
            sumf+=f;minf-=f;
        }
    }
    if(!sumf) lev[u]=-1;
    return sumf;
}
int dinic()
{
    int sum=0;
    while(bfs())sum+=dfs(ss,inf);
    return sum;
}
int contain[15];int mark[1025];
void read_build()
{
      int tx;
    for(int i=0;i<n;i++)
      {
         int tkind=0;
         for(int j=0;j<m;j++)
        {
            scanf("%d",&tx);
            if(tx==1)
           tkind=tkind|(tx<<(m-j-1));          //二进制压缩状态,或者开10维数组判重也方便。
        }
         mark[tkind]++;
      }
      for(int i=0;i<=1024;i++)
       {
           if(mark[i]!=0)
           adde(ss,i,mark[i]);
       }
       for(int i=0;i<=1024;i++)
       {
           if(mark[i]!=0)
          {
             int ti=i;int cwei=0;
             while(ti!=0)
             {
                if(ti%2==1)
                 adde(i,m-1-cwei+1024,inf);
                ti=ti/2;
                cwei++;
             }
          }
       }
      for(int i=0;i<m;i++)     //每个星球人数
       {
          scanf("%d",&contain[i]);
       }
       for(int i=0;i<m;i++)    //星球
     {
         adde(i+1024,tt,contain[i]);
     }
   /* for(int i=0;i<=n*m+1;i++)
      for(int j=head[i];j!=-1;j=e[j][1])
      {
          printf("%d->%d:%d\n",i,e[j][0],e[j][2]);
      }*/
}
void init()
{
    nume=0;  ss=1050;tt=ss+1;
    for(int i=0;i<=tt;i++)
      {
          head[i]=-1;
          contain[i]=mark[i]=0;
      }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        read_build();
        int ans=dinic();
        if(ans==n)printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

hdu 3605 /状态合并最大流

时间: 2024-10-19 01:09:15

hdu 3605 /状态合并最大流的相关文章

HDU 3605 Escape(最大流+缩点转换)

http://acm.hdu.edu.cn/showproblem.php?pid=3605 题目很简单,要求的就是最后能搬到星球上去的人的个数.刚开始看到,知道是最大流,就把人和星球都设为点,能生存就连线,权值为1,最后建立超级源点和超级汇点.求出最大流量即可.先是RE,开大数组后TLE.仔细算了,光光人到星球的便就可达到100w了,超时的概率太大了.后来找了解题报告,知道了缩点这一说,因为星球个数m最大只有10个,所以每个人最多只有1024种情况,把这每一种情况设为点(这里很抽象),将之与符

HDU 3605 Escape(状压+最大流)

Escape Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 9430    Accepted Submission(s): 2234 Problem Description 2012 If this is the end of the world how to do? I do not know how. But now scient

Hdu 3605 Escape (最大流 + 缩点)

题目链接: Hdu 3605  Escape 题目描述: 有n个人要迁移到m个星球,每个星球有最大容量,每个人有喜欢的星球,问是否所有的人都能迁移成功? 解题思路: 正常情况下建图,不会爆内存,但是TLE还是稳稳的.以前只遇到过网络流拆点建图,这个正好是缩点建图.吼吼吼~~~,建图的方式还是值得学习的. 因为星球数目最多十个,那么无论有多少个人,其不同选择也就2^10种咯.把不同的选择作为节点,节点就从10^5减少到了2^10,整整缩小了一个数量级呢.建立源点和汇点,源点和选择链接,边权为这种选

POJ 2135 Farm Tour &amp;&amp; HDU 2686 Matrix &amp;&amp; HDU 3376 Matrix Again 费用流求来回最短路

累了就要写题解,最近总是被虐到没脾气. 来回最短路问题貌似也可以用DP来搞,不过拿费用流还是很方便的. 可以转化成求满流为2 的最小花费.一般做法为拆点,对于 i 拆为2*i 和 2*i+1,然后连一条流量为1(花费根据题意来定) 的边来控制每个点只能通过一次. 额外添加source和sink来控制满流为2. 代码都雷同,以HDU3376为例. #include <algorithm> #include <iostream> #include <cstring> #in

HDU 3549 Flow Problem ( 最大流 -EK 算法)

C++,G++的读取速度差距也太大了 Flow Problem 题意:n,m表示n个点m条有向带权边 问:从1-n最大流多少 裸最大流,拿来练手,挺不错的 #include <iostream> #include <cstdlib> #include <cstdio> #include <cstring> #include <queue> #include <algorithm> const int N = 210; #define

HDU 2732 Leapin&#39; Lizards(最大流)

Leapin' Lizards Problem Description Your platoon of wandering lizards has entered a strange room in the labyrinth you are exploring. As you are looking around for hidden treasures, one of the rookies steps on an innocent-looking stone and the room's

HDU 3605 Escape【二分图多重匹配】

题意: 有n个人去m个星球  告诉你每个人想去哪些星球和每个星球最多容纳多少人,问能不能让所有人都满足 分析: 二分图多重匹配 代码: 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <vector> 5 using namespace std; 6 7 const int maxn = 100005; 8 const int maxm = 15; 9 10

HDU 4292Food(网络流之最大流)

题目地址:HDU 4292 水题. 由于每个人只能有1份,所以需要拆点限制流量.建图方法为,建一源点与汇点,将食物与源点相连,权值为食物额数量,将饮料与汇点相连,权值为饮料数量..然后将人进行拆点为i和i',将对应的i与i'连边权值为1,将i与它所对应的YES的食物连边,将i'与它所对应的YES的饮料连边,一次求最大流. 代码如下: #include <iostream> #include <stdio.h> #include <string.h> #include &

hdu 3605 Escape (二分图多重匹配)

Escape Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 4298    Accepted Submission(s): 1129 Problem Description 2012 If this is the end of the world how to do? I do not know how. But now scient