hdu3338 最大流

题意: 

           给你一个N*M的网格,上面有的有一些数字,要求填充数字,满足的规则是这样:

答案不唯一,只要满足和的关系就可以,还有就是只能用1--9之间的数字填充,而且每一行或一列可以重复使用某个数字,观察每个要填充的点我们会发现,其实该点只于他所在的"行和"限制和所在的"列和"限制,我们可以把点分为三类,白色填充,左下半有数,右下半

有数 ,(其他的没用,不用管 ,左下和右上都有数的一定要拆成两个点),只要权衡好这三类点就ok了,那么我们可以直接添加 超级远点s ,超级汇点e ,左下进右上出(也可以反过来);题目要求是1--9 ,最大流可能会产生0所以直接0--8,输出的时候在+1就行.题意既然说是保证有解,那么最大流肯定会满流,最后每个点流多少就输出多少+1就ok;

建图:

(1)s 和所有左下有数的点连 ,流量是左下的数字减去他下面空白行的个数(因为是0--8每个都少了1 ,一共有多少个就少多少个)

(2)所有左下角有数的点和他下面的这一列的空白点相连,流量 8

(3)所有右上角有数的被他所在的这一列空白的连接,记住是被连接,(方向别反了),还有注意一点就是如果该点左下角有数了,那么一定要拆点,不然会冲突,流量是8;

(4)第三步中所有被连接的点在连接e,流量是该点右上角的数 - 这一行的空白格子个数.原因和(1) 一样.

      建图后直接一遍最大流,然后根据流量情况就能输出答案了, 题目是 Special Judge ..所以随便跑一遍就行了,还有就是别用DINIC,会超时,就算我把点都离散化了依然超时,我用的是

SAP之前没用过,随便找了个模板改改用的. 当某个点有两个值时一定要拆点.同时可以离散化去优化.  

下面是代码,第一个是TLE代码(DINIC),第二个是AC代码(SAP);

// 超时的DINIC

#include<stdio.h>

#include<string.h>

#include<queue>

#define N_node 100 * 100 * 2 + 100

#define N_edge 500000

#define N 100 + 5

#define inf 1000000000

using namespace std;

typedef struct

{

   char node[8];

}NODE;

typedef struct

{

   int to ,next ,cost;

}STAR;

typedef struct

{

   int x ,dep;

}DEP;

NODE map[N][N];

STAR E[N_edge]; 

DEP xin ,tou;

int list[N_node] ,tot;

int list2[N_node] ,deep[N_node];

int X[N*N*2+100];

void add(int a ,int b ,int c)

{

   E[++tot].to = b;

   E[tot].cost = c;

   E[tot].next = list[a];

   list[a] = tot;

   

   E[++tot].to = a;

   E[tot].cost = 0;

   E[tot].next = list[b];

   list[b] = tot;

}

int minn(int x ,int y)

{

   return x < y ? x : y;

}

bool BFS_DEEP(int s ,int t ,int n)

{

   memset(deep ,255 ,sizeof(deep));

   deep[s] = 0;

   xin.x = s ,xin.dep = 0;

   queue<DEP>q;

   q.push(xin);

   while(!q.empty())

   {

      tou = q.front();

      q.pop();

      for(int k = list[tou.x] ;k ;k = E[k].next)

      {

         xin.x = E[k].to;

         xin.dep = tou.dep + 1;

         if(deep[xin.x] != -1 || !E[k].cost)

         continue;

         deep[xin.x] = xin.dep;

         q.push(xin);

      }

   }

   for(int i = 0 ;i <= n ;i ++)

   list2[i] = list[i];

   return deep[t] != -1;

}

int DFS_FLOW(int s ,int t ,int flow)

{

   if(s == t) return flow;        

   int nowflow = 0;

   for(int k = list2[s] ;k ;k = E[k].next)

   {

      list2[s] = k;

      int to = E[k].to;

      int c = E[k].cost;

      if(deep[to] != deep[s] + 1 || !c)

      continue;

      int temp = DFS_FLOW(to ,t ,minn(c ,flow - nowflow));

      nowflow += temp;

      E[k].cost -= temp;

      E[k^1].cost += temp;

      if(nowflow == flow) break;

   }

   if(!nowflow) deep[s] = 0;

   return nowflow;

}

int DINIC(int s ,int t ,int n)

{

   int ans = 0;

   while(BFS_DEEP(s ,t ,n))

   {        

      ans += DFS_FLOW(s ,t ,inf);

   }

   return ans;

}

int main ()

