hdu4292 Food 最大流模板题

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4292

题意：水和饮料，建图跑最大流模板。

我用的是学长的模板，最然我还没有仔细理解，不过这都不重要直接贴就行了。

下面是AC代码，以后就当做最大流的模板来用了。

代码：

#include<cstdio>
#include<iostream>
using namespace std;

const int oo=1e9;
const int mm=2e5+;
const int mn=1e5+;

int node,src,dest,edge;
int ver[mm],flow[mm],Next[mm];
int head[mn],work[mn],dis[mn],q[mn];

int Min(int a,int b)
{
    return a<b?a:b;
}

void prepare(int _node,int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=; i<node; ++i)head[i]=-;
    edge=;
}

void Addedge(int u,int v,int c)
{
    ver[edge]=v,flow[edge]=c,Next[edge]=head[u],head[u]=edge++;
    ver[edge]=u,flow[edge]=,Next[edge]=head[v],head[v]=edge++;
}

bool Dinic_bfs()
{
    int i,u,v,l,r=;
    for(i=; i<node; ++i)dis[i]=-;
    dis[q[r++]=src]=;
    for(l=; l<r; ++l)
        for(i=head[u=q[l]]; i>=; i=Next[i])
            if(flow[i]&&dis[v=ver[i]]<)
            {
                dis[q[r++]=v]=dis[u]+;
                if(v==dest)return ;
            }
    return ;
}

int Dinic_dfs(int u,int exp)
{
    if(u==dest)return exp;
    for(int &i=work[u],v,tmp; i>=; i=Next[i])
        if(flow[i]&&dis[v=ver[i]]==dis[u]+&&(tmp=Dinic_dfs(v,Min(exp,flow[i])))>)
        {
            flow[i]-=tmp;
            flow[i^]+=tmp;
            return tmp;
        }
    return ;
}

int Dinic_flow()
{
    int i,ret=,delta;
    while(Dinic_bfs())
    {
        for(i=; i<node; ++i) work[i]=head[i];
        while(delta=Dinic_dfs(src,oo)) ret+=delta;

    }
    return ret;
}

int main()
{
    char s[];
    int n,f,d,t;
    while(scanf("%d%d%d",&n,&f,&d)==)
    {
        prepare(n*+f+d+,,n*+f+d+);
        for(int i=; i<=f; i++)
        {
            scanf("%d",&t);
            Addedge(,i,t);///源点加边
        }
        for(int i=; i<=d; i++)
        {
            scanf("%d",&t);
            Addedge(f+*n+i,f+*n+d+,t);///汇点加边
        }
        for(int i=; i<=n; i++)
            Addedge(f+i,f+n+i,);///拆点
        for(int i=; i<=n; i++)
        {
            scanf("%s",s+);
            for(int j=; j<=f; j++)
                if(s[j]=='Y')
                    Addedge(j,f+i,);///顾客与食物加边
        }
        for(int i=; i<=n; i++)
        {
            scanf("%s",s+);
            for(int j=; j<=d; j++)
                if(s[j]=='Y')
                    Addedge(f+n+i,f+*n+j,);///顾客与饮料加边
        }
        printf("%d\n",Dinic_flow());
    }
    return ;
}

学长模板的链接：http://m.blog.csdn.net/article/details?id=30030439

模板：

#include<cstdio>
#include<iostream>
using namespace std;
const int oo=1e9;

const int mm=;
const int mn=;
int node,src,dest,edge;
int ver[mm],flow[mm],next[mm];
int head[mn],work[mn],dis[mn],q[mn];

void prepare(int _node,int _src,int _dest) ///node是结点总数
{
    node=_node,src=_src,dest=_dest;
    for(int i=; i<node; ++i)head[i]=-;
    edge=;
}

void addedge(int u,int v,int c)
{
    ver[edge]=v,flow[edge]=c,next[edge]=head[u],head[u]=edge++;
    ver[edge]=u,flow[edge]=,next[edge]=head[v],head[v]=edge++;
}

bool Dinic_bfs()
{
    int i,u,v,l,r=;
    for(i=; i<node; ++i)dis[i]=-;
    dis[q[r++]=src]=;
    for(l=; l<r; ++l)
        for(i=head[u=q[l]]; i>=; i=next[i])
            if(flow[i]&&dis[v=ver[i]]<)
            {
                dis[q[r++]=v]=dis[u]+;
                if(v==dest)return ;
            }
    return ;
}

int Dinic_dfs(int u,int exp)
{
    if(u==dest)return exp;
    for(int &i=work[u],v,tmp; i>=; i=next[i])
        if(flow[i]&&dis[v=ver[i]]==dis[u]+&&(tmp=Dinic_dfs(v,min(exp,flow[i])))>)
        {
            flow[i]-=tmp;
            flow[i^]+=tmp;
            return tmp;
        }
    return ;
}
int Dinic_flow()
{
    int i,ret=,delta;
    while(Dinic_bfs())
    {
        for(i=; i<node; ++i)work[i]=head[i];
        while(delta=Dinic_dfs(src,oo))ret+=delta;
    }
    return ret;
}

SAP模板：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;

const int MAXN=;//点数的最大值
const int MAXM=**;//边数的最大值
const int INF=0x3f3f3f3f;

struct Edge
{
    int to,next,cap,flow;
} edge[MAXM]; //注意是MAXM

