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
*/