SPOJ 287 Smart Network Administrator(最大流+二分答案)

题意：有N户人，m条街道（边），k户人家需要向1联网（1号有网），通过各个街道连电缆到1。要求这些电缆在同一条街道颜色不同，要求在k户人家连接到的情况下使用最少的颜色，输出最少颜色的种数，题目保证k户人家一定能连上网，边是双向边。

分析：很容易想到将1点作为源点，k户人家连到汇点，并且k户人家到汇点的容量都为1。问题在于，与源点相连的点流量为多少，1？INF？思来想去都不对，而且要保证用的颜色最少。可以想到二份答案，那么所有的容量都为此答案当然是可以的咯。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 505
#define MAXM 505*500
#define LL long long
#define INF 0x3f7f7f7f
const double eps = 1e-10;
struct Edge
{
    int from,to,cap,flow;
    Edge(int from=0,int to=0,int cap=0,int flow=0):from(from),to(to),cap(cap),flow(flow){}
};
struct node
{
    int u,v;
    node(int u=0,int v=0):u(u),v(v){}
};
vector<node>E;
vector<Edge>edges;
vector<int>g[MAXN];
vector<int>point;
bool vis[MAXN];
int d[MAXN];
int cur[MAXN];
int s,t,n,m,k;
void init()
{
    for(int i=0;i<MAXN;i++)
    {
        g[i].clear();
    }
    edges.clear();
}
void add(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int m=edges.size();
    g[from].push_back(m-2);
    g[to].push_back(m-1);
}
bool bfs()
{
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!q.empty())
    {
        int tx=q.front();
        q.pop();
        int sz=g[tx].size();
        for(int i=0;i<sz;i++)
        {
            Edge e=edges[g[tx][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                vis[e.to]=1;
                d[e.to]=d[tx]+1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}
int dfs(int x,int a)
{
    if(x==t||a==0)
        return a;
    int flow=0,f;
    int sz=g[x].size();
    for(int &i=cur[x];i<sz;i++)
    {
        Edge &e=edges[g[x][i]];
        if(d[x]+1==d[e.to])
        {
            f=dfs(e.to,min(a,e.cap-e.flow));
            if(f>0)
            {
                e.flow+=f;
                edges[g[x][i]^1].flow-=f;
              	// Edge E=edges[g[x][i]^1];
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
    }
    return flow;
}
int maxFlow()
{
    int flow=0;
    while(bfs())
    {
        memset(cur,0,sizeof(cur));
        flow+=dfs(s,INF);
    }
    return flow;
}
void solve()
{
    int l=0,r=k,i;
    s=1;t=n+1;

    while(l<r)
    {
        int mid=(l+r)>>1;
        int sz;
        init();
         for(i=0;i<point.size();i++)
        {
            add(point[i],t,1);
        }
        sz=E.size();
        for(i=0;i<sz;i++)
        {
            add(E[i].u,E[i].v,mid);
            add(E[i].v,E[i].u,mid);
        }
        int temp=maxFlow();
        if(temp==k)
            r=mid;
        else l=mid+1;
    }
    cout<<l<<endl;
}
int main()
{
    int cas,i;
    scanf("%d",&cas);
    while(cas--)
    {
         E.clear();
         point.clear();
        s=0;
        scanf("%d%d%d",&n,&m,&k);
        for(i=1;i<=k;i++)
        {
            int id;
            cin>>id;
            point.push_back(id);
        }
        for(i=1;i<=m;i++)
        {
            int u,v;
            cin>>u>>v;
            E.push_back(node(u,v));
        }
        solve();
    }
}