{

   int i ,j ,n ,m ,s ,e;

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

   {

      int sum_n = 0;

      for(i = 1 ;i <= n ;i ++)

      for(j = 1 ;j <= m ;j ++)

      {

         scanf("%s" ,map[i][j].node);

         if(map[i][j].node[0] == '.')

         {

            sum_n ++;

            continue;

         }

         if(map[i][j].node[0] != 'X')

         sum_n ++;

         if(map[i][j].node[4] != 'X')

         sum_n ++;

      }

          

      s = 0 ,e = sum_n + 1;

      sum_n = 0;

      memset(X ,255 ,sizeof(X));                      

      memset(list ,0 ,sizeof(list)) ,tot = 1;

      for(i = 1 ;i <= n ;i ++)

      for(j = 1 ;j <= m ;j ++)

      {

         if(map[i][j].node[3] == 'X' || map[i][j].node[0] == '.') continue;

         char t_str[8];

         for(int ii = 0 ;ii <= 7 ;ii ++)

         t_str[ii] = map[i][j].node[ii];

         int a ,b ,mk = 0;

         if(X[(i-1)*m+j] == -1) X[(i-1)*m+j] = ++sum_n;

         int now =  X[(i-1)*m+j];

         if(t_str[0] != 'X')

         {

            mk = 1;

            int temp = (t_str[0]-48)*100+(t_str[1]-48)*10+(t_str[2]-48)*1; 

            for(int ii = i + 1 ;ii <= n ;ii ++)

            {

               if(map[ii][j].node[0] != '.')

               break;

               temp --;

               if(X[(ii - 1) * m + j] == -1) X[(ii - 1) * m + j] = ++sum_n;

               b = X[(ii - 1) * m + j];       

               add(now ,b ,8);

            }

            add(s ,now ,temp);

         }

         

         if(t_str[4] != 'X')

         {                    

            if(mk) now = ++sum_n;

            int temp = (t_str[4]-48)*100+(t_str[5]-48)*10+(t_str[6]-48)*1;

            for(int jj = j + 1 ;jj <= m ;jj ++)

            {

               if(map[i][jj].node[0] != '.')

               break;

               temp --;

               if(X[(i - 1) * m + jj] == -1) X[(i - 1) * m + jj] = ++sum_n;

               a = X[(i - 1) * m + jj];

               add(a ,now ,8);

            }

            add(now ,e ,temp);

         }

      }

      

      DINIC(s ,e ,sum_n + 1);

      for(i = 1 ;i <= n ;i ++)

      for(j = 1 ;j <= m ;j ++)

      {

         if(j != 1) printf(" ");

         if(map[i][j].node[0] != '.')

         printf("_");

         else

         {

            int k = list[X[(i - 1) * m + j]];

            int c = E[k].cost;

            printf("%d" ,8 - c + 1);

         }

         if(j == m) printf("\n");

      }

   }

   return 0;

}
  

//SAP ac

#include<stdio.h>

#include<string.h>

#include<queue>

#define N 100 + 5

using namespace std;

typedef struct

{

   char node[8];

}NODE;

NODE map[N][N];

int X[50000];

//***********************************************

const int MAXN=50000;//点数的最大值

const int MAXM=1000000;//边数的最大值

const int INF=0x3f3f3f3f;

struct Node

{

    int from,to,next;

    int cap;

}edge[MAXM];

int tol;

int head[MAXN];

int dep[MAXN];

int gap[MAXN];//gap[x]=y :说明残留网络中dep[i]==x的个数为y

int nn;//n是总的点的个数，包括源点和汇点

void init()

{

    tol=0;

    memset(head,-1,sizeof(head));

}

void addedge(int u,int v,int w)

{

    edge[tol].from=u;

    edge[tol].to=v;

    edge[tol].cap=w;

    edge[tol].next=head[u];

    head[u]=tol++;

    edge[tol].from=v;

    edge[tol].to=u;

    edge[tol].cap=0;

    edge[tol].next=head[v];

    head[v]=tol++;

}

void BFS(int start,int end)

{

    memset(dep,-1,sizeof(dep));

    memset(gap,0,sizeof(gap));

    gap[0]=1;

    int que[MAXN];

    int front,rear;

    front=rear=0;

    dep[end]=0;

    que[rear++]=end;

    while(front!=rear)

    {

        int u=que[front++];

        if(front==MAXN)front=0;

        for(int i=head[u];i!=-1;i=edge[i].next)

        {

            int v=edge[i].to;

            if(dep[v]!=-1)continue;

            que[rear++]=v;

            if(rear==MAXN)rear=0;

            dep[v]=dep[u]+1;

            ++gap[dep[v]];

        }

    }

}

