网络流强化-HDU 3338-上下界限制最大流

　　题意是：

　　一种特殊的数独游戏，白色的方格给我们填1-9的数，有些带数字的黑色方格，右上角的数字代表从他开始往右一直到边界或者另外一个黑格子，中间经过的白格子的数字之和要等于这个数字；左下角的也是一样的意思，只是作用对象成了它下方的白格子。

　　思路：

　　既然所有行的数字之和等于所有列的数字之和，那么我们可以将行方向（向右）的点作为与源点连接的点，列方向（向下）的点作为与汇点连接的点。

　　由于向右和向下的点可能在同一块方格里面，以及我们需要设置每个白格子的容量，所以我们需要拆点。

　　题目要求填1-9的数，所以白格子起码都是1，我们不妨假设这些基础的1已经填好了，那么将对应行方向的点的入边（来自源点）容量减去该点作用范围内的白格子数目，将对应列方向的点的出边（去到汇点）容量减去该点作用范围内的白格子数目。然后设置白格子的容量为8就能保证填的都是1-9的数了。

　　

#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define maxe 100128  //pay  双向边 一共10万条路 双向就是20万 反边就是40万
#define maxv 20128   //pay
#define maxn 105    //pay
#define sc scanf
#define pt printf
#define rep(i,a,b)  for(int i=(a);i<(b);++i)
const int inf = 0x3f3f3f3f; 
int cg,sp,ins;  //cg change sp是总流量 ins是加速回溯点
int N,M,s,t,delta,UP_LIMIT;
int q[maxv],fro,rea;
typedef struct ed{
    int v,nxt,cap; //dis
}ed;
ed e[maxe];
int tot,head[maxv],cur[maxv],vis[maxv],bk[maxv],d[maxv],num[maxv]; //
int mi(int a,int b) {return a<b?a:b;}
int mx(int a,int b) {return a>b?a:b;}
void add(int u,int v,int cap)
{
    e[tot].v=v;         e[tot].nxt=head[u];
    /*e[tot].dis=dis;*/     e[tot].cap=cap;
    head[u]=tot++;

    e[tot].v=u;         e[tot].nxt=head[v];
    /*e[tot].dis=-dis;*/    e[tot].cap=0;
    head[v]=tot++;
} 
// 仅有一次的BFS为ISAP节省了不少时间 
bool bfs()
{
    //数组模拟queue
    int u,v,i,my_all = t;
    for(i=0;i<=my_all;++i) vis[i]=num[i]=0;  //无须一定是my_all，涉及所有即可~~~~~~~~~~~~~~~~~~ 
    for(i=0;i<=my_all;++i) d[i]=UP_LIMIT;    //UP_LIMIT的设定是比最高的层次大1
    fro = rea = 0;
    q[rea] = t; ++rea;
    vis[t] = 1;
    d[t] = 0;
    ++num[d[t]];
    while (rea>fro) 
    {
        u = q[fro]; ++fro;
        //pt("BFSing~ : u=%d
",u);
        for (i=head[u]; i!=-1; i=e[i].nxt) 
        {
            v=e[i].v;
            if (!vis[v] && e[i^1].cap ) 
            {
                vis[v] = true;
                d[v] = d[u] + 1;
                ++num[d[v]];
                q[rea] = v; ++rea;
                //pt("普度众生 u=%d,v=%d,d[u]=%d,d[v]=%d
",u,v,d[u],d[v]);
            }
        }
    }
    //int last_ed=-1;
    //把连接了到不了终点的点的边都去除 如果确定都能和终点连接 就不需要 
    /*for(u=0;u<=my_all;++u)
    {
        if(!vis[u]) continue;
        for (i=head[u]; i!=-1; i=e[i].nxt) 
        {
            v=e[i].v;
            if(!vis[v])
            {
                if(i==head[u]){
                    head[u] = e[i].nxt;
                    continue;
                }
                else{
                    e[last_ed].nxt = e[i].nxt;
                    continue;
                }
            }
            last_ed = i;
        }
    }*/
    return vis[s];
}
// 增广
int augment()/*单源单汇 不用查这个*/
{
    int  flow = inf, i;
    cg = t;
    // 从汇点到源点通过 p 追踪增广路径, flow 为一路上最小的残量
    while (cg != s) {
        i = bk[cg];
        if(flow>=e[i].cap)
        {
            flow = e[i].cap;
            ins = e[i^1].v;     
            //用来加速寻找，在最小流量断开的地方重新开始寻找
            //嗯，等一下 我这个是从终点往起点寻找，而确定增光路径是从起点到终点
            //那么起点是河流的上游，那么回溯的河段应该尽可能的往上游靠近
            //所以应该将flow>e[i].cap的大于号改成大于等于号
        }
        cg = e[i^1].v;
    }
    cg = t;
    // 从汇点到源点更新流量
    while (cg != s) {
        i = bk[cg];
        e[i].cap -= flow;
        e[i^1].cap += flow;
        cg = e[i^1].v;
    }
    return flow;
}
//由于每次修改层次的时候，都是在到剩下子节点的距离中挑选最短的加1 所以层次分明不会出现死循环 
int max_flow()
{
    int flow = 0,i,u,v;
    bool advanced;
    if(bfs()==false) return 0;
    //pt("零层妖塔=%d
",d[s]);
    u = s;
    memcpy(cur, head, sizeof(head));
    while (d[s] < UP_LIMIT)          //UP_LIMIT的设定是比最高的层次大1
    //终点是0，那么起点所在层次最多是N-1 同理，不是d[s]<t
    {
        if (u == t) 
        {
            flow += augment();
            u = ins;    //pay speed up
        }
        advanced = false;
        for (i = cur[u]; i!=-1; i=e[i].nxt) 
        { 
            v = e[i].v;
            //pt("SELECT: %d -> %d
",u,v); 
            if (e[i].cap && d[u] == d[v] + 1) 
            {
                advanced = true;
                bk[v] = i;
                cur[u] = i;
              //  pt("%d -> %d ::d[u]=%d,d[v]=%d
",u,v,d[u],d[v]); 
                u = v;
                break;
            }
        }
        if (!advanced) 
        { // retreat
            int base = UP_LIMIT;        //UP_LIMIT的设定是比最高的层次大1
            for (i = head[u]; i != -1; i=e[i].nxt)
            {
                if (e[i].cap&&base>d[e[i].v])
                {
                    cur[u] = i;
                    base = d[e[i].v];
                }
            }
            
            if (--num[d[u]] == 0)
            {
                //pt("u=%d,d=%d
",u,d[u]);
                //pt("BREAK FROM HERE
");
                break; // gap 优化
            } 
            ++num[d[u] = base+1]; 
            //pt("------------------我来增加层次%d：%d
",m+1,u);
            //我以前一直在想 如果没有找到怎么办呢 现在发现原来找不到的话距离会被赋成base+1 
            //—— 比上界还高 所以接下来不会再访问到这个点 这个点也没有机会被减成0了——不会莫名其妙地break，哈哈哈
            if (u != s)
            {
                //pt("from %d ",u);
                u = e[bk[u]^1].v;
                //pt("return to %d
",u);
            }
            else
            {
                // pt("STILL AT S:%d
",s);
            }
        }
    }
    return flow;
}

