蓝桥杯之图论、广度优先、深度优先

图的表示、图的遍历

[7.1 深度优先]

求连通性

给定一个方阵，定义连通：上下左右相邻，并且值相同。
可以想象成一张地图，不同的区域被涂以不同颜色。
输入：
整数N, (N<50)表示矩阵的行列数
接下来N行，每行N个字符，代表方阵中的元素
接下来一个整数M，(M<1000)表示询问数
接下来M行，每行代表一个询问，
格式为4个整数，y1,x1,y2,x2，
表示(第y1行,第x1列) 与 (第y2行,第x2列) 是否连通。
连通输出true，否则false

例如：
10
0010000000
0011100000
0000111110
0001100010
1111010010
0000010010
0000010011
0111111000
0000010000
0000000000
3
0 0 9 9
0 2 6 8
4 4 4 6

程序应该输出：
false
true
true

思路：
深度优先，即从某一个格子出发，先选定一个方向，然后这个方向一直走下去，在每一步都重复上一部的动作，当到达最后一步时，再返回来朝其他方向走，最后走完每一步。由于时求连通性，即找到一条通路，就可以不再继续往下递归了，使用深度优先很实用。

代码：

#include

int dfs(int a[50][50],int n,int y1,int x1,int y2,int x2){
	
	if(x1==x2&&y1==y2) return 1;
	
	int old=a[y1][x1];
	a[y1][x1]=-1;
	
	int flag=0;
	if(y1>0&&a[y1-1][x1]==old&&dfs(a,n,y1-1,x1,y2,x2)) flag=1;
	if(y10&&a[y1][x1-1]==old&&dfs(a,n,y1,x1-1,y2,x2)) flag=1;
	if(x1

-------------------------------------------

[7.2 广度优先]

迷宫问题、最短路径

...11111111111111111111111111111
11.111111........1111111111.1111
11.111111..111.11111111.....1111
11.11111111111.1111111111.111111
11.111111.................111111
11.111111.11111111111.11111.1111
11.111111.11111111111.11111..111
11..........111111111.11111.1111
11111.111111111111111.11....1111
11111.111111111111111.11.11.1111
11111.111111111111111.11.11.1111
111...111111111111111.11.11.1111
111.11111111111111111....11.1111
111.11111111111111111111111.1111
111.1111.111111111111111......11
111.1111.......111111111.1111.11
111.1111.11111.111111111.1111.11
111......11111.111111111.1111111
11111111111111.111111111.111...1
11111111111111...............1.1
111111111111111111111111111111..

如上图的迷宫，入口，出口分别：左上角，右下角
"1"是墙壁，"."是通路
求最短需要走多少步？

思路：

代码：

#include

typedef struct mypoint{
	int x,y,pre;
}point;
int front=0,tail=0;
point queue[1024];
	
char a[21][32];


void enqueue(point p){
	queue[tail++]=p;
}
point dequeue(){
	return queue[front++];
}
int isempty(){
	return tail==front;
}


void visit(int x,int y){
	point visit_point = {x,y,front-1};
	a[x][y]='*';
	enqueue(visit_point);
}


void print(int xlen,int ylen){
	for(int i=0;i<=xlen;i++){
			for(int j=0;j<=ylen;j++){
				printf("%c",a[i][j]);
			}
			printf("\n");
		}
		printf("\n");
}
void printPath(point p){
	
	if(p.pre==-1){
		return;
	}
	p=queue[p.pre];
	printPath(p);
	printf("(%d,%d)\n",p.x,p.y);
	
} 


int bfs(int startx,int starty,int xlen,int ylen){
	
	point start={startx,starty,-1};	
	visit(start.x,start.y);
	
	while(!isempty()){
		start=dequeue();
		if(start.x==xlen&&start.y==ylen){
			break;
		}
		
		if(start.y+1<=ylen&&a[start.x][start.y+1]=='.'){	//right
			visit(start.x,start.y+1);
		}
		
		if(start.x+1<=xlen&&a[start.x+1][start.y]=='.'){	//bottom
			visit(start.x+1,start.y);
		}
		
		if(start.x-1>=0&&a[start.x-1][start.y]=='.'){	//top
			visit(start.x-1,start.y);
		}
		
		if(start.y-1>=0&&a[start.x][start.y-1]=='.'){	//left
			visit(start.x,start.y-1);
		}
		
	}
	
	if(start.x==xlen&&start.y==ylen){
		int sum=1;
		point tmp = {start.x,start.y,start.pre};
		
		while(start.pre!=-1){
			start=queue[start.pre];
			sum++;
		}
		
		printf("%d\n",sum);
		
		//printPath(tmp);
		
	}else{
		printf("No Path !\n");
	}
	
}


int main(){
	freopen("data.in","r",stdin);
	
	for(int i=0;i<21;i++){
		char t[33];
		scanf("%s",&t);
		for(int j=0;j<32;j++){
			a[i][j]=t[j];
		}		
	}	
	
	print(20,31);	
	bfs(0,0,20,31);
	
	return 0;	
}

-------------------------------------------

分酒问题

有4个红酒瓶子，它们的容量分别是：9升, 7升, 4升, 2升  
开始的状态是 [9,0,0,0]，也就是说：第一个瓶子满着，其它的都空着。

允许把酒从一个瓶子倒入另一个瓶子，但只能把一个瓶子倒满或把一个瓶子倒空，不能有中间状态。
这样的一次倒酒动作称为1次操作。

假设瓶子的容量和初始状态不变，对于给定的目标状态，至少需要多少次操作才能实现？
本题就是要求你编程实现最小操作次数的计算。
 
输入：最终状态（空格分隔）
输出：最小操作次数（如无法实现，则输出-1）

例如：
输入：
9 0 0 0
应该输出：
0

输入：
6 0 0 3
应该输出：
-1

输入：
7 2 0 0
应该输出：
2

思路：

代码：

#include

typedef struct {
	int v[4]={0};
	int pre;
}node;

node q[1000];
int head=0,tail=0;
int full[4]={9,7,4,2};
int vis[10][8][5][3]={0};

void enqueue(node n){
	q[tail++]=n;
}


node dequeue(){
	return q[head++];
}

void pour(node n,int x,int y){
	
	if(n.v[x]==n.v[y]) return;
	if(n.v[x]==0) return;
	if(n.v[y]==full[y]) return;
	
	if(n.v[x]+n.v[y]<=full[y]){
		n.v[y]=n.v[x]+n.v[y];
		n.v[x]=0;
	}else{
		n.v[x]=n.v[x]-(full[y]-n.v[y]);
		n.v[y]=full[y];
	}
	
	n.pre=head-1;
	
	if(vis[n.v[0]][n.v[1]][n.v[2]][n.v[3]]){
	}else{
		vis[n.v[0]][n.v[1]][n.v[2]][n.v[3]]=1;
		enqueue(n);
	}	
	return;
}
int equal(int a[4],int b[4]){
	int flag=1;
	for(int i=0;i<4;i++){
		if(a[i]!=b[i]){
			flag=0;
		}
	}
	return flag;
}
int empty(){
	return head==tail;
}

int bfs(int target[4]){
	
	node start_node;
	start_node.v[0]=9;
	start_node.v[1]=0;
	start_node.v[2]=0;
	start_node.v[3]=0;
	start_node.pre=-1;
	vis[9][0][0][0]=1;
	enqueue(start_node);
	node tmp;
	while(!empty()){
		
		tmp=dequeue();
		
		if(equal(tmp.v,target)){
			break;
		}
		
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				pour(tmp,i,j);
			}
		}
		
	}
	
	if(equal(tmp.v,target)){
		int sum=0;


		while(tmp.pre!=-1){
			tmp=q[tmp.pre];
			sum++;
		}
		
		printf("%d\n",sum);
	}else{
		printf("%d\n",-1);
	}
}


