hdu 2242（图的双联通&树形dp）

对于一个连通图，如果任意两点至少存在两条点不重复路径，则称这个图为点双连通的（简称双连通）；如果任意两点至少存在两条边不重复路径，则称该图为边双连通的。点双连通图的定义等价于任意两条边都同在一个简单环中，而边双连通图的定义等价于任意一条边至少在一个简单环中。对一个无向图，点双连通的极大子图称为点双连通分量（简称双连通分量），边双连通的极大子图称为边双连通分量。

删除一条边以后还互相连通的教室就是一个双联通分量里面的，这题要求的就是 删除哪一个桥之后，分开的两个双联通分量的权值（人数） 相差最小。

先跑一边tarjan进行双联通缩点，然后用缩的点建图，便是一棵树，树的每条边就是原图中的桥，剩下的就是简单dp更新最小答案。如果原图中的双联通分量只有一个，那就是“impossable”。

INF的值一定要开大！！！！！！！！

我踏马因为这wa了N发！！！！

#include<cstdio>
#include<stack>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 10005;
const int maxm = 20005;
int n,m;
int va[maxn];
struct node
{
    int to;
    int next;
    node(){}
    node(int a,int b):to(a),next(b){}
}edge[maxm<<1],tree[maxm<<1];
int head[maxn],dfn[maxn],low[maxn],belong[maxn],thead[maxn],ans[maxn];
int tot,ti,coun,ttot,res,people;
stack<int>s;
void add_edge(int u,int v)
{
    edge[tot] = node(v,head[u]);
    head[u] = tot++;
    edge[tot] = node(u,head[v]);
    head[v] = tot++;
}
void tarjan(int u,int fa)
{
    dfn[u] = ++ti; low[u] = ti; s.push(u);
    int flag = 0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v==fa&&flag==0){flag = 1;continue;}
        if(!dfn[v]){
            tarjan(v,u);
            low[u] = min(low[u],low[v]);
        }else if(belong[v]==-1) low[u] = min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        int y;
        coun++;
        do{
            y = s.top(); s.pop();
            ans[coun] += va[y];
            belong[y] = coun;
        }while(y!=u);
    }
}
int cbh(int u,int fa)
{
    int sum = ans[u];
    dfn[u] = 1;
    for(int i=thead[u];i!=-1;i=tree[i].next)
    {
        int v = tree[i].to;
        if(v==fa||dfn[v]) continue;
        sum+=cbh(v,u);
    }
    res = min(res,abs(2*sum-people));
    return sum;
}
int main()
{
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        people = 0;
        for(int i=0;i<n;i++) scanf("%d",&va[i]),people+=va[i];
        tot = 0;
        memset(head,-1,sizeof(head));
        for(int i=0;i<m;i++)
        {
           scanf("%d%d",&u,&v);
           add_edge(u,v);
        }
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        memset(ans,0,sizeof(ans));
        memset(belong,-1,sizeof(belong));
        coun = 0;ti = 0;
        tarjan(0,0);
        if(coun==1){printf("impossible\n");continue;}
      //  printf("%d\n",coun);
        ttot = 0;
        memset(thead,-1,sizeof(thead));
        memset(dfn,0,sizeof(dfn));
        for(int i=0;i<n;i++)
        {
            for(int j=head[i];j!=-1;j=edge[j].next)
            {
                v = edge[j].to;
                if(belong[i]!=belong[v])
                {
                    tree[ttot] = node(belong[v],thead[belong[i]]);
                    thead[belong[i]] = ttot++;
                }
            }
        }
        res = 0xfffffff;
        cbh(1,0);
        printf("%d\n",res);
    }
    return 0;
}