hdu 2242 考研路茫茫——空调教室 点强连通+树形dp

首先用强连通缩点，之后再用图中的桥和强连通分量新建一张图，之后算一次树形dp。
树形dp过程是，将一棵无根树，当成有根树，利用dfs计算每个节点的子树中的权值（即每一个强连通分量中的人数）

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
struct Edge
{
    int from,to,tag;
};

int n,m,dfn[200000+5],low[200000+5],vis[200000+5],dep,num,p[200000+5];
int ans,sum,pe[20000+5],bcc_sum[20000+5],dp[20000+5];
vector<Edge>edges;
vector<int>G[200000+5];
vector<int>g[200000+5];

void AddEdge(int from,int to)
{
    int i,flag=0;
    for(i=0; i<G[from].size(); i++)
        if(edges[G[from][i]].to==to)
        {
            edges[G[from][i]].tag++;
            flag=1;
            break;
        }
    if(!flag)
    {
        Edge tp;
        tp.from=from;
        tp.to=to;
        tp.tag=0;
        edges.push_back(tp);
        G[from].push_back(edges.size()-1);
    }
}

void dfs(int u,int fa)
{
    dfn[u]=low[u]=++dep;
    for(int i=0; i<G[u].size(); i++)
    {
        Edge t=edges[G[u][i]];
        if(!vis[t.to])
        {
            vis[t.to]=1;
            dfs(t.to,u);
            low[u]=min(low[u],low[t.to]);
            if(low[t.to]>dfn[u]&&!t.tag)
            {
                g[u].push_back(t.to);
                g[t.to].push_back(u);
                num++;
            }
        }
        else if(t.to!=fa||t.tag)
            low[u]=min(low[u],dfn[t.to]);
    }
}

void dfs2(int u,int bcc)
{
    p[u]=bcc;
    dp[bcc]+=pe[u];
    for(int i=0; i<G[u].size(); i++)
    {
        int to=edges[G[u][i]].to;
        bool f=true;
        for(int j=0; j<g[u].size(); j++)
        {
            int v=g[u][j];
            if(v==to)
            {
                f=false;
                break;
            }
        }
        if(!f||vis[to]) continue;
        vis[to]=1;
        dfs2(to,bcc);
    }
}

void dfs3(int u)
{
    vis[u]=1;
    for(int i=0; i<G[u].size(); i++)
    {
        int v=G[u][i];
        if(vis[v]==-1)
        {
            dfs3(v);
            dp[u]+=dp[v];
        }
    }
    ans=min(ans,abs(sum-2*dp[u]));
    //printf("%d %d\n",ans,abs(sum-2*dp[u]));
}

void find_bcc()
{
    int i,j,bcc,u,v;
    memset(vis,0,sizeof(vis));
    num=dep=0;
    for(i=0; i<n; i++)
    {
        if(!vis[i])
        {
            vis[i]=1;
            dfs(i,-1);
        }
    }
    memset(vis,0,sizeof(vis));
    memset(p,0xff,sizeof(p));
    memset(dp,0,sizeof(dp));
    bcc=0;
    for(i=0; i<n; i++)
    {
        if(!vis[i])
        {
            vis[i]=1;
            dfs2(i,bcc);
            bcc++;
        }
    }
    if(bcc==1)
    {
        printf("impossible\n");
    }
    else {
    for(i=0; i<=n; i++)
        G[i].clear();

    for(i=0; i<n; i++)
        for(j=0; j<g[i].size(); j++)
        {
            int v=g[i][j];
            if(p[v]!=p[i])
            {
                G[p[i]].push_back(p[v]);
            }
        }
    memset(vis,0xff,sizeof(vis));
    ans=0x7fffffff;
    dfs3(0);
    if(ans==sum) printf("impossible\n");
    else printf("%d\n",ans);
    }
}

int main()
{
    int _,i,u,v;
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0) break;
        edges.clear();
        sum=0;
        for(i=0; i<n; i++)
        {
            scanf("%d",&pe[i]);
            sum+=pe[i];
        }
        for(i=0; i<=n; i++)
        {
            G[i].clear();
            g[i].clear();
        }
        for(i=1; i<=m; i++)
        {
            scanf("%d%d",&u,&v);
            AddEdge(u,v);
            AddEdge(v,u);
        }
        find_bcc();
    }
    return 0;
}