void init()
{
    tot=0;
    memset(head,-1,sizeof(head));   //pay 
}
char info[maxn][maxn][8];
int  ok_ed[maxn][maxn];
int is_black[maxn][maxn];
int LEFT[maxn][maxn],RIGHT[maxn][maxn];
//最大流部分没有什么问题了 关键在于终点源点、编号分配、题目理解建图上面
//切记：不要建立无用的边！！ 包括连接不到的点 和不和终点连通的点 
//确保所有的点都要和终点连通——这样才是合法的点
int main()
{
    freopen("in.txt","r",stdin);
    
    /*数据初始化区*/
    s=0, bk[0]=-1;

    /*变量存放区*/
    int i,j,u,v,id,who,sub;

    while(~sc("%d%d",&N,&M))
    {

        /*数据初始化区*/
        init(); sp = 0;
        for(i=0;i<N;++i) for(j=0;j<M;++j) is_black[i][j] = 0;
        for(i=0;i<N;++i) for(j=0;j<M;++j) LEFT[i][j] = RIGHT[i][j] = ok_ed[i][j] = -1;

        /*数据读取区*/
        for(i=0;i<N;++i) for(j=0;j<M;++j) sc("%s",info[i][j]);

        /*关键数据赋值区*/
        delta  = (N)*(M); t=2*delta+1; s=2*delta; 
        UP_LIMIT = 2*delta + 2; 
                //说明：这个是层次的无法达到的上界，所以一共有N个点的时候，
                //如果从0开始编号，那么上界就是N；如果从1开始编号，上界就是N+1

        /*数据处理区*/ /*建图区*/
        for(i=0;i<N;++i) for(j=0;j<M;++j)
        {
            if(info[i][j][0]=='.')  continue; 
            is_black[i][j] = 1; 
            if(info[i][j][0]!='X')  LEFT[i][j] = (info[i][j][0]-'0')*100+(info[i][j][1]-'0')*10+info[i][j][2]-'0';
            if(info[i][j][4]!='X') RIGHT[i][j] = (info[i][j][4]-'0')*100+(info[i][j][5]-'0')*10+info[i][j][6]-'0';
        }
        for(i=0;i<N;++i) for(j=0;j<M;++j)
        {
            if(is_black[i][j]==0)  continue; 
            if(LEFT[i][j]==-1&&RIGHT[i][j]==-1) continue;
            
            if(LEFT[i][j]!=-1)
            {
                id = i*M + j + delta; //往下的取小一点的编号
                v=j; u=i+1; sub = 0;
                while(u<N&&is_black[u][v]==0) ++sub,++u;
                LEFT[i][j]-=sub;
                add(id,t,LEFT[i][j]);
            }
            if(RIGHT[i][j]!=-1)
            {
                id = i*M + j ; //往下的取小一点的编号
                u=i; v=j+1;  sub=0;
                while(v<M&&is_black[u][v]==0) ++sub,++v;
                RIGHT[i][j]-=sub;
                add(s,id,RIGHT[i][j]);
            }
        }
        for(i=0;i<N;++i) for(j=0;j<M;++j)
        {
            if(is_black[i][j])  continue;
            id = i*M +j;            //!!!居然把这个放在后面，那建立边就会失败了，相当于用这次的容量帮上次的建边 
            add(id,id+delta,8); ok_ed[i][j] = tot - 2; //value[i][j] - cap就是分配的流量 
            
            /*OUTPUT*/
            v=j; u=i-1;
            while(is_black[u][v]==0) --u;
            who = u*M + v;
            add(id+delta,who+delta,inf);
            /*INPUT*/
            u=i; v=j-1;
            while(is_black[u][v]==0) --v;
            who = u*M + v ;
            add(who,id,inf);
        }
        /*答案处理区*/
        sp = max_flow();
        //pt("sp=%d
",sp);
        for(i=0;i<N;++i) for(j=0;j<M;++j)
        {
            if(j>0) pt(" ");
            if(is_black[i][j]==1) pt("_");
            else
            {
                who = ok_ed[i][j];
                pt("%d", 9 - e[who].cap   ); 
                
            } 
            if(j==M-1) pt("
");
        }
    }
    return 0;
}

/**
 * 友情链接：
 * http://www.renfei.org/blog/isap.html 解释ISAP原理
 * https://www.cnblogs.com/bosswnx/p/10353301.html 使用的数据结构和我的比较相近 
 */

 　　2019年8月18日17:11:56

　　想要知道这个增广大概是怎么回事，因为我之前觉得好像都是线性的。

　　假设先走S->A1->B1->T，之后B1->T已经满流，此时再走S->A2->B1->T，走不通了。

　　那么可以从B1往回增广走到A1，然后从A1开始增广寻找新的路径，如A1->B2->T。