HDU 2242 连通分量缩点+树形dp

题目大意是：

所有点在一个连通图上，希望去掉一条边得到两个连通图，且两个图上所有点的权值的差最小，如果没有割边，则输出impossible

这道题需要先利用tarjan算法将在同一连通分量中的点缩成一个点后，重新构建一幅图，然后利用新建的图进行树形dp解决问题

这道题目需要注意的是可能存在重边，那么子节点回到父节点有两条边及以上的话，就需要对子节点经过父节点的边进行low值更新

tarjan算法学习的网站个人感觉还不错https://www.byvoid.com/blog/scc-tarjan/

/*
找割边是否存在
*/
#include <cstdio>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;

typedef long long ll;
const int N = 10005;
const int INF = 200000000;

int first[N] , k , k_scc , val[N] , val_scc[N] , sum[N] , all ;
int scc[N] , num_of_scc , dfs_clock , dfn[N] , low[N];
stack<int> s;

struct Edge{
    int x , y , next ;
    bool flag;
}e[N<<2] , e_scc[N<<2];

int my_abs(int x)
{
    return x>=0?x:-x;
}

void add_edge(int x , int y)
{
    e[k].x = x , e[k].y = y , e[k].next = first[x];
    first[x] = k++;
}

void add_edge_scc(int x , int y)
{
    e_scc[k_scc].x = x , e_scc[k_scc].y = y , e_scc[k_scc].next = first[x] , e_scc[k_scc].flag = false;
    first[x] = k_scc++;
}

void tarjan(int u , int fa)
{
    dfn[u] = low[u] = ++dfs_clock;
    s.push(u);
    int flag = 1; //用来解决重边情况
    for(int i=first[u] ; i!=-1 ; i=e[i].next){
        int v = e[i].y;
        /*
        因为第一次遇到父节点的边，表示是一开始下来的边，这个是不允许访问的，
        但是如果遇到2次及以上，说明u v之间不止一条边，访问到第二次之后的边是允许
        low[u]通过这个重边得到dfn[v]比较下的较小值进行更新
        */
        if(v == fa && flag){
            flag = 0;
            continue;
        }
        if(!dfn[v]){
            tarjan(v,u);
            low[u] = min(low[u] , low[v]);
        }
        else if(!scc[v])
            low[u] = min(low[u] , dfn[v]);
    }
    if(low[u] == dfn[u]){
        num_of_scc++;
        while(true){
            int x = s.top();
            s.pop();
            scc[x] = num_of_scc;
            val_scc[num_of_scc] += val[x];//得到新构建图上的点的权值
            if(x == u) break;
        }
    }
}

void dfs(int u , int fa)
{
    sum[u] = val_scc[u];
    for(int i=first[u] ; i!=-1 ; i=e_scc[i].next){
        int v = e_scc[i].y;
        if(v == fa) continue;
        e_scc[i].flag = true;
        dfs(v , u);
        sum[u]+=sum[v];
    }
}

int main()
{
  //  freopen("a.in" , "r" , stdin);
    int n , m , x , y;
    while(scanf("%d%d" , &n , &m) == 2){
        memset(first , -1 , sizeof(first));
        k=0 , all = 0;
        for(int i=0 ; i<n ; i++)
        {
            scanf("%d" , val+i);
            all += val[i];
        }

        for(int i=0 ; i<m ; i++){
            scanf("%d%d" , &x , &y);
            add_edge(x , y);
            add_edge(y , x);
        }

        //强连通分量缩点
        dfs_clock = 0 , num_of_scc = 0;
        memset(dfn , 0 ,sizeof(dfn));
        memset(scc , 0 , sizeof(scc));
        memset(val_scc , 0 , sizeof(val_scc));
        tarjan(0 , -1);

        if(num_of_scc == 1){
            puts("impossible");
            continue;
        }

        //重新构建一个以连通分量缩点后的树形图
        memset(first , -1 , sizeof(first));
        k_scc = 0;
        for(int i=0 ; i<k ; i++){
            if(scc[e[i].x] == scc[e[i].y]) continue;
            add_edge_scc(scc[e[i].x] , scc[e[i].y]);
        }
        dfs(1 , -1);

        int minn = INF;
        for(int i=0 ; i<k_scc ; i++){
            if(!e_scc[i].flag) continue;
            minn = min(minn , my_abs(all - sum[e_scc[i].y] - sum[e_scc[i].y]) );
        }
        printf("%d
" , minn);
    }
    return 0;
}