hdu4888

Redraw Beautiful Drawings

Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 2007    Accepted Submission(s): 447

Problem Description
Alice and Bob are playing together. Alice is crazy about art and she has visited many museums around the world. She has a good memory and she can remember all drawings she has seen.
Today Alice designs a game using these drawings in her memory. First, she matches K+1 colors appears in the picture to K+1 different integers(from 0 to K). After that, she slices the drawing into grids and there are N rows and M columns. Each grid has an integer on it(from 0 to K) representing the color on the corresponding position in the original drawing. Alice wants to share the wonderful drawings with Bob and she tells Bob the size of the drawing, the number of different colors, and the sum of integers on each row and each column. Bob has to redraw the drawing with Alice's information. Unfortunately, somtimes, the information Alice offers is wrong because of Alice's poor math. And sometimes, Bob can work out multiple different drawings using the information Alice provides. Bob gets confused and he needs your help. You have to tell Bob if Alice's information is right and if her information is right you should also tell Bob whether he can get a unique drawing.
 
Input
The input contains mutiple testcases.
For each testcase, the first line contains three integers N(1 ≤ N ≤ 400) , M(1 ≤ M ≤ 400) and K(1 ≤ K ≤ 40). N integers are given in the second line representing the sum of N rows. M integers are given in the third line representing the sum of M columns.
The input is terminated by EOF.
 
Output
For each testcase, if there is no solution for Bob, output "Impossible" in one line(without the quotation mark); if there is only one solution for Bob, output "Unique" in one line(without the quotation mark) and output an N * M matrix in the following N lines representing Bob's unique solution; if there are many ways for Bob to redraw the drawing, output "Not Unique" in one line(without the quotation mark).
 
Sample Input
2 2 4
4 2
4 2
4 2 2
2 2 5 0
5 4
1 4 3
9
1 2 3 3
 
Sample Output
Not Unique
Impossible
Unique
1 2 3 3
 
Author
Fudan University
 
Source
 
Recommend
We have carefully selected several similar problems for you:  4910 4909 4908 4907 4906

大意：n*m的矩阵，每个格子可以是0~k，给出各行的和和各列的和，求格子数字唯一方案，或判断无解或不唯一。

题解：

最大流，每行一个点，每列一个点，起点到每行的点连流量等于这行的和的边，每列的点连流量等于这列的和的边到终点，每行的点连到每列的点流量为K的点。所有行的和不等于所有列的和 或 最大流不等于所有行的和 则无解。有解的话再判有没有环，有环说明多解，可以dfs判环。

我这题卡了好久，判环的地方怒有问题，后来我看别人代码，只用从1~nr（行数）作为起始位置就能判完，也就是从行的节点开始，如果所有节点都开始一发的话会超时……我觉得再开点东西来记忆的话应该可以更快点，日后再说吧。

日后：

有了更好的删边判环方法，具体见一道几乎相同的题的题解：http://www.cnblogs.com/yuiffy/p/3929369.html

因为要删边判环，边被删了不好输出结果，所以先记录结果再删就好啦。速度快得飞起来。

（我的网络流是n个点，下标1~n的ISAP+GAP+CUR，怕不怕）

