HDU2422_考研路茫茫——空调教室_Tarjan缩点+树形dp/判断联通块数量

考研路茫茫——空调教室的题目链接

题目数据：
N和M(0<N<=10000,0<M<20000)
一开始以为是树的重心，结果一直提示超内存，后来看了看题，发现不对，m>n-1啊,不可能是树；
肯定有环；
但是我们破坏环中的任意一条边，都不会满足题意。
所以我们寻找的那条边肯定不在环里，而分开之后，
在一个环里的那些点不会分开，所以可以见一个环
变成一个点；这样就可以把这个代环的图转化为一
棵树，然后按照求树的重心的方法去解决了；

小技巧：
^按位异或
(0,1)
(2,3)
(4,5)
……
（2*n，2*n+1）

（2*n）^1==(2*n+1)
(2*n+1)==(2*n);
(tarjan算法中处理无向边的技巧：
对于a<-->b，在a-->b和b-->a中的任意一条边被使用，另一条边也要被标记;
e[i].flag=e[i^1].flag=1;)

《新知识点：Tarjan算法》
《重点是变量好多！！！！》

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int num=10010;
/////////////////////
struct node{
    int u,v,next;
    bool flag;
}e[num<<1];//第二次生成树的时候也用e，覆盖前一次的数据即可。
int head[num],cnt;//用于第一次生成图
int head2[num],cnt2;//用于生成树
//////////////////////
//Tarjan算法核心(dfn，low，ind)，模拟栈(stack,t)，(all,w[num],w2[num]
//,总价值，每个点，环合并之后的价值)，（f，cnt3，f，新树上的结点，cnt3，新树上有几个结点）
int dfn[num],low[num],ind,stack[num],t,all,w[num],w2[num],f[num],cnt3;
bool vis[num];//那个点在栈中
//////////////////////
int n,m;
//////////////////////
int dp[num],ip[num],ans;//ip，进度（无向图）
/////////////////////
void int_i(void)
{
    t=0;
    cnt=cnt2=-1;//初始化为-1.使得边的编号从0开始
    cnt3=0;
    ind=0;
    all=0;
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(w2,0,sizeof(w2));
    memset(w,0,sizeof(w));
    memset(head,-1,sizeof(head));
    memset(head2,-1,sizeof(head2));
    memset(vis,0,sizeof(vis));
    memset(f,-1,sizeof(num));
    memset(dp,0,sizeof(dp));
    memset(ip,0,sizeof(ip));
    memset(stack,0,sizeof(stack));
    ans=inf;
    return ;
}
void addedge1(int u,int v)//图
{
    e[++cnt].u=u;
    e[cnt].v=v;
    e[cnt].flag=false;
    e[cnt].next=head[u];
    head[u]=cnt;
    return ;
}
void addedge2(int u,int v)//树
{
    e[++cnt2].u=u;
    e[cnt2].v=v;
    e[cnt2].flag=false;
    e[cnt2].next=head2[u];
    head2[u]=cnt2;
    ip[v]++;
    return ;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++ind;
    stack[++t]=u;
    vis[u]=true;
    int v;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        if(e[i].flag) continue;
        v=e[i].v;
        e[i].flag=e[i^1].flag=true;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(vis[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }

    if(dfn[u]==low[u])
    {
        cnt3++;
        do{
            v=stack[t--];
            vis[v]=false;
            f[v]=cnt3;//1
            w2[cnt3]+=w[v];//2
            //1，2，将环中的点合并在一块
           // printf("cnt==%d,v==%d\n",cnt3,v);
        }while(v!=u);
    }
    return ;
}
void dfs(int u,int f)
{
    int v;
    dp[u]=w2[u];
    for(int i=head2[u];i!=-1;i=e[i].next)
    {
        v=e[i].v;
      //  printf("u==%d,v==%d",u,v);
        if(v==f) continue;
        dfs(v,u);
        dp[u]+=dp[v];
    }
   // printf("dp==%d\n",dp[u]);
    ans=min(ans,abs(all-2*dp[u]));
    return ;
}
int main()
{
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int_i();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&w[i]);
            all+=w[i];
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&u,&v);
            u++;v++;
            addedge1(u,v);
            addedge1(v,u);
        }
        tarjan(1);
        if(cnt3==1) {
            printf("impossible\n");
            continue;
        }
        //生成树：
        for(int i=0;i<=cnt;i++)
        {
            u=e[i].u;
            v=e[i].v;
            //f[u]==f[v],说明一条边的两个点，在同一个环中；
            //f[u]!=f[v]，说明这条边连接了两部分；构成树上的新边
            if(f[u]!=f[v])
            {
              //  printf("u==%d,v==%d\n",f[u],f[v]);
                addedge2(f[u],f[v]);
            }
        }

        for(int i=1;i<=cnt3;i++)
        {
           // printf("ip==%d\n",ip[i]);
            if(ip[i]==1)
            {
                dfs(i,-1);
                printf("%d\n",ans);
                break;
            }
        }
    }
    return 0;
}
/*
 4 3
 1 1 1 1
 0 1
 1 2
 2 3
 4 3
 1 2 3 5
 0 1
 1 2
 2 3
*/