UVA 1660 Cable TV Network 电视网络(无向图，点连通度，最大流)

题意：给一个无向图，求其点连通度？（注意输入问题）

思路：

　　如果只有1个点，那么输出“1”；

　　如果有0条边，那么输出“0”；

　　其他情况：用最大流解决。下面讲如何建图：

　　图的连通度问题是指：在图中删去部分元素（点或边），使得图中指定的两个点s和t不连通（即不存在从s到t的路径），求至少要删去几个元素。

　　图的连通度分为点连通度和边连通度：
　　　　（1）点连通度：只许删点，求至少要删掉几个点（当然，s和t不能删去，这里保证原图中至少有三个点）；
　　　　（2）边连通度：只许删边，求至少要删掉几条边。

　　并且，有向图和无向图的点连通度求法不同，因此还要分开考虑。说明：最大流对应的是最小割。

　　【有向图】：这个其实就是最小割问题。以s为源点，t为汇点建立网络，原图中的每条边在网络中仍存在，容量为1。

　　【无向图】：需要拆点，每个点都拆成两个点v和v'，并连1条有向边v->v'，容量为1。点v承接原图中所有入边，点v'承接原图中所有出边。那么对于原图每条有向边就得建两条边了，容量无穷，且涉4个新顶点。

　　【混合图】无向边按无向图处理，有向边按有向图处理。

　　最后，源点S到汇点，跑一次最大流，就得到了答案。如果无指定ST，那么应该顶下1个S，再穷举其他点作为T。这个S应该如何定就不知道了，时间充裕就穷举S和T，不充裕就找个度最少的为S。

　　针对此题，随意定个0号点为源点也能过，当然穷举两点也能过。

　　

 #include <bits/stdc++.h>
 #define LL long long
 #define pii pair<int,int>
 #define INF 0x7f7f7f7f
 using namespace std;
 const int N=;
 int n, m, edge_cnt;
 vector<int> vect[N*];
 int path[N], flow[N];

 struct node
 {
     int from, to, cap, flow;
     node(){};
     node(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){};
 }edge[], cpy[];

 void add_node(int from, int to, int cap, int flow)
 {
     edge[edge_cnt]=node(from,to,cap,flow);
     vect[from].push_back(edge_cnt++);
 }

 int BFS(int s,int e)
 {
     deque<int> que(,s);
     flow[s]=INF;

     while(!que.empty())
     {
         int x=que.front();
         que.pop_front();
         for(int i=; i<vect[x].size(); i++)
         {
             node e=cpy[vect[x][i]];
             if(!flow[e.to] && e.cap>e.flow )
             {
                 flow[e.to]=min(flow[e.from],e.cap-e.flow);
                 path[e.to]=vect[x][i];
                 que.push_back(e.to);
             }
         }
         if(flow[e]) break;
     }
     return flow[e];
 }

 int max_flow(int s,int e)
 {
     int ans_flow=;
     while(true)
     {
         memset(path,,sizeof(path));
         memset(flow,,sizeof(flow));

         int tmp=BFS(s,e);
         if(!tmp)    return ans_flow;
         ans_flow+=tmp;

         int ed=e;
         while(ed!=s)
         {
             int t=path[ed];
             cpy[t].flow+=tmp;
             cpy[t^].flow-=tmp;
             ed=cpy[t].from;
         }
     }
 }

 int cal()
 {
     int ans=INF;

     for(int i=; i<edge_cnt; i++)
     {
         if( edge[i].from== && edge[i].to== && edge[i].cap> )
         {
             edge[i].cap=INF;
             break;
         }
     }
     for(int k=; k<n; k++)  //枚举汇点
     {
         memcpy(cpy, edge, sizeof(edge));
         for(int i=; i<edge_cnt; i++)   //所有边
         {
             if( cpy[i].from==k* && cpy[i].to==k*+ &&cpy[i].cap> )
             {
                 cpy[i].cap=INF;
                 break;
             }
         }
         ans=min(ans, max_flow(,k*+));
     }
     return ans==INF?n:ans;
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int a, b;
     char c;
     while(cin>>n>>m)
     {
         edge_cnt=;
         memset(edge,,sizeof(edge));
         for(int i=n*; i>=; i--) vect[i].clear();

         for(int i=; i<n; i++)  //拆点
         {
             add_node(i*, i*+, , );
             add_node(i*+, i*, , );
         }

         for(int i=; i<m; i++)
         {
             while(c=getchar(), c!='(' );
             scanf("%d%c%d%c",&a,&c,&b,&c);

             add_node(a*+, b*, INF,  );  //每条无向边拆2条有向
             add_node(b*, a*+, ,  );

             add_node(b*+, a*, INF, );
             add_node(a*, b*+, , );
         }
         printf("%d\n",cal());
     }
     return ;
 }