日前代码：

  1.  #include<cstdio>
  2.  #include<cmath>
  3.  #include<iostream>
  4.  #include<cstring>
  5.  #include<algorithm>
  6.  #include<cmath>
  7.  #include<map>
  8.  #include<set>
  9.  using namespace std;
  10.  #define ll __int64
  11.  #define usint unsigned int
  12.  #define RE  freopen("1002.in","r",stdin)
  13.  #define WE  freopen("1002my.out","w",stdout)
  14.  
  15.  int ans;
  16.  int r[],co[];
  17.  int k,nr,nc;
  18.  int sumr,sumc;
  19.  const int maxn=;//点数
  20.  const int maxm=;//边数
  21.  const int inf=0x7fffffff;//MAXINT
  22.  struct vnode {
  23.      int v,next;
  24.      int cap;
  25.  };
  26.  int cnt,head[maxn];
  27.  int h[maxn],g[maxn],d[maxn];//g[i]为标号为i的结点个数，h[i]为i结点的标号，d[]当前弧优化，记录当前弧
  28.  bool found;
  29.  int n,m,st,ed;//n个点m条边
  30.  int augc,flow;//augc为增广路容量，flow为最大流
  31.  vnode e[maxm];
  32.  
  33.  void add(int x,int y,int z) {
  34.      e[cnt].v=y;
  35.      e[cnt].cap=z;
  36.      e[cnt].next=head[x];
  37.      head[x]=cnt;
  38.      cnt++;
  39.  //    if(cnt>=maxm|| x>=maxn||y>=maxn)
  40.  //    {
  41.  //        //cout<<x<<','<<y<<','<<z<<','<<cnt<<','<<head[x]<<','<<head[y]<<endl;
  42.  //        getchar();
  43.  //    }
  44.      e[cnt].v=x;
  45.      e[cnt].cap=;
  46.      e[cnt].next=head[y];
  47.      head[y]=cnt;
  48.      cnt++;
  49.  
  50.  }
  51.  
  52.  bool walked[maxn];
  53.  bool dfs(int x,int preE) {
  54.      //cout<<x<<',';
  55.      for (int i=head[x]; i!=-; i=e[i].next)//寻找容许边
  56.      {
  57.          if(i==(preE^))continue;
  58.          if (e[i].cap>) { //如果残留容量大于0，如果不是直接回头
  59.              if(walked[e[i].v])return true;
  60.              walked[e[i].v]=true;
  61.              if(dfs(e[i].v,i)) return true;
  62.              walked[e[i].v]=false;
  63.          }
  64.      }
  65.      //printf("(%d)out ",x);
  66.      //getchar();
  67.      return false;
  68.  }
  69.  
  70.  void aug(const int &m) {
  71.      int i,mini,minh=n-;
  72.      int augco=augc;
  73.      if (m==ed) { //如果当前结点为汇点
  74.          found=true;
  75.          flow+=augc;    //增加流量
  76.          return;
  77.      }
  78.      for (i=d[m]; i!=-; i=e[i].next) { //寻找容许边
  79.          //printf("m=%d,i=%d,e[i].v=%d,e[i].cap=%d,e[i].next=%d\n",m,i,e[i].v,e[i].cap,e[i].next);
  80.          //getchar();
  81.          if (e[i].cap && h[e[i].v]+==h[m]) { //如果残留容量大于0，如果是容许边
  82.              if (e[i].cap < augc)  augc=e[i].cap;//如果容许边流量小于当前增广路流量 则更新增广路流量
  83.              d[m]=i;    //把i定为当前弧
  84.              aug(e[i].v);    //递归
  85.              if (h[st]>=n) return; //GAP 如果源点距离标号大于n 则停止算法
  86.              if (found) break;    //如果找到汇点 则退出寻找
  87.              augc=augco;//没找到就还原当前的流
  88.          }
  89.      }
  90.      if (!found) {      //重标号
  91.          for (i=head[m]; i!=-; i=e[i].next) //找那个标号，这里不能用d[m]开始，不然会蛋疼
  92.              if (e[i].cap && h[e[i].v]<minh) {
  93.                  minh=h[e[i].v];
  94.                  mini=i;
  95.              }
  96.          g[h[m]]--;                                 //GAP 距离为
  97.          if (!g[h[m]]) h[st]=n;                 //GAP
  98.          h[m]=minh+;
  99.          d[m]=mini;
  100.          g[h[m]]++;                                 //GAP
  101.      } else {
  102.          //修改残量
  103.          e[i].cap-=augc;
  104.          e[i^].cap+=augc;
  105.      }
  106.  }
  107.  
  108.  void farm() {
  109.      int i,j,x,y,z;
  110.      memset(head,-,sizeof(head));
  111.      cnt=;
  112.      n=nc+nr+;
  113.      st=n-;
  114.      ed=n;
  115.      for(i=nc; i>=; i--)
  116.          add(st,i,co[i-]);
  117.      for(i=nr; i>=; i--)
  118.          add(nc+i,ed,r[i-]);
  119.      for(i=nc; i>=; i--)
  120.          for(j=nr; j>=; j--)
  121.              add(i,nc+j,k);
  122.      //printf("cnt=%d\n",cnt);
  123.      memset(h,,sizeof(h));
  124.      memset(g,,sizeof(g));
  125.      g[]=n;
  126.      flow=;
  127.      //printf("st=%d,head[st]=%d\n",st,head[st]);
  128.      for(i=; i<=n; i++)
  129.          d[i]=head[i];//当前弧初始化
  130.      while(h[st]<n) {
  131.          augc=inf;//初始化增广路容量为正无穷大
  132.          found=false;
  133.          aug(st);//从源点开始找
  134.      }
  135.      if(flow!=sumr) {ans=;return;}
  136.      //printf("%d\n",flow);
  137.      memset(walked,false,sizeof(walked));
  138.      for(i=;i<=nr;i++)  ///Why is nr?
  139.      {
  140.          //printf("start dfs(%d)\n",i);
  141.          if(dfs(i,-)) {ans=;return;}
  142.      }
  143.      ans=;
  144.      //printf("%d\n",flow);
  145.  }
  146.  
  147.  int main() {
  148.      //RE;
  149.      //WE;
  150.      int i,j;
  151.      while(scanf("%d%d%d",&nr,&nc,&k)!=EOF) {
  152.          sumr=;sumc=;
  153.          for(i=; i<nr; i++)
  154.          {
  155.              scanf("%d",&r[i]);
  156.              sumr+=r[i];
  157.          }
  158.          for(i=; i<nc; i++)
  159.          {
  160.              scanf("%d",&co[i]);
  161.              sumc+=co[i];
  162.          }
  163.          ans=;
  164.          if(sumr==sumc)farm();
  165.          if(ans==) printf("Impossible\n");
  166.          else if(ans!=) {
  167.              printf("Not Unique\n");
  168.  //            for(i=1; i<=nr; i++) {
  169.  //                for(j=head[nc+i]; j!=-1; j=e[j].next)
  170.  //                {
  171.  //                    if(e[j].v==ed)continue;
  172.  //                    printf("%d ",e[j].cap);
  173.  //                }
  174.  //                puts("");
  175.  //            }
  176.          } else {
  177.              printf("Unique\n");
  178.              for(i=; i<=nr; i++) {
  179.                  for(j=head[nc+i]; j!=-; j=e[j].next) {
  180.                      if(e[j].v==ed)continue;
  181.                      printf("%d",e[j].cap);
  182.                      int thenext=e[j].next;
  183.                      while(thenext!=-&&e[thenext].v==ed)thenext=e[thenext].next;
  184.                      if(thenext!=-)putchar(' ');
  185.                  }
  186.                  puts("");
  187.              }
  188.          }
  189.      }
  190.      //cout<<"end";
  191.      return ;
  192.  }

