hdu2242（树形dp+tarjan+缩点）

hdu2242 http://acm.hdu.edu.cn/showproblem.php?pid=2242

给定n，m表示n个点，m条边

每个点有个权值

问我们删除两某条边（割边）后将图分为两个部分，要使得两个部分的权值之差最小

这题的弱化版本是在一棵树上删除某条边后后将图分为两个部分，要使得两个部分的权值之差最小。是用树形dp来做的

但是这道题目是个图，但是我们可以转化为树，即将图中的边连通分量求出来，然后缩成一个点，建出一个新的树图，那么就可以用树形dp来求解题目了.

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 typedef long long LL;
 const int INF = <<;
 const int N =  + ;
 vector<int> g1[N],g2[N];
 int val1[N],val2[N];
 int dfn[N],low[N],dfs_clock,cnt;
 int belong[N];
 stack<int> st;
 bool vis[N];
 int ans,sum;
 void tarjan(int u, int fa)
 {
     bool flag = false;
     vis[u] = true;
     dfn[u] = low[u] = ++dfs_clock;
     st.push(u);
     for(int i=; i<g1[u].size(); ++i)
     {

         int v = g1[u][i];
         if(v==fa && !flag)
         {
             flag = true;
             continue;
         }
         if(!vis[v]) tarjan(v,u);
         low[u] = min(low[u],low[v]);
     }
     if(dfn[u]==low[u])
     {
         cnt++;
         int x;
         do
         {
             x= st.top();
             st.pop();
             belong[x] = cnt;
             val2[cnt] += val1[x];
         }while(u!=x);
     }
 }

 void dfs(int u, int fa)
 {
     vis[u] = true;
     for(int i=; i<g2[u].size(); ++i)
     {
         int v = g2[u][i];
         if(vis[v]) continue;
         dfs(v,u);
         val2[u] += val2[v];
     }
 }
 void dfs2(int u, int fa)
 {
     vis[u] = true;
     for(int i=; i<g2[u].size(); ++i)
     {
         int v = g2[u][i];
         if(vis[v]) continue;
         ans = min(ans,abs(sum-*val2[v]));
         dfs2(v,u);
     }
 }
 int main()
 {
     int n,m,i,u,v,j;
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         for(i=; i<=n; ++i)
         {
             g1[i].clear();
             g2[i].clear();
         }
         sum = ;
         for(i=; i<n; ++i)
         {
             scanf("%d",&val1[i]);
             sum += val1[i];
         }
         for(i=; i<m; ++i)
         {
             scanf("%d%d",&u,&v);
             g1[u].push_back(v);
             g1[v].push_back(u);
         }
         memset(vis,,sizeof(vis));
         memset(dfn,,sizeof(dfn));
         memset(low,,sizeof(low));
         memset(val2,,sizeof(val2));
         dfs_clock = ;
         cnt = ;
         tarjan(,-);
         for(i=; i<n; ++i)
             for(j=; j<g1[i].size(); ++j)
             {
                 int v = g1[i][j];
                 if(belong[v] != belong[i])//建新图,虽然新建的图会有重边，但是不影响树形dp
                 {
                     g2[belong[i]].push_back(belong[v]);
                     g2[belong[v]].push_back(belong[i]);
                 }
             }
         if(cnt==)//如果整个图是边连通的，那么不管删哪条边都不能使得图不连通
         {
             puts("impossible");
             continue;
         }
         ans = INF;
         memset(vis,,sizeof(vis));
         dfs(,-);
         memset(vis,,sizeof(vis));
         dfs2(,-);
         printf("%d\n",ans);
     }
     return ;
 }