|每删一个节点计算块数,判断连通性|L2-013 红色警报 （25 分)

天梯 并查集
link
Red Alert
一步步攻占，一个城市一个城市攻占
【解题思路】

每一次都要重新判断一下需要连接的道路变化有无影响

有影响的情况比较难找，那就直接先判断没有影响的情况

就是等于前集合数目等于现集合数目或原集合数目+1等于现集合数目（因为题意，若该国本来就不完全连通，是分裂的k个区域，而失去一个城市并不改变其他城市之间的连通性，则不要发出警报）

这样即使去掉当前结点也无碍

如果连通块数组不变或者减1（原来就是孤立得一个），说明图连通块数目不受影响

如果连通块数目增加了1，则说明连通块加1，图中连通性受到影响

    for(int i=0;i<m;i++){
        //城市的编号从0开始
        int a,b;
        cin>>a>>b;
        road[i].a=a;
        road[i].b=b;//1条路的2端的节点分别是a和b
        Union(a,b);//并查集
    }
    int cnt=0;//记录原来的连通块的个数
    for(int i=0;i<n;i++){
        // if(isRoot[i]!=0)
        //     cnt++;
        if(father[i]==i)cnt++;
    }
    
    for(int i=0;i<k;i++){
        int city;
        cin>>city;
        lost[city]=1;//标记该city已经被攻占
        init(n);//已经得到了 原来的连通块的个数,可以进行下一步了，删除一个，再计算，比较
        //memset(isRoot,0,sizeof(isRoot));//isRoot也进行重生
        
    
    
        for(int j=0;j<m;j++){//关系数//每一段关系都去比较
            if(lost[road[j].a]==0&&lost[road[j].b]==0)//只有2个端点都没有被攻占的路才能实现联通
                Union(road[j].a,road[j].b);
        }
          //计算每攻占1个城市后的联通块数，进行比较
        int cnt1=0;//每攻占1个城市后的联通块数
        for(int j=0;j<n;j++){
            if(father[j]==j&&lost[j]==0)//根节点并且没有被攻占---》没有被攻占的组数/块数
                cnt1++;
    }

if(cnt1==cnt||cnt1+1==cnt)printf("City %d is lost.\n",city);
    else printf("Red Alert: City %d is lost!\n",city);
    if(cnt1==0)
        printf("Game Over.\n");
        
        cnt=cnt1;
    }

//输入
//第一行 n,m----城市个数(编号从0开始)----连接2城市的通路条数
//随后m行，一条道路所连接的城市编号
/*
5 4
0 1
1 3
3 0
0 4
5
1 2 0 4 3
*/
//K ----被攻占的城市的数目
//5
//K个被攻占的城市的编号
//1 2 0 4 3

/*---------
City 1 is lost.
City 2 is lost.
Red Alert : City 0 is lost!
City 4 is lost.
City 3 is lost.
Game Over.
*/

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int n,m;
int father[10010];
int isRoot[10010]={0};
int lost[10010]={0};

struct Road{
    int a,b;//连接1条路的2个端点a,b
}road[10010];

void init(int n){
    for(int i=0;i<n;i++)
        father[i]=i;
}


int findFather(int i){
    if(father[i]==i)return i;
    else{
        int F=findFather(father[i]); 
        father[i]=F;
        return F;
    }
}

void Union(int a,int b){
    int faA=findFather(a);
    int faB=findFather(b);
    if(faA!=faB)father[faA]=faB;
}