AC代码(任意源)

#include <bits/stdc++.h>
#define LL long long
#define pii pair<int,int>
#define INF 0x7f7f7f7f
using namespace std;
const int N=;
int n, m, edge_cnt;
vector<int> vect[N*];
int path[N], flow[N];

struct node
{
    int from, to, cap, flow;
    node(){};
    node(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){};
}edge[], cpy[], old[];

void add_node(int from, int to, int cap, int flow)
{
    edge[edge_cnt]=node(from,to,cap,flow);
    vect[from].push_back(edge_cnt++);
}

int BFS(int s,int e)
{
    deque<int> que(,s);
    flow[s]=INF;

    while(!que.empty())
    {
        int x=que.front();
        que.pop_front();
        for(int i=; i<vect[x].size(); i++)
        {
            node e=cpy[vect[x][i]];
            if(!flow[e.to] && e.cap>e.flow )
            {
                flow[e.to]=min(flow[e.from],e.cap-e.flow);
                path[e.to]=vect[x][i];
                que.push_back(e.to);
            }
        }
        if(flow[e]) break;
    }
    return flow[e];
}

int max_flow(int s,int e)
{
    int ans_flow=;
    while(true)
    {
        memset(path,,sizeof(path));
        memset(flow,,sizeof(flow));

        int tmp=BFS(s,e);
        if(!tmp)    return ans_flow;
        ans_flow+=tmp;

        int ed=e;
        while(ed!=s)
        {
            int t=path[ed];
            cpy[t].flow+=tmp;
            cpy[t^].flow-=tmp;
            ed=cpy[t].from;
        }
    }
}

int cal()
{
    int ans=INF;
    for(int s=; s<n; s++)  //枚举源点
    {
        memcpy(old, edge, sizeof(edge));
        for(int i=; i<edge_cnt; i++)
        {
            if( old[i].from==s* && old[i].to==s*+ && old[i].cap> )
            {
                old[i].cap=INF;
                break;
            }
        }

        for(int k=s+; k<n; k++)  //枚举汇点
        {
            memcpy(cpy, old, sizeof(old));
            for(int i=; i<edge_cnt; i++)   //所有边
            {
                if( cpy[i].from==k* && cpy[i].to==k*+ &&cpy[i].cap> )
                {
                    cpy[i].cap=INF;
                    break;
                }
            }
            ans=min(ans, max_flow(s*,k*+));
        }
    }

    return ans==INF?n:ans;
}

int main()
{
    //freopen("input.txt", "r", stdin);
    int a, b;
    char c;
    while(cin>>n>>m)
    {
        edge_cnt=;
        memset(edge,,sizeof(edge));
        for(int i=n*; i>=; i--) vect[i].clear();

        for(int i=; i<n; i++)  //拆点
        {
            add_node(i*, i*+, , );
            add_node(i*+, i*, , );
        }

        for(int i=; i<m; i++)
        {
            while(c=getchar(), c!='(' );
            scanf("%d%c%d%c",&a,&c,&b,&c);

            add_node(a*+, b*, INF,  );  //每条无向边拆2条有向
            add_node(b*, a*+, ,  );

            add_node(b*+, a*, INF, );
            add_node(a*, b*+, , );
        }
        printf("%d\n",cal());
    }
    return ;
}

AC代码（穷举S和T）