int SAP(int start,int end)

{

    int res=0;

    BFS(start,end);

    int cur[MAXN];

    int S[MAXN];

    int top=0;

    memcpy(cur,head,sizeof(head));

    int u=start;

    int i;

    while(dep[start]<nn)

    {

        if(u==end)

        {

            int temp=INF;

            int inser;

            for(i=0;i<top;i++)

               if(temp>edge[S[i]].cap)

               {

                   temp=edge[S[i]].cap;

                   inser=i;

               }

            for(i=0;i<top;i++)

            {

                edge[S[i]].cap-=temp;

                edge[S[i]^1].cap+=temp;

            }

            res+=temp;

            top=inser;

            u=edge[S[top]].from;

        }

        if(u!=end&&gap[dep[u]-1]==0)//出现断层，无增广路

          break;

        for(i=cur[u];i!=-1;i=edge[i].next)

           if(edge[i].cap!=0&&dep[u]==dep[edge[i].to]+1)

             break;

        if(i!=-1)

        {

            cur[u]=i;

            S[top++]=i;

            u=edge[i].to;

        }

        else

        {

            int min=nn;

            for(i=head[u];i!=-1;i=edge[i].next)

            {

                if(edge[i].cap==0)continue;

                if(min>dep[edge[i].to])

                {

                    min=dep[edge[i].to];

                    cur[u]=i;

                }

            }

            --gap[dep[u]];

            dep[u]=min+1;

            ++gap[dep[u]];

            if(u!=start)u=edge[S[--top]].from;

        }

    }

    return res;

}

//**************************************

int main ()

{

   int i ,j ,n ,m ,s ,e;

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

   {

      int sum_n = 0;

      for(i = 1 ;i <= n ;i ++)

      for(j = 1 ;j <= m ;j ++)

      {

         scanf("%s" ,map[i][j].node);

         if(map[i][j].node[0] == '.')

         {

            sum_n ++;

            continue;

         }

         if(map[i][j].node[0] != 'X')

         sum_n ++;

         if(map[i][j].node[4] != 'X')

         sum_n ++;

      }

         

      s = 0 ,e = sum_n + 1;

      sum_n = 0;

      memset(X ,255 ,sizeof(X));                      

      memset(head ,255 ,sizeof(head));

      tol = 0;

      for(i = 1 ;i <= n ;i ++)

      for(j = 1 ;j <= m ;j ++)

      {

         if(map[i][j].node[3] == 'X' || map[i][j].node[0] == '.') continue;

         char t_str[8];

         for(int ii = 0 ;ii <= 7 ;ii ++)

         t_str[ii] = map[i][j].node[ii];

         int a ,b ,mk = 0;

         if(X[(i-1)*m+j] == -1) X[(i-1)*m+j] = ++sum_n;

         int now =  X[(i-1)*m+j];

         if(t_str[0] != 'X')

         {

            mk = 1;

            int temp = (t_str[0]-48)*100+(t_str[1]-48)*10+(t_str[2]-48)*1; 

            for(int ii = i + 1 ;ii <= n ;ii ++)

            {

               if(map[ii][j].node[0] != '.')

               break;

               temp --;

               if(X[(ii - 1) * m + j] == -1) X[(ii - 1) * m + j] = ++sum_n;

               b = X[(ii - 1) * m + j];       

               addedge(now ,b ,8);

            }

            addedge(s ,now ,temp);

         }

         

         if(t_str[4] != 'X')

         {                    

            if(mk) now = ++sum_n;

            int temp = (t_str[4]-48)*100+(t_str[5]-48)*10+(t_str[6]-48)*1;

            for(int jj = j + 1 ;jj <= m ;jj ++)

            {

               if(map[i][jj].node[0] != '.')

               break;

               temp --;

               if(X[(i - 1) * m + jj] == -1) X[(i - 1) * m + jj] = ++sum_n;

               a = X[(i - 1) * m + jj];

               addedge(a ,now ,8);

            }

            addedge(now ,e ,temp);

         }

      }

      

      nn = sum_n + 1 + 1;

      SAP(s ,e);

      for(i = 1 ;i <= n ;i ++)

      for(j = 1 ;j <= m ;j ++)

      {

         if(j != 1) printf(" ");

         if(map[i][j].node[0] != '.')

         printf("_");

         else

         {

            int k = head[X[(i - 1) * m + j]];

            int c = edge[k].cap;

            printf("%d" ,8 - c + 1);

         }

         if(j == m) printf("\n");

      }

   }

   return 0;

}