POJ 2455 Secret Milking Machine 最大流建模

题目链接

http://poj.org/problem?id=2455

题意

某人为了隐藏他的挤奶机，可能是为了不让别人跟踪，他决定从1~n，然后走密道回到1，再从1到n，走t次，且每条路径不同，每次尽量走路径最短的路，问他在t次走的过程中，两个路标之间的最大距离。

思路

二分枚举最大边权。如果两点的边权小于等于枚举的量，之间建立一条容量为1的边，若有重边满足条件，容量加1，最后从1点跑最大流，判断最大流是否大于等于t。边是双向的，所以反向边的残量不为0

#include<cstdio>
#include<queue>
#include<iostream>
#include<vector>
#include<map>
#include<cstring>
#include<string>
#include<set>
#include<stack>
#include<algorithm>
#define cle(a) memset(a,0,sizeof(a))
#define inf(a) memset(a,0x3f,sizeof(a))
#define ll long long
#define Rep(i,a,n) for(int i=a;i<=n;i++)
using namespace std;
#define INF2 9223372036854775807ll
const int INF = ( 2e9 ) + 2;
const ll maxn =  410;
const int maxm = 210;
ll maxx;
int n,m,t;
int mp2[maxn][maxn];
ll mp[maxn][maxn];
struct edge
{
    int from,to,c;
    edge(int getu,int getv,int getc)
    {
        from=getu;
        to=getv;
        c=getc;
    }
};
vector<edge> e;
struct Dinic
{

    int s,t,n;
    int d[maxn];
    int cur[maxn];
    vector<edge> e;
    vector<int> g[maxn];
    void addedge(int u,int v,int c)
    {
        e.push_back(edge(u,v,c));
        e.push_back(edge(v,u,c));
        int m=e.size();
        g[u].push_back(m-2);
        g[v].push_back(m-1);
    }
    void init()
    {
        e.clear();
        for(int i=0; i<=maxn; i++)
            g[i].clear();
    }
    bool bfs()
    {
        queue<int> q;
        q.push(s);
        memset(d,0,sizeof(d));
        d[s]=1;
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            for(int i=0; i<g[u].size(); i++)
            {
                int v=e[g[u][i]].to;
                int c=e[g[u][i]].c;
                if(!d[v]&&c)
                {
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        return d[t];
    }
    int dfs(int u,int maxf,int t)
    {
        if(u==t)return maxf;
        int ret=0;
        for(int &i=cur[u]; i<g[u].size(); i++)
        {
            int c=e[g[u][i]].c;
            int v=e[g[u][i]].to;
            int f;
            if(d[u]+1==d[v]&&c)
            {
                f=dfs(v,min(maxf-ret,c),t);
                e[g[u][i]].c-=f;
                e[g[u][i]^1].c+=f;
                ret+=f;
                if(ret==maxf)return ret;
            }
        }
        return ret;
    }
    int maxflow(int s,int t)
    {
        this->s=s;
        this->t=t;
        int flow=0;
        while(bfs())
        {
            memset(cur,0,sizeof(cur));
            int temp=dfs(s,INF,t);
            flow+=temp;
        }
        return flow;
    }
} dinic;
bool check(int t,int n,int T)
{

    for(int i=0; i<e.size(); i++)
    {
        if(e[i].c<=t)
            dinic.addedge(e[i].from,e[i].to,1);
    }
    int temp=dinic.maxflow(1,n);
    dinic.init();
    return temp>=T;
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&t))
    {
        memset(mp,0,sizeof(mp));
        e.clear();
        for(int i=0; i<m; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            e.push_back(edge(u,v,w));
            mp[u][v]=1;
            mp[v][u]=1;
        }
        int l=0,r=1000010;
        while(l<r)
        {
            int mid=(l+r)>>1;
            if(check(mid,n,t))
                r=mid;
            else
                l=mid+1;
        }
        cout<<l<<endl;
    }
}