int main()
{   
    cin>>n>>m;//5 4
    init(n);
// 0 1
// 1 3
// 3 0
// 0 4
    for(int i=0;i<m;i++){
        //城市的编号从0开始
        int a,b;
        cin>>a>>b;
        road[i].a=a;
        road[i].b=b;//1条路的2端的节点分别是a和b
        Union(a,b);//并查集
    }
    
    //先吸收 被攻占的城市的编号
    int k;
    cin>>k;
    
    // //计算原来的连通块的个数，方便与后面每攻占1个城市后的联通块数，进行比较
    // for(int i=0;i<n;i++){//城市的编号从0开始
    //     isRoot[findFather(i)]++;  //标记根节点(每个组的标志)不为0  
    // }
    
    int cnt=0;//记录原来的连通块的个数
    for(int i=0;i<n;i++){
        // if(isRoot[i]!=0)
        //     cnt++;
        if(father[i]==i)cnt++;
    }
    
    

    for(int i=0;i<k;i++){
        int city;
        cin>>city;
        lost[city]=1;//标记该city已经被攻占
        init(n);//已经得到了 原来的连通块的个数,可以进行下一步了，删除一个，再计算，比较
        //memset(isRoot,0,sizeof(isRoot));//isRoot也进行重生
        
        for(int j=0;j<m;j++){//关系数//每一段关系都去比较
            if(lost[road[j].a]==0&&lost[road[j].b]==0)//只有2个端点都没有被攻占的路才能实现联通
                Union(road[j].a,road[j].b);
        }
        
         //计算每攻占1个城市后的联通块数，进行比较
        int cnt1=0;//每攻占1个城市后的联通块数
        for(int j=0;j<n;j++){
            if(father[j]==j&&lost[j]==0)//根节点并且没有被攻占---》没有被攻占的组数/块数
                cnt1++;
    }
    
    if(cnt1==cnt||cnt1+1==cnt)printf("City %d is lost.\n",city);
    else printf("Red Alert: City %d is lost!\n",city);
    if(cnt1==0)
        printf("Game Over.\n");
        
        cnt=cnt1;
    }
    return 0;
}

-----------------
#include <cstdio>
#include <iostream>
using namespace std;
int father[10010];
int lost[10010] = { 0 };//被攻占的城市标记为1，初始化都为0，没有被攻占
int isRoot[10010] = { 0 };

struct Road {
	int a, b;//1条路的2个端口
}road[10010];

void init(int n) {
	for (int i = 0; i <n; i++) {
		father[i] = i;
	}
}

int findFather(int i) {
	if (father[i] == i)return i;
	else {
		int F=findFather(father[i]);
		father[i]=F;
		return F;
	}
}
void Union(int a,int b) {
	int faA = findFather(a);
	int faB = findFather(b);
	if (faA != faB)father[faA] = faB;
}
int main() {
	int n, m, k;
	scanf_s("%d%d", &n, &m);
	init(n);
	for (int i = 0; i < m; i++) {//第i条有关系的路
		int a, b;
		scanf_s("%d%d", &a, &b);
		road[i].a = a;
		road[i].b = b;
		Union(a, b);
	}
	//cout << "ok";
	scanf_s("%d", &k);
/*
	int cnt = 0;
	for (int i = 0; i < n; i++) {
		if (father[i] == i)
			cnt++;
	}
*/
//人的编号从1开始
	for (int i = 1; i <= n; i++) {
		//isRoot[father[i]] = true;//i的根节点是findFather(i)-已经压缩路径了
		isRoot[findFather(i)]++;
	}
	//int ans = 0;//记录集合的数目
	int cnt = 0;
	for (int i = 1; i <= n; i++) {
		if (isRoot[i] != 0) {
			cnt++;
		}
	}
	for (int i = 0; i < k; i++) {//1 2 0 4 3
		int city;
		cin>>city;
		init(n);//???????//归0
		lost[city] = 1;

		for (int j=0; j < m; j++) {//关系数
			if (lost[road[j].a]==0 && lost[road[j].b] == 0)//给出的某1有关系的路的2个端口，都没有被攻占
				Union(road[j].a, road[j].b);
		}

		int cnt1 = 0;//攻占后,完好的块数
		for (int j = 0; j < n; j++) {
			if (father[j] == j && lost[j] == 0) {//没被攻占的根节点的个数//没被全部打下来的块数
				cnt1++;
			}
		}
		if(cnt1+1==cnt||cnt1==cnt)printf("City %d is lost.\n", city);
		else printf("Red Alert: City %d is lost!\n", city);
		if (cnt1 == 0)cout << "Game Over.\n";//根节点全部被打下来了
		
		cnt = cnt1;
	}
	return 0;
}