int main(){
	int a[4]={0};
	scanf("%d%d%d%d",&a[0],&a[1],&a[2],&a[3]);
		
	bfs(a);
	return 0;
}

-------------------------------------------

[7.3 生成树]

标题：风险度量

X星系的的防卫体系包含 n 个空间站。这 n 个空间站间有 m 条通信链路，构成通信网。
两个空间站间可能直接通信，也可能通过其它空间站中转。

对于两个站点x和y (x != y), 如果能找到一个站点z，使得：
当z被破坏后，x和y不连通，则称z为关于x,y的关键站点。

显然，对于给定的两个站点，关于它们的关键点的个数越多，通信风险越大。

你的任务是：已经网络结构，求两站点之间的通信风险度，即：它们之间的关键点的个数。

输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，链路数。
空间站的编号从1到n。通信链路用其两端的站点编号表示。
接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条链路。
最后1行，两个数u,v，代表被询问通信风险度的两个站点。

输出：一个整数，如果询问的两点不连通则输出-1.

例如：
用户输入：
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6
则程序应该输出：
2

思路：
通过深度优先的方法，找到所有x到达y的路径，将每次每个点被经过的次数记录下来，最后，寻找经过次数和路径数相同的点，就是割点。

代码：

#include

int a[10001][10001]={0};
int vis[10001]={0};
long count[10001]={0};
int routs=0,m;
int x,y;


