洛谷P3469 [POI2008]BLO-Blockade

P3469 [POI2008]BLO-Blockade

题目描述

There are exactly nn towns in Byteotia.

Some towns are connected by bidirectional roads.

There are no crossroads outside towns, though there may be bridges, tunnels and flyovers. Each pair of towns may be connected by at most one direct road. One can get from any town to any other-directly or indirectly.

Each town has exactly one citizen.

For that reason the citizens suffer from loneliness.

It turns out that each citizen would like to pay a visit to every other citizen (in his host's hometown), and do it exactly once. So exactly n\cdot (n-1)n⋅(n−1) visits should take place.

That's right, should.

Unfortunately, a general strike of programmers, who demand an emergency purchase of software, is under way.

As an act of protest, the programmers plan to block one town of Byteotia, preventing entering it, leaving it, and even passing through.

As we speak, they are debating which town to choose so that the consequences are most severe.

Task Write a programme that:

reads the Byteotian road system's description from the standard input, for each town determines, how many visits could take place if this town were not blocked by programmers, writes out the outcome to the standard output.

给定一张无向图，求每个点被封锁之后有多少个有序点对(x,y)(x!=y,1<=x,y<=n)满足x无法到达y

输入输出格式

输入格式：

 

In the first line of the standard input there are two positive integers: nn and mm (1\le n\le 100\ 0001≤n≤100 000, 1\le m\le 500\ 0001≤m≤500 000) denoting the number of towns and roads, respectively.

The towns are numbered from 1 to nn.

The following mm lines contain descriptions of the roads.

Each line contains two integers aa and bb (1\le a<b\le n1≤a<b≤n) and denotes a direct road between towns numbered aa and bb.

 

输出格式：

 

Your programme should write out exactly nn integers to the standard output, one number per line. The i^{th}ith line should contain the number of visits that could not take place if the programmers blocked the town no. ii.

 

输入输出样例

输入样例#1： 复制

5 5
1 2
2 3
1 3
3 4
4 5

输出样例#1： 复制

8
8
16
14
8

/*
     思路就是求出是否为割点，如果是就算出这个割点无法联通的点的数量ans[i] 
     最后答案即为(ans[i]+n-1)*2
*/
#include <bits/stdc++.h>

using namespace std;

const int maxn = 100006;

int dfn[maxn],low[maxn],n,m,cnt,sz[maxn];
long long ans[maxn];

vector<int> G[maxn];//vector领接表存图

void tarjan(int u){
    long long z = 0;sz[u] = 1;//注意这里要置初值，否则答案不对
    dfn[u] = low[u] = ++cnt;
    for(int i = 0;i < G[u].size();i++){
        int v = G[u][i];
        if(!dfn[v]){
            tarjan(v);
            low[u] = min(low[u],low[v]);
            sz[u] += sz[v];
            if(low[v] >= dfn[u]){//如果满足子树的low>=父节点的dfn 说明父节点为割点
                ans[u] += 1ll * z * sz[v];//现在割去的部分和以前割去的部分都不能联通
                z += sz[v];//更新割去的点的数目
            }
        }else{
            low[u] = min(low[u],dfn[v]);
        }//常规的求割点操作 只不过不要考虑父节点啥的
    }
    ans[u] += 1ll * (n-1-z) * z;//现在割去的部分和没有割去的部分不能联通 n-1-z求的是除了u和割去的子树外的其他联通点
}

int main(){
    int x,y;
    scanf("%d%d",&n,&m);
    for(register int i = 1;i <= m;i++){
        scanf("%d%d",&x,&y);
        G[x].push_back(y);
        G[y].push_back(x);//双向边连图
    }
    for(register int i = 1;i <= n;i++){
        if(!dfn[i]) tarjan(i);
    }
    for(register int i = 1;i <= n;i++){
        printf("%lld\n",(ans[i]+n-1)<<1);//位运算加快计算速度
    }//这里ans数组求的是因为割点无法互相到达的点的数目，还要加上本身连接的n-1个点
    return 0;
}