hdu2242考研路茫茫——空调教室(边双连通,缩点,dfs)

最新推荐文章于 2022-03-29 22:20:29 发布

_zidaoziyan

最新推荐文章于 2022-03-29 22:20:29 发布

阅读量1k

点赞数

分类专栏：双连通文章标签：连通图

本文链接：https://blog.csdn.net/acm_fighting/article/details/50383383

版权

双连通专栏收录该内容

0 篇文章 0 订阅

订阅专栏

考研路茫茫——空调教室

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Problem Description

众所周知，HDU的考研教室是没有空调的，于是就苦了不少不去图书馆的考研仔们。Lele也是其中一个。而某教室旁边又摆着两个未装上的空调，更是引起人们无限YY。

一个炎热的下午，Lele照例在教室睡觉的时候，竟然做起了空调教室的美梦。

Lele梦到学校某天终于大发慈悲给某个教室安上了一个空调。而且建造了了M条通气管道，让整个教学楼的全部教室都直接或间接和空调教室连通上，构成了教室群，于是，全部教室都能吹到空调了。

不仅仅这样，学校发现教室人数越来越多，单单一个空调已经不能满足大家的需求。于是，学校决定封闭掉一条通气管道，把全部教室分成两个连通的教室群，再在那个没有空调的教室群里添置一个空调。

当然，为了让效果更好，学校想让这两个教室群里的学生人数尽量平衡。于是学校找到了你，问你封闭哪条通气管道，使得两个教室群的人数尽量平衡，并且输出人数差值的绝对值。

Input

本题目包含多组数据，请处理到文件结束。
每组测试第一行包含两个整数N和M(0<N<=10000,0<M<20000)。其中N表示教室的数目(教室编号从0到N-1)，M表示通气管道的数目。
第二行有N个整数Vi(0<=Vi<=1000)，分别代表每个教室的人数。
接下来有M行，每行两个整数Ai，Bi(0<=Ai,Bi<N)，表示教室Ai和教室Bi之间建了一个通气管道。

Output

对于每组数据，请在一行里面输出所求的差值。
如果不管封闭哪条管道都不能把教室分成两个教室群，就输出"impossible"。

Sample Input

Sample Output

0
1

Author

linle

/*
题解:
首先,很容易想到用Tarjan求图中是否有桥,
如果没有桥则输出impossible
如果有桥,对原来的图进行缩点,建边,形成了一个新的图,该图必定无环(为树)
接下来是利用一个简单的树形dp,对树中的每个节点维护他的子树下的房间人数和
那么如果切断他和他祖先相连的边,则差值为abs(2*他子树的房间人数-总人数)
不停维护他的子树就可以了
*/
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <queue>
#include <vector>
using namespace std;

const int MAXN = 10010;
const int MAXM = 40100;

struct Edge
{
    int to,next;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值是1~block
int Index,top;
int block;
bool Instack[MAXN];
int count_num[MAXN];
int bridge;
vector<int>vec[MAXN];
int vis[MAXN];
int a[MAXN],num[MAXN],all;
int ans;

void addedge(int u,int v)
{
    edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut = false;
    head[u] = tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int pre_cnt=0;//处理重边,如果不需要可以去掉
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        v = edge[i].to;
        if( v == pre &&pre_cnt==0){
            pre_cnt++;
            continue;
        }
        if( !DFN[v] )
        {
            Tarjan(v,u);
            if(Low[u] > Low[v])Low[u] = Low[v];
            if(Low[v] > Low[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;
            }
        }
        else if(Instack[v] && Low[u] > DFN[v])
             Low[u] = DFN[v];
    }
    if(Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = block;
            count_num[block]+=a[v];
        }
        while( v != u );
    }
}

void init()
{
    tot = 0;
    all=0;
    memset(head,-1,sizeof(head));
}

void dfs(int u){
    vis[u]=1;
    for(int i=0;i<vec[u].size();i++){
        int v=vec[u][i];
        if(vis[v]==1)
            continue;
        dfs(v);
        count_num[u]+=count_num[v];
    }
    ans=min(ans,abs(count_num[u]-(all-count_num[u])));
}

void solve(int N)
{
    memset(DFN,0,sizeof(DFN));
    memset(count_num,0,sizeof(count_num));
    memset(Belong,0,sizeof(Belong));
    memset(vis,0,sizeof(vis));
    memset(Instack,false,sizeof(Instack));
    Index = top = block = 0;
    ans=1000000000;
    for(int i = 1;i <= N;i++)
        if(!DFN[i])
           Tarjan(i,-1);
    for(int i = 1;i <= block;i++)
      vec[i].clear();
    int flag=0;
    for(int u = 1;u <= N;u++){
        for(int i = head[u];i != -1;i = edge[i].next)
           if(edge[i].cut&&(Belong[u]!=Belong[edge[i].to])) //不加Belong[u]!=Belong[edge[i].to],flag就会变为1
           {
               flag=1;
               int v = edge[i].to;
               vec[Belong[u]].push_back(Belong[v]);
           }//建立一棵树
    }
    if(flag==0)
        printf("impossible\n");
    else{
        dfs(1);
        printf("%d\n",ans);
    }
}

int main()
{
    int n,m;
    int u,v;
    while(scanf("%d%d",&n,&m)==2)
    {
        init();
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            all+=a[i];
        }
        while(m--)
        {
            scanf("%d%d",&u,&v);
            u++,v++;
            addedge(u,v);
            addedge(v,u);
        }
        solve(n);
    }
    return 0;
}

代码二:直接在求双连通时就行树形dp

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <queue>
#include <vector>
using namespace std;

const int MAXN = 10010;
const int MAXM = 40100;

struct Edge
{
    int to,next;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值是1~block
int Index,top;
int block;
bool Instack[MAXN];
int count_num[MAXN];
int bridge;
int vis[MAXN];
int a[MAXN],num[MAXN],all;
int ans;

void addedge(int u,int v)
{
    edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut = false;
    head[u] = tot++;
}

int Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int pre_cnt=0;//处理重边,如果不需要可以去掉
    int sum=0;
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        v = edge[i].to;
        if( v == pre &&pre_cnt==0){
            pre_cnt++;
            continue;
        }
        if( !DFN[v] )
        {
            sum+=Tarjan(v,u);
            if(Low[u] > Low[v])Low[u] = Low[v];
            if(Low[v] > Low[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;
            }
        }
        else if(Instack[v] && Low[u] > DFN[v])
             Low[u] = DFN[v];
    }
    if(Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = block;
            sum+=a[v];
        }
        while( v != u );
        if(abs(2*sum-all)<ans)
            ans=abs(2*sum-all);
    }
    return sum;
}

void init()
{
    tot = 0;
    all=0;
    memset(head,-1,sizeof(head));
}

void solve(int N)
{
    memset(DFN,0,sizeof(DFN));
    memset(Belong,0,sizeof(Belong));
    memset(Instack,false,sizeof(Instack));
    Index = top = block = 0;
    ans=1000000000;
    for(int i = 1;i <= N;i++)
        if(!DFN[i])
           Tarjan(i,-1);
    if(block==1)
        printf("impossible\n");
    else
        printf("%d\n",ans);
}

int main()
{
    int n,m;
    int u,v;
    while(scanf("%d%d",&n,&m)==2)
    {
        init();
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            all+=a[i];
        }
        while(m--)
        {
            scanf("%d%d",&u,&v);
            u++,v++;
            addedge(u,v);
            addedge(v,u);
        }
        solve(n);
    }
    return 0;
}