hdu 2242 考研路茫茫——空调教室

双连通分量

边双连通分量+DP  （其实不用DP，直接建树+遍历一次就能计算出全部的DP值）

题意无向图连通，所以只要从一个点运行一次dfs即可，在运行dfs过程中保存下所有的桥并且计算出所有的边双连通分量。在tarjan之后对原图进行缩点，缩点后就能得到一棵，树边刚好就是全部的桥。缩点后每个大点都有一个权值，权值等于 = 属于该连通分量的每个小点的权值和。

因此保存下全部桥是为了方便建树。建树之后对树进行一次遍历（很多人说是DP，其实不算是DP，只是简单的遍历而已）。遍历过程要计算每个节点的dp值，dp[i] = 以点i为节点的子树的所有节点的权值和 

因此每计算完一个节点的dp值后，就可以看看切断这条树边，能不能更新最大的答案， 切断该边的结果为   (SUM - dp[i]) - dp[i]

#include <iostream>

#include <cstdio>

#include <cstring>

#include <utility>

#include <vector>

#include <stack>

using namespace std;

#define N 10010

#define M 20010

#define INF 0x3f3f3f3f



int n,tot,val[N];

int head[N],dfn[N],low[N],belong[N],ins[N],dcnt,bcnt;

int weight[N],dp[N],vis[N],SUM,res;

typedef pair<int ,int> pii;

struct edge

{

    int u,v,used,next;

}e[2*M];

vector<pii>bridge;

stack<int>sta;

vector<int>ver[N];



void add(int u, int v, int k)

{

    e[k].u = u; e[k].v = v; e[k].used = 0;

    e[k].next = head[u]; head[u] = k++;

    u = u^v; v = u^v; u = u^v;

    e[k].u = u; e[k].v = v; e[k].used = 0;

    e[k].next = head[u]; head[u] = k++;

}



void dfs(int u , int fa)

{

    dfn[u] = low[u] = ++dcnt;

    sta.push(u); ins[u] = 1;

    for(int k=head[u]; k!=-1; k=e[k].next)

        if(!e[k].used)

        {

            e[k].used = e[k^1].used = 1;

            int v = e[k].v;

            if(!dfn[v]) //树边

            {

                dfs(v,u);

                low[u] = min(low[u] , low[v]);

                if(low[v] > dfn[u]) //桥

                {

                    bridge.push_back(make_pair(u,v));

                    while(true)

                    {

                        int x = sta.top();

                        sta.pop(); ins[x] = 0;

                        belong[x] = bcnt;

                        if(x == v) break;

                    }

                    bcnt++; //统计连通分支数

                }

            }

            else if(ins[v]) //后向边

                low[u] = min(low[u] , dfn[v]);

        }

}



inline int abs(int x ,int y)

{

    return x>y? x-y : y-x ;

}



void travel(int u) //遍历整个树，顺便计算出dp值，并且顺便计算出答案

{

    vis[u] = 1;

    dp[u] = weight[u];

    for(int i=0; i<ver[u].size(); i++)

    {

        int v = ver[u][i];

        if(vis[v]) continue;

        travel(v);

        dp[u] += dp[v]; //加上子树的dp值

    }

    res = min(res , abs(SUM-2*dp[u]));

}



void build() //缩点后建树，树边就是桥

{

    SUM = 0;

    res = INF;

    for(int i=0; i<bcnt; i++)

    {

        weight[i] = vis[i] = dp[i] = 0;

        ver[i].clear();

    }

    //计算缩点后每个点的权值

    for(int i=0; i<n; i++)

        weight[belong[i]] += val[i];

    for(int i=0; i<bcnt; i++)

        SUM += weight[i];



    for(int i=0; i<bridge.size(); i++)

    {

        int u = belong[ bridge[i].first ];

        int v = belong[ bridge[i].second ];

        ver[u].push_back(v);

        ver[v].push_back(u);

    }

    travel(0);

//    for(int i=0; i<n; i++) printf("%d[%d]\n",i,belong[i]);

//    for(int i=0; i<bcnt; i++) printf("w=%d\n",weight[i]);

//    for(int i=0; i<bcnt; i++) printf("dp=%d\n",dp[i]);

}



void solve()

{

    dcnt = bcnt = 0;

    bridge.clear();

    while(!sta.empty()) sta.pop();

    memset(ins,0,sizeof(ins));

    memset(dfn,0,sizeof(dfn));

    dfs(0,-1);

    while(!sta.empty())

    {

        int x = sta.top();

        sta.pop(); ins[x] = 0;

        belong[x] = bcnt;

    }

    bcnt++;



    if(bcnt == 1) //整个图就是个边双连通分支，不存在桥

    {

        cout << "impossible" << endl;

        return ;

    }

    

    build(); //建树，并且遍历，遍历过程中就能计算出答案

    cout << res << endl;

}



int main()

{

    while(cin >> n >> tot)

    {

        tot *= 2;

        memset(head,-1,sizeof(head));

        for(int i=0; i<n; i++) cin >> val[i];

        for(int i=0; i<tot; i+=2)

        {

            int u,v;

            cin >> u >> v;

            add(u,v,i);

        }

        solve();

    }

    return 0;

}