DS红色警报

题目描述

战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序，当失去一个城市导致国家被分裂为多个无法连通的区域时，就发出红色警报。注意：若该国本来就不完全连通，是分裂的k个区域，而失去一个城市并不改变其他城市之间的连通性，则不要发出警报。

输入

输入在第一行给出两个整数N（0 < N ≤ 500）和M（≤ 5000），分别为城市个数（于是默认城市从0到N-1编号）和连接两城市的通路条数。随后M行，每行给出一条通路所连接的两个城市的编号，其间以1个空格分隔。在城市信息之后给出被攻占的信息，即一个正整数K和随后的K个被攻占的城市的编号。

注意：输入保证给出的被攻占的城市编号都是合法的且无重复，但并不保证给出的通路没有重复。

输出

对每个被攻占的城市，如果它会改变整个国家的连通性，则输出Red Alert: City k is lost!，其中k是该城市的编号；否则只输出City k is lost.即可。如果该国失去了最后一个城市，则增加一行输出Game Over.。

输入样例1

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

输出样例1

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

NOTICE：

事先声明，这道题虽然能AC，但是算法实现很烂;

这道题我们需要解决的问题是，判断什么时候需要发出警报，即城市连通性发生改变；我采取的算法是，看孤立结点数是否增加（被攻占的城市不算在其中）；如果孤立结点数增加，则说明连通性发生改变，否则，连通性不改变；

稀烂：首先是算法本身，通过孤立结点数的改变来判断连通性的改变有漏洞（1——2——3——4——5四个城市像这样依次连成一条线，如果3被攻陷，则被割裂成两部分1——2、4——5，连通性发生改变，但是孤立结点数保持0不变）；正确的算法应该是，进行图的遍历，数有多少个连通分量，看前后数量是否变化，简单直接明了；其次是算法实现：用邻接表来实现的话真的太麻烦了，又是指针又是定义新的结点类，很复杂，最好是用邻接矩阵实现；

#include <iostream>
using namespace std;

class EdgeNode
{
private:
	int adjvex;
	EdgeNode* next;
public:
	EdgeNode():adjvex(-1),next(nullptr){}
	friend class Graph;
};

class VertexNode
{
private:
	int flag;//该节点是否被删除（是否存在）
	EdgeNode* firstedge;
public:
	VertexNode():firstedge(nullptr),flag(1) {}
	friend class Graph;
};

//记得重置
int Nodenum;//孤立结点数

class Graph
{
private:
	int vertexnum;
	int edgenum;
	VertexNode* vertex;
public:
	Graph()
	{
		cin >> vertexnum >> edgenum;
		vertex = new VertexNode[vertexnum];
		for (int i = 0; i < edgenum; i++)
		{
			int num1, num2;
			cin >> num1 >> num2;

			//类似没有头结点的单链表的尾插法
			EdgeNode* p = new EdgeNode;
			p->adjvex = num2;

			if (vertex[num1].firstedge == nullptr)
			{
				vertex[num1].firstedge = p;
			}
			else
			{
				EdgeNode* q = vertex[num1].firstedge;
				while (1)
				{
					if (q->next == nullptr)
					{
						q->next = p;
						break;
					}
					q = q->next;
				}
			}
		}
		//计算一开始时孤立结点数
		Nodenum = 0;
		for (int i = 0; i < vertexnum; i++)
		{
			int tag = 0;
			for (int j = 0; j < vertexnum; j++)
			{
				if (vertex[j].flag == 1)
				{
					EdgeNode* p = vertex[j].firstedge;
					while (p != nullptr)
					{
						if (p->adjvex == i)
						{
							tag = 1;
							break;
						}
						p = p->next;
					}
					if (tag == 1)
						break;
				}
				
			}
			if (tag == 0)
				Nodenum++;
		}
	}
	~Graph()
	{
		delete[]vertex;
	}
	void Delete(int num)//把有关该城市的信息全部删除
	{
		//先把相应的EdgeNode删除
		for (int i = 0; i < vertexnum; i++)
		{
			if (vertex[i].flag == 1)
			{
				EdgeNode* p = vertex[i].firstedge;
				EdgeNode* q=nullptr;//指向被删除结点的前一个结点
				while (p != nullptr)
				{
					if (p->adjvex == num)//找到相应的EdgeNode
					{
						if (p == vertex[i].firstedge)
						{
							vertex[i].firstedge = p->next;
							delete p;
							break;
						}
						else
						{
							q->next = p->next;
							delete p;
							break;
						}
					}
					q = p;
					p = p->next;
				}
			}
		}
		//再把VertexNode删除
		vertex[num].flag = 0;//标志置零相当于删除
	}
	int ifChange()//判断连通性是否发生变化
	{
		int cnt = 0;
		for (int i = 0; i < vertexnum; i++)
		{
			if (vertex[i].flag == 0)
				continue;

			

			int tag = 0;
			for (int j = 0; j < vertexnum; j++)
			{
				if (vertex[j].flag == 1)
				{
					EdgeNode* p = vertex[j].firstedge;
					while (p != nullptr)
					{
						if (p->adjvex == i||vertex[i].firstedge!=nullptr)
						{
							tag = 1;
							break;
						}
						p = p->next;
					}
					if (tag == 1)
						break;
				}
				
			}
			if (tag == 0)
				cnt++;
		}
		if (cnt > Nodenum)
		{
			Nodenum = cnt;
			return 1;
		}
		else
		{
			Nodenum = cnt;
			return 0;
		}
	}
	int ifNull()//判断是否失去所有的城市
	{
		for (int i = 0; i < vertexnum; i++)
		{
			if (vertex[i].flag == 1)
				return 0;
		}
		return 1;
	}
	void test()
	{
		int n, num;
		cin >> n;
		for (int i = 0; i < n; i++)
		{
			cin >> num;
			Delete(num);
			
			if (ifChange())
			{
				cout << "Red Alert: City " << num << " is lost!" << endl;
			}
			else
			{
				cout << "City " << num << " is lost." << endl;
			}

			if (ifNull())
			{
				cout << "Game Over." << endl;
			}
		}
	}
};

int main()
{
	Graph g;
	g.test();
	return 0;
}