int tol;
int head[MAXN];
int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN];

void init()
{
    tol=;
    memset(head,-,sizeof(head));
}
//加边，单向图三个参数，双向图四个参数
void addedge(int u,int v,int w,int rw=)
{
    edge[tol].to = v;
    edge[tol].cap = w;
    edge[tol].next = head[u];
    edge[tol].flow = ;
    head[u] = tol++;

    edge[tol].to = u;
    edge[tol].cap = rw;
    edge[tol].next = head[v];
    edge[tol].flow = ;
    head[v]=tol++;
}
//输入参数：起点、终点、点的总数
//点的编号没有影响，只要输入点的总数
int sap(int start,int end,int N)
{
    memset(gap,,sizeof(gap));
    memset(dep,,sizeof(dep));
    memcpy(cur,head,sizeof(head));
    int u=start;
    pre[u]=-;
    gap[]=N;
    int ans=;
    while(dep[start]<N)
    {
        if(u==end)
        {
            int Min=INF;
            for(int i=pre[u]; i!=-; i=pre[edge[i^].to])
                if(Min>edge[i].cap-edge[i].flow)
                    Min=edge[i].cap-edge[i].flow;
            for(int i=pre[u]; i!=-; i=pre[edge[i^].to])
            {
                edge[i].flow+=Min;
                edge[i^].flow-=Min;
            }
            u=start;
            ans+=Min;
            continue;
        }
        bool flag=false;
        int v;
        for(int i=cur[u]; i!=-; i=edge[i].next)
        {
            v=edge[i].to;
            if(edge[i].cap-edge[i].flow && dep[v]+==dep[u])
            {
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if(flag)
        {
            u=v;
            continue;
        }
        int Min=N;
        for(int i=head[u]; i!=-; i=edge[i].next)
            if(edge[i].cap-edge[i].flow && dep[edge[i].to]<Min)
            {
                Min=dep[edge[i].to];
                cur[u]=i;
            }
        gap[dep[u]]--;
        if(!gap[dep[u]])return ans;
        dep[u]=Min+;
        gap[dep[u]]++;
        if(u!=start) u=edge[pre[u]^].to;
    }
    return ans;
}

int main()
{
    init();
    addedge(u,v,value);
    maxf=sap(,n+m+,n+m+); ///源点，汇点，总点数的值。
}

ISAP模板：

#include <cstdio>
#include <cstring>

using namespace std;

const int MAXN = ;
const int MAXM = ;

// ISAP

struct edge
{
    int t, f;
    edge *p, *r;
} T[MAXM], *H[MAXN], *I[MAXN], *P[MAXN];

int C;
int G[MAXN], D[MAXN], L[MAXN];

inline void adde(const int a, const int b, const int c)
{
    edge *e1 = T + C++;
    edge *e2 = T + C++;
    e1->t = b;
    e1->f = c;
    e1->p = H[a];
    e1->r = e2;
    H[a] = e1;
    e2->t = a;
    e2->f = ;
    e2->p = H[b];
    e2->r = e1;
    H[b] = e2;
}

inline int isap(const int cnt, const int src, const int snk)
{
    int maxf = ;
    int curf = 0x3f3f3f3f;
    int u = src, v;
    edge *e;
    memcpy(I, H, sizeof(H));
    memset(G, , sizeof(G));
    memset(D, , sizeof(D));
    G[] = cnt;
    while (D[src] < cnt)
    {
        L[u] = curf;
        for (e = I[u]; e; e = e->p)
        {
            v = e->t;
            if (e->f >  && D[u] == D[v] + )
            {
                I[u] = P[v] = e;
                if (e->f < curf)
                    curf = e->f;
                u = v;
                if (u == snk)
                {
                    maxf += curf;
                    while (u != src)
                    {
                        P[u]->f -= curf;
                        P[u]->r->f += curf;
                        u = P[u]->r->t;
                    }
                    curf = 0x3f3f3f3f;
                }
                break;
            }
        }
        if (e)
            continue;
        if (!--G[D[u]])
            break;
        int mind = cnt - ;
        for (e = H[u]; e; e = e->p)
            if (e->f >  && D[e->t] < mind)
            {
                I[u] = e;
                mind = D[e->t];
            }
        ++G[D[u] = mind + ];
        if (u != src)
        {
            u = P[u]->r->t;
            curf = L[u];
        }
    }
    return maxf;
}

int N, M;
bool V[];

int main()
{
    int tt, a, b, c, ss, cnt;
    scanf("%d", &tt);
    for (int tc = ; tc <= tt; ++tc)
    {
        memset(V, false, sizeof(V));
        memset(H, , sizeof(H));
        ss = ;
        C = ;
        scanf("%d%d", &N, &M);
        cnt = N + ;
        for (int i = ; i < N; ++i)
        {
            scanf("%d%d%d", &a, &b, &c);
            adde(, i, a);
            for (int j = b - ; j < c; ++j)
            {
                adde(i, j + , );
                if (!V[j])
                {
                    adde(j + , , M);
                    V[j] = true;
                    ++cnt;
                }
            }
            ss += a;
        }
        if (isap(cnt, , ) == ss)
            printf("Case %d: Yes\n\n", tc);
        else
            printf("Case %d: No\n\n", tc);
    }
    return ;
}