L - Kakuro Extension - HDU 3338 - （最大流）

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN = 105;
const int oo = 1e9+7;

struct Graph
{///描述点的属性，是黑色还是白色，是行和还是列的和
///并且给他们编号（为了节约内存的设置，也可以直接用下标编号）
    int rowSum, rIndex;
    int polSum, pIndex;
    int white, wIndex;
}G[MAXN][MAXN];
struct Edge{int v, flow, next;}edge[MAXN*MAXN*MAXN];
int Head[MAXN*MAXN*2], cnt, Layer[MAXN*MAXN*2];
int Row, Pol, White;///这些块总数

void InIt()
{
    cnt = Row = Pol = White = 0;
    memset(Head, -1, sizeof(Head));
    memset(G, 0, sizeof(G));
}
void Trun(char s[], Graph &p)
{
    if(strcmp(s, "XXXXXXX") == 0)
        return ;
    if(strcmp(s, ".......") == 0)
    {
        p.white = true;
        p.wIndex = ++White;
        return ;
    }

    s[3] = 0;

    if(s[0] >= ‘0‘ && s[0] <= ‘9‘)
    {///前面的是列值
        sscanf(s, "%d", &p.polSum);
        p.pIndex = ++Pol;
    }
    if(s[4] >= ‘0‘ && s[4] <= ‘9‘)
    {///后面是行
        sscanf(s+4, "%d", &p.rowSum);
        p.rIndex = ++Row;
    }
}
void AddEdge(int u, int v, int flow)
{
    edge[cnt].v = v;
    edge[cnt].flow = flow;
    edge[cnt].next = Head[u];
    Head[u] = cnt++;

    swap(u, v);

    edge[cnt].v = v;
    edge[cnt].flow = 0;
    edge[cnt].next = Head[u];
    Head[u] = cnt++;
}
bool BFS(int start, int End)
{
    memset(Layer, 0, sizeof(Layer));
    queue<int>Q;
    Q.push(start);
    Layer[start] = 1;

    while(Q.size())
    {
        int u = Q.front();Q.pop();

        if(u == End)return true;

        for(int j=Head[u]; j!=-1; j=edge[j].next)
        {
            int v = edge[j].v;

            if(Layer[v] == false && edge[j].flow)
            {
                Layer[v] = Layer[u] + 1;
                Q.push(v);
            }
        }
    }

    return false;
}
int DFS(int u, int MaxFlow, int End)
{
    if(u == End)return MaxFlow;

    int uflow = 0;

    for(int j=Head[u]; j!=-1; j=edge[j].next)
    {
        int v = edge[j].v;

        if(Layer[v]-1==Layer[u] && edge[j].flow)
        {
            int flow = min(MaxFlow-uflow, edge[j].flow);
            flow = DFS(v, flow, End);

            edge[j].flow -= flow;
            edge[j^1].flow += flow;
            uflow += flow;

            if(uflow == MaxFlow)
                break;
        }
    }

    if(uflow == 0)
        Layer[u] = 0;

    return uflow;
}
int Dinic(int start, int End)
{
    int MaxFlow = 0;

    while(BFS(start, End) == true)
        MaxFlow += DFS(start, oo, End);

    return MaxFlow;
}

int main()
{
    int M, N;

    while(scanf("%d%d", &M, &N) != EOF)
    {
        int i, j, k, q;
        char s[107];

        InIt();

        for(i=1; i<=M; i++)
        for(j=1; j<=N; j++)
        {
            scanf("%s", s);
            Trun(s, G[i][j]);
        }

        int start = Row+Pol+White*2+1, End = start+1;
        int Ri = White*2, Pi = Ri+Row;;

        for(i=1; i<=M; i++)
        for(j=1; j<=N; j++)
        {
            if(G[i][j].rowSum > 0)
            {///把源点与行连接,流量就是行的和
                k = G[i][j].rIndex;
                AddEdge(start, Ri+k, G[i][j].rowSum);
                q = cnt - 2;///记录下这条边的下标
            }
            if(G[i][j].white == true)
            {///如果是白色的块,与所连的行的流量减1

                int t = G[i][j].wIndex;

                edge[q].flow -= 1;
                AddEdge(Ri+k, t, 8);///点与前面所在的行相连
                AddEdge(t, t+White, 8);///把白色拆点
                G[i][j].pIndex = cnt - 1;///记录拆的那条边
            }
        }

        for(j=1; j<=N; j++)
        for(i=1; i<=M; i++)
        {
            if(G[i][j].polSum > 0)
            {///把汇点与列相连
                k = G[i][j].pIndex;
                AddEdge(Pi+k, End, G[i][j].polSum);
                q = cnt - 2;
            }
            if(G[i][j].white == true)
            {///如果是白色块，与之相连的列的流量减1
                int t = G[i][j].wIndex;

                edge[q].flow -= 1;
                AddEdge(White+t, Pi+k, 8);///拆点与前面所在的列相连
            }
        }
        Dinic(start, End);
        ///printf("%d\n",Dinic(start, End));

        for(i=1; i<=M; i++)
        for(j=1; j<=N; j++)
        {
            if(G[i][j].white == true)
            {
                int t = G[i][j].pIndex;
                printf("%d", edge[t].flow+1);
            }
            else
                printf("_");

            printf("%c", j==N ? ‘\n‘ : ‘ ‘);
        }
    }

    return 0;