其实也就是无向图的连通性
复习：
无向图的联通分量
割点：在一个联通分量里面有一些关键点，如果删除它，会把这个联通分量分为更多。
割边——双连通问题
有多少个割点：DFS，深搜优先生成树
对任意一个点s做DFS,生成一棵树
1）如果树的根节点s有两个或更多的孩子：s是割点
2）T的非根节点u是割点：当且仅当u存在一个子节点v，v及其后代都没有回退边连回u的祖先
HOW:u的直接后代v，数组num[]表示DFS时候的顺序，low[i]表示i及其后代能够回退回的祖先的num，一开始是num[i]=low[i]=dfn++
如果low[v]>=num[u]，那么u就是割点
如果low[v]>num[u]，那么u-->v就是割边
int low[maxn],num[maxn];
vector<int> g[maxn];
bool iscut[maxn];
int dfn;
void dfs(int u,int fa){
low[u]=num[u]=dfn++; //初始值为DFS访问的顺序
int child=0;
for(int i=0;i<g[u].size();i++){
int v=g[u][i];
if(!num[v]){
child++;
dfs(v,u);
low[u]=min(low[u],low[v]); //用后代的Low更新爸爸的low
if(low[v]>=num[u]&&u!=1) //判断割点1：不是根节点的判断
iscut[u]=1;
}
else if(num[v]<num[u]&&v!=fa){
low[u]=min(low[u],num[v]); //处理回退边，fa也是u的邻居，但是之前已经访问过，所以不需要处理
}
}
if(u==1&&child>=2) iscut[1]=1; //根节点
}
int main(){
int ans,n;
//输入图
memset(low,0,sizeof(low));
memset(num,0,sizeof(num));
dfn=0;
memset(iscut,0,sizeof(iscut));
ans=0;
dfs(1,-1);
for(int i=1;i<=n;i++) ans+=iscut[i];
cout<<ans<<endl;
return 0;
}
双连通分量：
在一个联通图中任选两点，如果至少存在两条“点不重复”的路径，称为点双连通。点双连通极大子图：点双连通分量（没有割点）
边双连通分量：如果至少存在两条“边不重复”的路径，成为边双连通（没有割边）
点双连通分量：如果至少存在两条“点不重复”的路径，称为点双连通（没有割点）
Tarjan，在dfs的时候，把遍历过程中的点保存起来，就可以得到点双连通分量，保存在栈，找到割点就拿出来，注意存在栈的是边
边双连通分量：缩点的技术：
1）首先找出图G的所有边双连通分量，DFS时，所有点生成low值，low值相同的就是同一个SCC，，有多少个SCC就有多少个边双连通分量
2）把每个边双连通分量看作一个点，low值相同的合并为一个点
3）转化为一棵树，即至少在缩点树上面增加多少条边才能变为一个边双连通图，即（度为1的点+1）/2
下面的是求需要连接多少条边才能变为双连通分量，只需要low数组
ps。也可以用tarjin的算法
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=1010;
const int INF=0x3fffffff;
typedef long long LL;
int n,m,low[maxn],dfn;
vector<int> g[maxn];
void dfs(int u,int fa){
low[u]=++dfn;
for(int i=0;i<g[u].size();i++){
int v=g[u][i];
if(v==fa) continue;
if(!low[v]) dfs(v,u);
low[u]=min(low[u],low[v]); //在这里处理最小值
}
}
int degree[maxn]; //计算每个缩点的度数
int tarjan(){
memset(degree,0,sizeof(degree));
for(int i=1;i<=n;i++){
for(int j=0;j<g[i].size();j++){
if(low[i]!=low[g[i][j]]){
degree[low[i]]++;
}
}
}
int res=0;
for(int i=1;i<=n;i++){
if(degree[i]==1) res++;
}
return res;
}
int main(){
while(~scanf("%d %d",&n,&m)){
memset(low,0,sizeof(low));
for(int i=0;i<=n;i++) g[i].clear();
for(int i=1;i<=m;i++){
int a,b;
scanf("%d %d",&a,&b);
g[a].push_back(b);
g[b].push_back(a);
}
dfn=0;
dfs(1,-1);
int ans=tarjan();
printf("%d\n",(ans+1)/2);
}
return 0;
}
例题：
1520：【 例 1】分离的路径
给出一个无向图，求要变成一个边双连通分量，要加多少条边。
和上面求双连通分量一样的
（第二种写法）：tarjin判环，统计入度为1的点的个数，新建道路可连接2个入度为1的点，故道路为入度为1的点的个数的一半。
注意的一点是： if(flag[i]==0||flag[i^1]==0){ //相邻的两条边
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=1010;
const int INF=0x3fffffff;
typedef long long LL;
int f,r;
//得到的是边双连通分量
//下面自己额这个有一个通不过
int low[5010];
int num=0,dfn=0;
vector<int> adj[5010];
void dfs(int x,int fa){
low[x]=++dfn;
for(int i=0;i<adj[x].size();i++){
int v=adj[x][i];
if(v==fa) continue;
if(!low[v]) dfs(v,x);
low[x]=min(low[x],low[v]);
}
}
//度为1 的个数，就是需要的边
int in[5010];
int js(){
memset(in,0,sizeof(in)); ///计算每个缩点的度数
for(int i=1;i<=f;i++){
for(int j=0;j<adj[i].size();j++){
if(low[i]!=low[adj[i][j]]) in[low[i]]++; //如果不在同一个连通块
}
}
for(int i=1;i<=f;i++){
if(in[i]==1) num++;
}
return (num+1)/2;
}
int main(){
scanf("%d %d",&f,&r);
int x,y;
for(int i=0;i<r;i++){
scanf("%d %d",&x,&y);
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1,-1);
int road=js();
cout<<road<<endl;
return 0;
}
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
int dfn[5010]; //还要了这个数组
int low[5010];
int f[5010],head[5010],in[5010],flag[5010];
int vis[5010],tot,cnt;
//tarjin判环，统计入度为1的点的个数，新建道路可连接2个入度为1的点，故道路为入度为1的点的个数的一半。
stack<int> st;
struct node{
int u,v,next;
}e[5010*2];
int n,m;
int summ=-1;
void add(int u,int v){
e[++summ]=node{u,v,head[u]};
head[u]=summ;
}
void tarjin(int u){
dfn[u]=low[u]=++cnt;
st.push(u);
vis[u]=1;
int v;
for(int i=head[u];i;i=e[i].next){
v=e[i].v;
if(flag[i]==0||flag[i^1]==0){ //相邻的两条边
flag[i]=flag[i^1]=1;
if(!dfn[v]){
tarjin(v);
low[u]=min(low[u],low[v]);
}
else if(vis[v]){ //回退边 ，如果要用这种判断方式的话，就需要在下面改变为vis[i]=0
low[u]=min(low[u],dfn[v]);
}
}
}
if(low[u]==dfn[u]){ //也是有缩点的技术
tot++;
do{
v=st.top();
st.pop();
f[v]=tot;
vis[v]=0; //可以出来了
}while(u!=v);
}
}
int main()
{
cin>>n>>m;
for(int i=1;i<=m;i++){
int u,v;
cin>>u>>v;
add(u,v);add(v,u);
}
for(int i=1;i<=n;i++){
if(!dfn[i]) tarjin(i);
}
for(int i=1;i<=2*m;i+=2){ //看这个循环
int u=e[i].u,v=e[i].v;
if(f[u]==f[v]) continue;
in[f[v]]++;in[f[u]]++; //无向边，不存在入度出度，反正两个点的都算（缩点后的点）
}
int ans=1;
for(int i=1;i<=tot;i++){
if(in[i]==1) ans++;
}
cout<<ans/2<<endl;
}
1521：【 例 2】矿场搭建
煤矿工地可以看成是由隧道连接挖煤点组成的无向图。为安全起见，希望在工地发生事故时所有挖煤点的工人都能有一条出路逃到救援出口处。于是矿主决定在某些挖煤点设立救援出口，使得无论哪一个挖煤点坍塌之后，其他挖煤点的工人都有一条道路通向救援出口。
请写一个程序，用来计算至少需要设置几个救援出口，以及不同最少救援出口的设置方案总数。
这道题蛮复杂，要先用tarjin算割点，然后用DFS出每个分量里面的割点数量，根据不同的数量不同的处理（画图看看吧）
解析：https://www.luogu.com.cn/problemnew/solution/P3225
分类讨论：
1）如果没有割点，至少需要建立两个出口，从任意非割点的地方选择两个点建立
2）如果这个分组只有一个割点，只需要在分组内设立一个出口，可以设立在任意一个非割点的地方
3）如果有两个及以上个割点，则无需建立，可以直接到达其他联通块
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=510;
const int INF=0x3fffffff;
typedef long long LL;
//最后得到点双连通分量
//还要求不同的方案数
//用Tarjan跑出割点，然后DFS搜索所有的联通快
//计算每一个联通快中的割点数目
//分类讨论：
//如果没有割点
//至少需要建立两个出口
//从任意非割点的地方选择两个点建立
//如果这个分组只有一个割点
//只需要在分组内设立一个出口
//可以设立在任意一个非割点的地方
//如果有两个及以上个割点，则无需建立，可以直接到达其他联通块
//https://www.luogu.com.cn/problemnew/solution/P3225
int dfn[maxn],vis[maxn],low[maxn];
bool cut[maxn]; //是不是割点
int head[maxn];
LL ans,cnt,dfnn,ans1,ans2,group,cases,root,rs,cuts;
int n,m;
void inti(){
memset(head,-1,sizeof(head));
memset(dfn,0,sizeof(dfn));
memset(low,0,sizeof(low));
memset(cut,0,sizeof(cut));
memset(vis,0,sizeof(vis));
dfnn=0; //至少需要的出口数
cnt=0;ans1=0;group=0;
ans2=1; //方案数
}
struct edge{
int to,next;
}e[maxn*maxn];
int num=0;
void add(int u,int v){
e[num]=edge{v,head[u]};
head[u]=num++;
}
void tarjin(int u,int fa){ //得到所有的割点
int v;
low[u]=dfn[u]=++dfnn;
for(int i=head[u];i!=-1;i=e[i].next){
v=e[i].to;
if(!dfn[v]){
tarjin(v,u);
low[u]=min(low[u],low[v]);
if(low[v]>=dfn[u]){ //割点
if(u!=root){ ////如果u不是子树的根节点
cut[u]=1;
}
else rs++; //根节点子节点数增加
}
}
else if(v!=fa){ //如果v不是u的父节点，但是v已经访问过
low[u]=min(low[u],dfn[v]); //判断是否能够更新Low
}
}
}
void dfs(int u){//DFS搜索一边联通块 ,得到这个连通块中的割点数
int v;
vis[u]=group;
ans++; //非割点数
for(int i=head[u];i!=-1;i=e[i].next){
v=e[i].to;
if(cut[v]&&vis[v]!=group){ ////如果v是割点并且v没有在这个分组内被访问过
cuts++; //割点数增加
vis[v]=group;
}
if(!vis[v]){
dfs(v);
}
}
}
int main(){
LL u,v;
cases=1;
while(cin>>m&&m){
inti();
n=-1;
for(int i=1;i<=m;i++){
cin>>u>>v;
add(u,v);add(v,u);
if(max(u,v)>n) n=max(u,v);
}
for(int i=1;i<=n;i++){
if(!dfn[i]){
root=i;
rs=0;
tarjin(i,i);
if(rs>=2) cut[i]=1; ////如果子树根节点的儿子数不少于2个，则这个根节点才是割点
}
}
for(int i=1;i<=n;i++){ ////枚举所有点来搜索分组
if(!vis[i]&&!cut[i]){
++group;
ans=0;cuts=0;
dfs(i);
if(cuts==0){ //如果这个连通块没有割点，就是两个出口
ans1+=2;
ans2*=(ans)*(ans-1)/2;
}
else if(cuts==1){ //如果有一个割点
ans1+=1;
ans2*=ans;//可以设立在任意一个非割点的地方
}
//如果有两个及以上个割点，则无需建立，可以直接到达其他联通块
}
}
cout<<"Case "<<cases++<<": "<<ans1<<" "<<ans2<<endl;
}
return 0;
}
1522：网络
求割点数量，但是关键是输入比较难以控制。
不确定行数，一组的数据以0结束
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=1010;
const int INF=0x3fffffff;
typedef long long LL;
//求割点数
int low[110],num[110],vis[110];
int n,dfn;
bool iscut[110];
//我觉得难点在于输入的控制，之后就是模板了
vector<int> adj[110];
void dfs(int u,int fa){
num[u]=low[u]=++dfn;
int child=0; //为了根节点
for(int i=0;i<adj[u].size();i++){
int v=adj[u][i];
if(!num[v]){
child++;
dfs(v,u);
low[u]=min(low[u],low[v]);
if(low[v]>=num[u]&&u!=1) iscut[u]=1; //如果不是根节点而且有回退变
}
else if(num[v]<num[u]&&v!=fa){
low[u]=min(low[u],num[v]); //有回退变
}
}
if(u==1&&child>1) iscut[1]=1;
}
int main(){
int x,y;
while(cin>>n&&n){
for(int i=1;i<=n;i++) adj[i].clear();
while(cin>>x&&x){
while(cin>>y){
adj[x].push_back(y);
adj[y].push_back(x);
if(getchar()=='\n') break; //!!!!
}
}
dfn=0;
int ans=0;
memset(iscut,0,sizeof(iscut));
memset(low,0,sizeof(low));
memset(num,0,sizeof(num));
dfs(1,-1);
for(int i=1;i<=n;i++) if(iscut[i]) ans++; //计算割点数量
cout<<ans<<endl;
}
return 0;
}
1523：嗅探器
考虑缩点时的过程，我们通过找v为根的搜索子树是否能延伸到时间戳小于u的节点来判断u是否为割点。如果该子树满足这一条件，则去掉u后该子树会与其余部分“失去联系”。
由此我们这样想：如果我们以一个信息中心a为根开始搜索，找到一个非根的割点u；此时若对应的子树根v的时间戳小于等于b的时间戳，则说明b存在于v为根的这颗子树内。
很容易通过阐述说明这一点。由于dfn随dfs序更新，若还没搜到b，则其dfn为0；或者dfn不为0而小于v，则说明b在进入v以前已经被搜到了。
那么如果把u断掉，v的整棵子树都会与根a失去联系，u就是所求的点之一。
or 我们要找出编号最小的割点，并且使这个割点能断开a和b的连接，所以要特判一下
一个点在割点的基础上，还要满足以下条件
要确保终点是从这一条边上通过的，还有终点不能通往这个点以前的任何点
所以：
考虑我们有一个u点，它连了一个v点，那么u点需要满足4个条件。
1、u不是起点终点。因为题目要求在中间服务器上建嗅探器。
2、u是割点。废话
3、终点(y)的dfn应该大于等于v点的dfn，因为要确保终点在v点或之后被访问到，即u点为必经的点。
4、终点(y)的low应该大于等于u点的dfn，因为要确保终点必须要经过u点。
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=500010;
const int INF=0x3fffffff;
typedef long long LL;
/*
考虑缩点时的过程，我们通过找v为根的搜索子树是否能延伸到时间戳小于u的节点来判断u是否为割点。如果该子树满足这一条件，则去掉u后该子树会与其余部分“失去联系”。
由此我们这样想：如果我们以一个信息中心a为根开始搜索，找到一个非根的割点u；此时若对应的子树根v的时间戳小于等于b的时间戳，则说明b存在于v为根的这颗子树内。
很容易通过阐述说明这一点。由于dfn随dfs序更新，若还没搜到b，则其dfn为0；或者dfn不为0而小于v，则说明b在进入v以前已经被搜到了。
那么如果把u断掉，v的整棵子树都会与根a失去联系，u就是所求的点之一。
*/int n;
int low[maxn],num[maxn],cut[maxn],head[maxn];
int a,b;
struct node{
int to,next;
}ed[maxn*2];
int dfn,cnt;
void add(int f,int t){
ed[++cnt].next=head[f];
ed[cnt].to=t;
head[f]=cnt;
}
void tarjin(int u){
low[u]=num[u]=++dfn;
for(int i=head[u];i;i=ed[i].next){
int v=ed[i].to;
if(!num[v]){
tarjin(v);
low[u]=min(low[u],low[v]);
if(low[v]>=num[u]&&u!=a&&num[b]>=num[v]){//此时若对应的子树根v的时间戳小于等于b的时间戳，则说明b存在于v为根的这颗子树内。
cut[u]=1;
}
}
else low[u]=min(low[u],num[v]);
}
return ;
}
int main(){
scanf("%d",&n);
int x,y;
while(scanf("%d %d",&x,&y)){
if(x==0&&y==0) break;
add(x,y);
add(y,x);
}
scanf("%d %d",&a,&b);
tarjin(a);
for(int i=1;i<=n;i++){
if(cut[i]){
printf("%d\n",i);
return 0;
}
}
printf("No solution\n");
return 0;
}
1524：旅游航道
其实就是计算割边的数目
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#define MAXN 150010
#define REP(i,k,n) for(int i=k;i<=n;i++)
#define in(a) a=read()
using namespace std;
inline int read(){
int f=1,x=0;
char ch=getchar();
for(;!isdigit(ch);ch=getchar())
if(ch=='-')
f=-1;
for(;isdigit(ch);ch=getchar())
x=x*10+ch-'0';
return x*f;
}
int n,m,cnt,ans;
int dfn[MAXN],low[MAXN];
int total=0,head[MAXN],nxt[MAXN<<1],to[MAXN<<1];
inline void adl(int a,int b){
total++;
to[total]=b;
nxt[total]=head[a];
head[a]=total;
return ;
}
inline void tarjan(int u,int f){
low[u]=dfn[u]=++cnt;
for(int e=head[u];e;e=nxt[e]){
if(!dfn[to[e]] && to[e]!=f){
tarjan(to[e],u);
low[u]=min(low[to[e]],low[u]);
if(low[to[e]]>dfn[u]) ans++;
}
else if(dfn[to[e]]<low[u] && to[e]!=f) low[u]=dfn[to[e]];
}
return ;
}
int main(){
while(scanf("%d%d",&n,&m)!=EOF){
if(n==0 && m==0) return 0;
total=0;
memset(dfn,0,sizeof(dfn));
memset(low,0,sizeof(low));
memset(head,0,sizeof(head));
cnt=ans=0;
int a,b;
REP(i,1,m){
in(a);in(b);
adl(a,b);
adl(b,a);
}
tarjan(1,0);
cout<<ans<<endl;
}
}
1525：电力
求一个图删除一个点之后，联通块最多有多少。
回想我们判断割点时的条件
1° 搜索树 子树中存在点 low[v]>=dfn[u]，即返回的时间戳不小于当前点u，删除这个点u，子树分离
2° 根节点 一个根节点root 满足超过两棵子树即为割点，很好理解
回到此题
对于情况一。当前点u，每有一个满足的子树，删除点u后就会有一个联通块，记录个数即可；
此外，还需要考虑点u的父亲，删除割点u后他的父亲与他的子树们也会分裂，个数++
对于情况二。好办，子树的个数
这样下来就得到了每个点删除后形成的新联通块个数
每断开一个点，原联通块消失，分裂成几部分，这也就是答案统计
like bool cut[] -------> int cut[]
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=1e5+10;
const int INF=0x3fffffff;
typedef long long LL;
/*
回想我们判断割点时的条件
1° 搜索树 子树中存在点 low[v]>=dfn[u]，即返回的时间戳不小于当前点u，删除这个点u，子树分离
2° 根节点 一个根节点root 满足超过两棵子树即为割点，很好理解
回到此题
对于情况一。当前点u，每有一个满足的子树，删除点u后就会有一个联通块，记录个数即可；
此外，还需要考虑点u的父亲，删除割点u后他的父亲与他的子树们也会分裂，个数++
对于情况二。好办，子树的个数
这样下来就得到了每个点删除后形成的新联通块个数
每断开一个点，原联通块消失，分裂成几部分，这也就是答案统计
*/
int ans,n,m;
int cnt;
struct node{
int to,next;
}ed[maxn<<1];
int head[maxn],low[maxn],num[maxn],dfn;
int cut[maxn]; //记录割点个数
void adde(int a,int b){
ed[++cnt].next=head[a];
ed[cnt].to=b;
head[a]=cnt;
}
void tarjin(int x,int fa){
int child=0;
low[x]=num[x]=++dfn;
for(int i=head[x];i;i=ed[i].next){
int t=ed[i].to;
if(!num[t]){
tarjin(t,fa);
low[x]=min(low[x],low[t]);
if(low[t]>=num[x]&&x!=fa){ //被作为割点的次数
cut[x]++;
}
if(x==fa) child++; //根节点的孩子数
}
else low[x]=min(low[x],num[t]);
}
if(x!=fa&&cut[x]) cut[x]++; //这个节点消失后上面的fa也会变成1个连通块
if(x==fa&&child>=2) cut[x]+=child;
//加上孩子
}
int main(){
while(1){
scanf("%d %d",&n,&m);
if(n==0&&m==0) break;
if(m==0){
printf("%d\n",n-1);
continue;
}
memset(cut,0,sizeof(cut));
memset(low,0,sizeof(low));
memset(num,0,sizeof(num));
memset(head,0,sizeof(head));
memset(ed,0,sizeof(ed));
dfn=0;
ans=0;
cnt=0;
for(int i=1;i<=m;i++){
int x,y;
scanf("%d %d",&x,&y);
adde(++x,++y); //细节
adde(y,x);
}
int temp;
for(int i=1;i<=n;i++){
if(!num[i]){
ans++;
tarjin(i,i);
}
}
temp=ans;
for(int i=1;i<=n;i++){
ans=max(ans,temp-1+cut[i]); //在所有的情况里面找最大
}
printf("%d\n",ans);
}
return 0;
}
//运行错误？？？什么鬼
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+50;
struct node{ int next, to; } edge[N<<1];
int head[N], cnt;
inline void add(int from, int to) { edge[++cnt] = (node) {head[from], to}, head[from] = cnt; }
int tot, low[N], dfn[N], cut[N];
void tarjan(int u, int fa) {
low[u] = dfn[u] = ++tot; int child = 0;
for(int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if(!dfn[v]) {
tarjan(v, fa), low[u] = min(low[u], low[v]);
if(low[v] >= dfn[u] && u != fa) cut[u] ++;
if(u == fa) child ++;
}
else low[u] = min(low[u], dfn[v]);
}
if(u != fa && cut[u]) cut[u] ++;//fa 所构成的一块
if(u == fa && child >= 2) cut[u] += child ;
}
int main() {
while(1) {
#define clear(a) memset(a, 0, sizeof a)
int n, m; cin>>n>>m;
if(n + m == 0) break;
if(m == 0) { printf("%d\n", n - 1); continue; }
clear(low), clear(cut), clear(dfn),clear(head),clear(edge);
cnt = tot = 0;
for(int i = 1, a, b; i <= m; i++) scanf("%d%d", &a, &b), add(++a, ++b), add(b, a);
int ans = 0;
for(int i = 1; i <= n; i++) if(!dfn[i]) ans ++, tarjan(i, i);
int temp = ans;
for(int i = 1; i <= n; i++) ans = max(ans, temp - 1 + cut[i]);
printf("%d\n", ans);
}
return 0;
}
1526：Blockade
yteotia 城市有 n 个城镇，m 条双向道路。每条道路连接两个不同的城镇，没有重复的道路，所有城镇连通。
输出 n个数，代表如果把第 i 个点去掉，将有多少对点不能互通。
输入 n,m 及 m 条边。
输出 n 个数，代表如果把第 i 个点去掉，将有多少对点不能互通。
点无非分为两种
割点 & 非割点
根据题目可得 , 对于非割点答案显然是
ans = (n - 1) * 2;
那么对于割点怎么处理答案呐？
把她分成两部分处理
对于一个点 fa
他的所有子树（搜索树中）的 size 互相乘起来 , 因为子树间互相断开不能联系
然后把所有子树的 size 加起来得 sum , 然后 ans += sum * (n - sum - 1) , 因为所有的子树都无法与外界联系
因为不算 fa 本身 , 所以是 (n - sum - 1) 而非 (n - sum)
但是对于一个点对 (a, b) 断开了显然有 (b, a) 也断开
我们只处理了一个 , 所以最后要把答案乘二
最后对于割点也要再加上 (n - 1) * 2 来处理上文没有处理的 fa 的情况
实在不懂，就画个图，画图比较好理解
/*
点无非分为两种
割点 & 非割点
根据题目可得 , 对于非割点答案显然是
ans = (n - 1) * 2;
那么对于割点怎么处理答案呐？
把她分成两部分处理
对于一个点 fa
他的所有子树（搜索树中）的 size 互相乘起来 , 因为子树间互相断开不能联系
然后把所有子树的 size 加起来得 sum , 然后 ans += sum * (n - sum - 1) , 因为所有的子树都无法与外界联系
因为不算 fa 本身 , 所以是 (n - sum - 1) 而非 (n - sum)
但是对于一个点对 (a, b) 断开了显然有 (b, a) 也断开
我们只处理了一个 , 所以最后要把答案乘二
最后对于割点也要再加上 (n - 1) * 2 来处理上文没有处理的 fa 的情况
*/
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=1e5+10;
const int INF=0x3fffffff;
typedef long long LL;
int head[maxn];
//https://blog.csdn.net/weixin_30274627/article/details/97911416
//我要气哭了，为什么还是错的
struct node{
int to,next;
}ed[maxn*10];
int n,m;
int ans[maxn],num[maxn],size[maxn],low[maxn],cut[maxn];
int cnt,dfn;
void adde(int x,int y){
ed[++cnt].to=y;
ed[cnt].next=head[x];
head[x]=cnt;
}
void tarjin(int u){
low[u]=num[u]=++dfn;
// printf("%d\n",u);
int child=0;
size[u]=1; //大小
int tot=0;
for(int i=head[u];i;i=ed[i].next){ //妈了个鸡
int v=ed[i].to;
if(!num[v]){
tarjin(v);
size[u]+=size[v];
low[u]=min(low[u],low[v]);
if(low[v]>=num[u]){
tot+=size[v];
ans[u]+=1ll*size[v]*(n-size[v]); //他的每个子树和其他节点的对数
if(u!=1||++child>1){
cut[u]=1;//是割点
}
}
}
else low[u]=min(low[u],num[v]);
}
if(cut[u]){
ans[u]+=1ll*(tot+1)*(n-tot-1)+(n-1); //莫法，画图理解
}
else ans[u]=2*(n-1);
}
int main(){
scanf("%d %d",&n,&m);
for(int i=1;i<=m;i++){
int x,y;
scanf("%d %d",&x,&y);
adde(x,y);
adde(y,x);
}
//不用循环，以为整个图是联通的
tarjin(1);
for(int i=1;i<=n;i++) printf("%lld\n",ans[i]);
return 0;
}
#include<string>
#include<cstdio>
#include<cstring>
#define RG register
#define IL inline
#define LL long long
#define DB double
using namespace std;
const int N=1e5+10;
const int M=1e6+10;
LL ans[N];
int n,m,Time,tot,head[N],dfn[N],low[N],size[N],cut[N];
struct EDGE{int next,to;}e[M];
IL void make(int x,int y) {
e[++tot]=(EDGE){head[x],y},head[x]=tot;
e[++tot]=(EDGE){head[y],x},head[y]=tot;
}
void Tarjan(int x) {
int i,y,summ=0,cnt=0;
dfn[x]=low[x]=++Time;
size[x]=1;
for (i=head[x];i;i=e[i].next) {
y=e[i].to;
if (!dfn[y]) {
Tarjan(y);
size[x]+=size[y];
low[x]=min(low[x],low[y]);
if (low[y]>=dfn[x]) {
summ+=size[y];
ans[x]+=1ll*size[y]*(n-size[y]);
if (x!=1||++cnt>1) cut[x]=1;
}
}
else low[x]=min(low[x],dfn[y]);
}
if (cut[x]) ans[x]+=1ll*(summ+1)*(n-summ-1)+(n-1);
else ans[x]=2*(n-1);
}
int main()
{
int i,x,y;
scanf("%d %d",&n,&m);
for (i=1;i<=m;++i){
scanf("%d %d",&x,&y);
make(x,y);
}
Tarjan(1);
for (i=1;i<=n;++i) printf("%lld\n",ans[i]);
return 0;
}