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 = ;
 const int INF = ;

 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<<] , e_scc[N<<];

 int my_abs(int x)
 {
     return x>=?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 = ; //用来解决重边情况
     for(int i=first[u] ; i!=- ; i=e[i].next){
         int v = e[i].y;
         /*
         因为第一次遇到父节点的边，表示是一开始下来的边，这个是不允许访问的，
         但是如果遇到2次及以上，说明u v之间不止一条边，访问到第二次之后的边是允许
         low[u]通过这个重边得到dfn[v]比较下的较小值进行更新
         */
         if(v == fa && flag){
             flag = ;
             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!=- ; 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) == ){
         memset(first , - , sizeof(first));
         k= , all = ;
         for(int i= ; i<n ; i++)
         {
             scanf("%d" , val+i);
             all += val[i];
         }

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

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

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

         //重新构建一个以连通分量缩点后的树形图
         memset(first , - , sizeof(first));
         k_scc = ;
         for(int i= ; 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( , -);

         int minn = INF;
         for(int i= ; 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\n" , minn);
     }
     return ;
 }