日后代码：

  1.  //#pragma comment(linker, "/STACK:102400000,102400000")
  2.  #include<cstdio>
  3.  #include<cmath>
  4.  #include<iostream>
  5.  #include<cstring>
  6.  #include<algorithm>
  7.  #include<cmath>
  8.  #include<map>
  9.  #include<set>
  10.  #include<stack>
  11.  #include<queue>
  12.  using namespace std;
  13.  #define ll long long
  14.  #define usll unsigned ll
  15.  #define mz(array) memset(array, 0, sizeof(array))
  16.  #define minf(array) memset(array, 0x3f, sizeof(array))
  17.  #define REP(i,n) for(i=0;i<(n);i++)
  18.  #define FOR(i,x,n) for(i=(x);i<=(n);i++)
  19.  #define RD(x) scanf("%d",&x)
  20.  #define RD2(x,y) scanf("%d%d",&x,&y)
  21.  #define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
  22.  #define WN(x) prllf("%d\n",x);
  23.  #define RE  freopen("1002.in","r",stdin)
  24.  #define WE  freopen("1002testout.txt","w",stdout)
  25.  #define mp make_pair
  26.  #define pb push_back
  27.  
  28.  int ans;
  29.  int r[],co[];
  30.  int k,nr,nc;
  31.  int sumr,sumc;
  32.  const int maxn=;//点数
  33.  const int maxm=;//边数
  34.  const int inf=0x7fffffff;//MAXINT
  35.  struct vnode {
  36.      int v,next;
  37.      int cap;
  38.  };
  39.  int cnt,head[maxn];
  40.  int h[maxn],g[maxn],d[maxn];//g[i]为标号为i的结点个数，h[i]为i结点的标号，d[]当前弧优化，记录当前弧
  41.  bool found;
  42.  int n,m,st,ed;//n个点m条边
  43.  int augc,flow;//augc为增广路容量，flow为最大流
  44.  vnode e[maxm];
  45.  
  46.  int an[maxn][maxn];
  47.  
  48.  void add(int x,int y,int z) {
  49.      e[cnt].v=y;
  50.      e[cnt].cap=z;
  51.      e[cnt].next=head[x];
  52.      head[x]=cnt;
  53.      cnt++;
  54.  //    if(cnt>=maxm|| x>=maxn||y>=maxn)
  55.  //    {
  56.  //        //cout<<x<<','<<y<<','<<z<<','<<cnt<<','<<head[x]<<','<<head[y]<<endl;
  57.  //        getchar();
  58.  //    }
  59.      e[cnt].v=x;
  60.  
  61.      e[cnt].cap=;
  62.      e[cnt].next=head[y];
  63.      head[y]=cnt;
  64.      cnt++;
  65.  
  66.  }
  67.  
  68.  bool walked[maxn];
  69.  bool dfs(const int &x,const int &prex) {///深搜判环
  70.      int biu=-;
  71.      walked[x]=true;
  72.      for (int i=head[x]; i!=-; i=e[i].next) {
  73.          if(e[i].v==prex) {
  74.              biu=i;
  75.              continue;
  76.          }
  77.          if (e[i].cap>) {
  78.              if(walked[e[i].v]) return true;
  79.              if(dfs(e[i].v,x)) return true;
  80.          }
  81.          if(biu==-) head[x]=e[i].next;///删边，因为走了这条边却没发现环
  82.          else e[biu].next=e[i].next;
  83.          biu=i;
  84.      }
  85.      walked[x]=false;
  86.      return false;
  87.  }
  88.  
  89.  void aug(const int &m) {
  90.      int i,mini,minh=n-;
  91.      int augco=augc;
  92.      if (m==ed) { //如果当前结点为汇点
  93.          found=true;
  94.          flow+=augc;    //增加流量
  95.          return;
  96.      }
  97.      for (i=d[m]; i!=-; i=e[i].next) { //寻找容许边
  98.          //printf("m=%d,i=%d,e[i].v=%d,e[i].cap=%d,e[i].next=%d\n",m,i,e[i].v,e[i].cap,e[i].next);
  99.          //getchar();
  100.          if (e[i].cap && h[e[i].v]+==h[m]) { //如果残留容量大于0，如果是容许边
  101.              if (e[i].cap < augc)  augc=e[i].cap;//如果容许边流量小于当前增广路流量 则更新增广路流量
  102.              d[m]=i;    //把i定为当前弧
  103.              aug(e[i].v);    //递归
  104.              if (h[st]>=n) return; //GAP 如果源点距离标号大于n 则停止算法
  105.              if (found) break;    //如果找到汇点 则退出寻找
  106.              augc=augco;//没找到就还原当前的流
  107.          }
  108.      }
  109.      if (!found) {      //重标号
  110.          for (i=head[m]; i!=-; i=e[i].next) //找那个标号，这里不能用d[m]开始，不然会蛋疼
  111.              if (e[i].cap && h[e[i].v]<minh) {
  112.                  minh=h[e[i].v];
  113.                  mini=i;
  114.              }
  115.          g[h[m]]--;                                 //GAP 距离为
  116.          if (!g[h[m]]) h[st]=n;                 //GAP
  117.          h[m]=minh+;
  118.          d[m]=mini;
  119.          g[h[m]]++;                                 //GAP
  120.      } else {
  121.          //修改残量
  122.          e[i].cap-=augc;
  123.          e[i^].cap+=augc;
  124.      }
  125.  }
  126.  
  127.  void farm() {
  128.      int i,j,x,y,z;
  129.      memset(head,-,sizeof(head));
  130.      cnt=;
  131.      n=nc+nr+;
  132.      st=n-;
  133.      ed=n;
  134.      for(i=nc; i>=; i--)
  135.          add(st,i,co[i-]);
  136.      for(i=nr; i>=; i--)
  137.          add(nc+i,ed,r[i-]);
  138.      for(i=nc; i>=; i--)
  139.          for(j=nr; j>=; j--)
  140.              add(i,nc+j,k);
  141.      //printf("cnt=%d\n",cnt);
  142.      memset(h,,sizeof(h));
  143.      memset(g,,sizeof(g));
  144.      g[]=n;
  145.      flow=;
  146.      //printf("st=%d,head[st]=%d\n",st,head[st]);
  147.      for(i=; i<=n; i++)
  148.          d[i]=head[i];//当前弧初始化
  149.      while(h[st]<n) {
  150.          augc=inf;//初始化增广路容量为正无穷大
  151.          found=false;
  152.          aug(st);//从源点开始找
  153.      }
  154.      if(flow!=sumr) {
  155.          ans=;
  156.          return;
  157.      }
  158.      //printf("%d\n",flow);
  159.      for(i=; i<=nr; i++) {
  160.          int k=;
  161.          for(j=head[nc+i]; j!=-; j=e[j].next) {
  162.              if(e[j].v==ed)continue;
  163.              an[i][k++]=e[j].cap;
  164.              int thenext=e[j].next;
  165.              while(thenext!=-&&e[thenext].v==ed)thenext=e[thenext].next;
  166.          }
  167.      }
  168.      memset(walked,false,sizeof(walked));
  169.      for(i=nr; i>=; i--) { ///Why is nr?
  170.          //printf("start dfs(%d)\n",i);
  171.          if(dfs(i,-)) {
  172.              ans=;
  173.              return;
  174.          }
  175.      }
  176.      ans=;
  177.      //printf("%d\n",flow);
  178.  }
  179.  
  180.  int main() {
  181.      //RE;
  182.      //WE;
  183.      int i,j;
  184.      while(scanf("%d%d%d",&nr,&nc,&k)!=EOF) {
  185.          sumr=;
  186.          sumc=;
  187.          for(i=; i<nr; i++) {
  188.              scanf("%d",&r[i]);
  189.              sumr+=r[i];
  190.          }
  191.          for(i=; i<nc; i++) {
  192.              scanf("%d",&co[i]);
  193.              sumc+=co[i];
  194.          }
  195.          ans=;
  196.          if(sumr==sumc)farm();
  197.          if(ans==) printf("Impossible\n");
  198.          else if(ans!=) {
  199.              printf("Not Unique\n");
  200.  //            for(i=1; i<=nr; i++) {
  201.  //                for(j=head[nc+i]; j!=-1; j=e[j].next)
  202.  //                {
  203.  //                    if(e[j].v==ed)continue;
  204.  //                    printf("%d ",e[j].cap);
  205.  //                }
  206.  //                puts("");
  207.  //            }
  208.          } else {
  209.              printf("Unique\n");
  210.              for(i=; i<=nr; i++) {
  211.                  if(nc>=)printf("%d",an[i][]);
  212.                  for(j=; j<=nc; j++) {
  213.                      printf(" %d",an[i][j]);
  214.                  }
  215.                  puts("");
  216.              }
  217.          }
  218.      }
  219.      //cout<<"end";
  220.      return ;
  221.  }