void dfs(int x){
	if(x==y){
		routs++;
		for(int i=1;i<=m;i++){
			if(vis[i]){
				count[i]++;
			}
		}
		
		return;
	}
	
	for(int i=1;i<=m;i++){
		if(a[x][i]&&!vis[i]){
			vis[i]=1;
			dfs(i);
			vis[i]=0;
		}
	}
}

int countSp(){
	int c=0;
	for(int i=1;i<=m;i++){
		if(count[i]==routs&&i!=x&&i!=y){
			c++;
		}
	}
	return c;
}

int main() {
	freopen("data.in","r",stdin);
	int n;
	scanf("%d%d",&m,&n);
	
	for(int i=0;i

-------------------------------------------

[7.4 线段树]

一大堆线段，求有效覆盖长度

标题：油漆面积

X星球的一批考古机器人正在一片废墟上考古。
该区域的地面坚硬如石、平整如镜。
管理人员为方便，建立了标准的直角坐标系。

每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。
经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。

矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。

为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。
小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。

其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。
注意，各个矩形间可能重叠。

本题的输入为若干矩形，要求输出其覆盖的总面积。

输入格式：
第一行，一个整数n，表示有多少个矩形(1<=n<10000)
接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。
(0<= x1,y1,x2,y2 <=10000)

输出格式：
一行一个整数，表示矩形覆盖的总面积。

例如，
输入：
3
1 5 10 10
3 1 20 20
2 7 15 17

程序应该输出：
340

再例如，
输入：
3
5 2 10 6
2 7 12 10
8 1 15 15

程序应该输出：
128

思路：

2. x排序，切分，每个条形累计面积

代码：

#include
#include

using namespace std;

typedef struct myseg{
	int l,r,h,d;
	myseg(){}
	myseg(int l,int r,int h,int d):l(l),r(r),h(h),d(d){}	
	bool operator<(const myseg &s){
		return hm) update(L,R,m+1,r,rt*2+1,val);
	pushdown(l,r,rt);
	
}


int main(){
	freopen("data.in","r",stdin);
	int n,k=0;
	scanf("%d",&n);
	
	for(int i=0;i

-------------------------------------------

[7.5 并查集]

一个图中，因为连通性分成多个集团，快速求两个节点间的连通性

从某个点开始，dfs建立生成树...
剩下的点再建....
是否连通就是生成树根节点是否相同的问题

标题：合根植物

w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？

输入格式：
第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1接下来一行，一个整数k，表示下面还有k行数据(0接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。

格子的编号一行一行，从上到下，从左到右编号。
比如：5 * 4 的小格子，编号：
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16
17 18 19 20

样例输入：
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17

样例输出：
5

其合根情况参考图[1.png]

思路：

代码：

#include

int a[1000*1000+1]={0}; 
int count=0;

int find(int n){
	if(a[n]==0){
		return n;
	}
	return a[n]=find(a[n]);	//并査集核心代码
}

void g(int x,int y){
	int p,q;
	if((p=find(x))!=(q=find(y))){
		a[p]=q;
		count++;
	}
	return;
}

int main(){
	int m,n;
	scanf("%d%d",&m,&n);
	int k;
	scanf("%d",&k);
	for(int i=0;i

------------------------------------------

[7.6 作业]

青蛙跳杯子

X星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。
X星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。
如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。

*WWWBBB

  其中，W字母表示白色青蛙，B表示黑色青蛙，*表示空杯子。

  X星的青蛙很有些癖好，它们只做3个动作之一：
  1. 跳到相邻的空杯子里。
  2. 隔着1只其它的青蛙（随便什么颜色）跳到空杯子里。
  3. 隔着2只其它的青蛙（随便什么颜色）跳到空杯子里。

  对于上图的局面，只要1步，就可跳成下图局面：

WWW*BBB

本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。

输入为2行，2个串，表示初始局面和目标局面。
输出要求为一个整数，表示至少需要多少步的青蛙跳。

例如：
输入：
*WWBB
WWBB*

则程序应该输出：
2

再例如，
输入：
WWW*BBB
BBB*WWW

则程序应该输出：
10

我们约定，输入的串的长度不超过15

----------------------------


笨笨有话说：
    我梦见自己是一棵大树，
    青蛙跳跃，
    我就发出新的枝条，
    春风拂动那第 5 层的新枝,
    哦，我已是枝繁叶茂。