POJ 1966

求的是无向图的点连通度。开始便想到网络流，既然选的是点，当然就要拆点加边了。但无论如何也不敢往枚举源汇点的方向想，因为网络流复习度很高。看看网上大牛的，都是枚举，再看数据，原来N才50个点，枚举无压力啊。看来自己以后要注意分析一下复杂度了。

总结：

1）无向图点连通度

看来没有什么好的算法。网络流。把点i拆成i->i‘容量自然是1，把无向图的边也拆成两条有向边i'->j,j'->i，容量为无穷。然后，枚举求s'->t的最小割就可了。

2）有向图点连通度

这个更简单了，单纯拆点建图就可以了。

3）无向图边连通度。

可以用store-wanger求最小割。边权为1

4）有向图边连通度

就是网络流求最小割

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

const int INF=0x3f3f3f3;
const int MAXN=120    ;
const int MAXM=15000;

struct Node{
    int from,to,next;
    int cap;
}edge[MAXM];
int tol;

int dep[MAXN];
int head[MAXN];
bool maze[MAXN][MAXN];
int n,m;
void init(){
    tol=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int w){
    edge[tol].from=u;
    edge[tol].to=v; edge[tol].cap=w;  edge[tol].next=head[u];
    head[u]=tol++;
    edge[tol].from=v;
    edge[tol].to=u;
    edge[tol].cap=0;
    edge[tol].next=head[v];
    head[v]=tol++;
}

int BFS(int start,int end){
    int que[MAXN];
    int front,rear; front=rear=0;
    memset(dep,-1,sizeof(dep));
    que[rear++]=start;
    dep[start]=0;
    while(front!=rear){
        int u=que[front++];
        if(front==MAXN)front=0;
        for(int i= head[u];i!=-1; i=edge[i].next){
            int v=edge[i].to;
            if(edge[i].cap>0&& dep[v]==-1){
                dep[v]=dep[u]+1;
                que[rear++]=v;
                if(rear>=MAXN) rear=0;
                if(v==end)return 1;
            }
        }
    }
    return 0;
}
int dinic(int start,int end){
    int res=0;
    int top;
    int stack[MAXN];
    int cur[MAXN];
    while(BFS(start,end)){
        memcpy(cur,head, sizeof(head));
        int u=start;
        top=0;
        while(1){
            if(u==end){
                int min=INF;
                int loc;
               for(int i=0;i<top;i++)
                  if(min>edge [stack[i]].cap) {
                      min=edge [stack[i]].cap;
                      loc=i;
                  }
                for(int i=0;i<top;i++){
                    edge[stack[i]].cap-=min;
                    edge[stack[i]^1].cap+=min;
                }
                res+=min;         
                top=loc;               
                u=edge[stack[top]].from;
            }
            for(int i=cur[u]; i!=-1; cur[u]=i=edge[i].next)
              if(edge[i].cap!=0 && dep[u]+1==dep[edge[i].to])
                 break;
            if(cur[u] !=-1){
                stack [top++]= cur[u];
                u=edge[cur[u]].to;
            }
            else{
                if(top==0) break;
                dep[u]=-1;
                u= edge[stack [--top] ].from;
            }
        }
    }
    return res;
}

void build(){
        init();
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==j)
                addedge(i*2,i*2+1,1);
                else if(maze[i][j]){
                    addedge(i*2+1,j*2,INF);
                }
            }
        }

}

int main(){
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF){
          memset(maze,false,sizeof(maze));
        for(int i=0;i<m;i++){
            scanf(" (%d,%d)",&u,&v);
            maze[u][v]=maze[v][u]=true;
        }
        int ans=INF;
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                build();
                if(!maze[i][j]){
                int res=dinic(i*2+1,j*2);
                if(res<ans) ans=res;
                if(ans==0) break;
                }
            }
            if(ans==0) break;
        }
        if(ans>=n){ printf("%d
",n); continue; }
        printf("%d
",ans);
    }
    return 0;
}