hdu4888 Redraw Beautiful Drawings 最大流+判环的更多相关文章

  1. HDU4888 Redraw Beautiful Drawings（2014 Multi-University Training Contest 3）

    Redraw Beautiful Drawings Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 65536/65536 K (Jav ...

  2. HDU4888 Redraw Beautiful Drawings（最大流唯一性判定：残量网络删边判环）

    题目 Source http://acm.hdu.edu.cn/showproblem.php?pid=4888 Description Alice and Bob are playing toget ...

  3. hdu 4888 Redraw Beautiful Drawings(最大流，判环)

    pid=4888">http://acm.hdu.edu.cn/showproblem.php?pid=4888 加入一个源点与汇点,建图例如以下: 1. 源点 -> 每一行相应 ...

  4. hdu4888 Redraw Beautiful Drawings（最大流）

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4888 题意:给一个矩阵没行的和和每列的和,问能否还原矩阵,如果可以还原解是否唯一,若唯一输出该矩阵. ...

  5. hdu 4888 Redraw Beautiful Drawings 最大流

    好难好难,将行列当成X和Y,源汇点连接各自的X,Y集,容量为行列的和,相当于从源点流向每一行,然后分配流量给每一列,最后流入汇点,这样执意要推断最后是否满流,就知道有没有解,而解就是每一行流向每一列多 ...

  6. hdu4888 Redraw Beautiful Drawings

    14更多学校的第二个问题 网络流量   分别以行,列作为结点建图 i行表示的结点到j列表示的结点的流量便是(i, j)的值 跑遍最大流   若满流了便是有解   推断是否unique  就是在残余网络 ...

  7. Redraw Beautiful Drawings（hdu4888）网络流+最大流

    Redraw Beautiful Drawings Time Limit: 3000/1500 MS (Java/Others) Memory Limit: 65536/65536 K (Java/O ...

  8. HDU Redraw Beautiful Drawings 推断最大流是否唯一解

    点击打开链接 Redraw Beautiful Drawings Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 65536/65536 ...

  9. 【HDU】4888 Redraw Beautiful Drawings 网络流【推断解是否唯一】

    传送门:pid=4888">[HDU]4888 Redraw Beautiful Drawings 题目分析: 比赛的时候看出是个网络流,可是没有敲出来.各种反面样例推倒自己(究其原因 ...

随机推荐

  1. Leetcode Perfect Square

    这道题首先想到的算法是DP.每个perfect square number对应的解都是1.先生成一个n+1长的DP list.对于每个i,可以用dp[i] = min(dp[j] + dp[i-j], ...

  2. XCode显示iOS Simulators时不显示系统版本号并出现Identifier(UUID)

    如果出现如下的显示问题,说明你添加了多个相同系统版本的iOS Simulators: 打开Windows->Devices,查看已经出现了相同版本的模拟器: 那么我们删除一些相同的模拟器,即可解 ...

  3. Linux Crontab 定时任务 命令详解

    一. Crontab 介绍 crontab命令的功能是在一定的时间间隔调度一些命令的执行. 1.1 /etc/crontab 文件 在/etc目录下有一个crontab文件,这里存放有系统运行的一些调 ...

  4. poj3484 Showstopper 二分

    题目地址 二分用的很是巧妙!关键是抽象出问题本质. #include <cstdio> #include <string> #include <cstring> ; ...

  5. Python 操作 mongodb 数据库

    原文地址:https://serholiu.com/python-mongodb 这几天在学习Python Web开发,于 是做准备做一个博客来练练手,当然,只是练手的,博客界有WordPress这样 ...

  6. AngularJs ngApp、ngBind、ngBindHtml、ngNonBindable

    ngApp 使用这个指令自动启动一个AngularJS应用.ngApp指令指定了应用程序的根节点,通常会将ngApp放置在网页的根节点如<body>或<html >标签的. 格 ...

  7. 区别 Jquery对象和Dom对象

    在讨论之前,先约定好定义变量的风格. 如果获取的对象是jQuery对象,那么在变量前加上$,例如: var $variable = jQuery对象; 如果获取的是DOM对象,则定义如下: var v ...

  8. hihoCoder1284机会渺茫(唯一分解定理 + 约分)

    题目链接 #1284 : 机会渺茫 时间限制:5000ms 单点时限:1000ms 内存限制:256MB 描述 小Hi最近在追求一名学数学的女生小Z.小Z其实是想拒绝他的,但是找不到好的说辞,于是提出 ...

  9. spring--学习之IOC DI

    2.1.1  IoC是什么 Ioc-Inversion of Control,即"控制反转",不是什么技术,而是一种设计思想.在Java开发中,Ioc意味着将你设计好的对象交给容器 ...

  10. phpcms后台获取当前登录账号的数据

    $amdinid=$_SESSION['userid'];$infoadmin=$this->admin->get_one(array('userid'=>$amdinid)); v ...