《重拾算法》02 广度优先搜索_b,b不一定认识a。现在我们把所有人从1到n编号,给出所有“认识”关系,问如果i发布-CSDN博客

本文链接：https://blog.csdn.net/RileGoule/article/details/88730619

《重拾算法》01 广度优先搜索

宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

百度百科是这样讲的宽搜，实际上我们第一次接触BFS是再二叉树的层次遍历里。下面用几个例子来说明这个非常高效的算法

1 CODEVS 1506 传话

题目

题目描述 Description
一个朋友网络，如果a认识b，那么如果a第一次收到某个消息，那么会把这个消息传给b，以及所有a认识的人。

如果a认识b，b不一定认识a。

所有人从1到n编号，给出所有“认识”关系，问如果i发布一条新消息，那么会不会经过若干次传话后，这个消息传回给了i，1<=i<=n。

输入描述 Input Description
第一行是n和m，表示人数和认识关系数。

接下来的m行，每行两个数a和b，表示a认识b。1<=a, b<=n。认识关系可能会重复给出，但一行的两个数不会相同。

样例输入 Sample Input
4 6

1 2

2 3

4 1

3 1

1 3

2 3

样例输出 Sample Output
T

T

T

F

分析

拿到这个题的样例数据，随手一画发现是个图，当然结合我们这章的主题，肯定是宽度优先算法了。那么首先要做的事情呢，就是建图。我们可以采用动态数组的方式来创建这个图，以达到节省空间的目的。
随后我们就要考虑如何建图，显然我们可以使用一个二维数组来表示，以列坐标表示人编号，行坐标表示他认识的人。
在之后我们就要利用队列设置广度优先递归搜索树。

/*
codevs 1056 传话 
*/ 

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int maxn = 1000+5;
int n,m; //n people m relative
int bfrom[maxn],bto[maxn];
int map[maxn][maxn]={0};
int mapq[maxn][maxn]={0};
queue<int> q;

void clear(queue<int>& q)
{
	queue<int> empty;
	swap(empty,q);
}

bool bfs(int pn,int targ) //pn means person number
{

	for(int i=1;i<=n;i++)
	{
		if(mapq[pn][i]==1)
			q.push(i);
			mapq[pn][i]=0;
	}
	if(q.empty()) return false;
	int front = q.front();
	q.pop();
	if(front == targ)return true;
	return	bfs(front,targ);
}

int main()
{

	cin>>n>>m;
//	int** map = new int*[n];
//	for(int i=0;i<n;i++){
//		map[i] = new int[n]
//	}
	for(int i=0;i<m;i++)
	{
		int a,b;
		cin>>a>>b;
		map[a][b]=1;
	}
	for(int i=1;i<=n;i++)
	{
		clear(q);
		memcpy(mapq,map,sizeof(map));
		if(bfs(i,i))cout<<"T"<<endl;
		else cout<<"F"<<endl;
	}
//	for(int i=0; i<n; i++) {
//  		delete[] map[i];
//	 }
//	delete[] map;
	return 0;
}

收获

【二级指针动态数组参考资料】
清空队列的方法：

void clear(queue<int>& q)
{
	queue<int> empty;
	swap(empty,q);
}

队列的基本用法

基本操作：

push(x) 将x压入队列的末端

pop() 弹出队列的第一个元素(队顶元素)，注意此函数并不返回任何值

front() 返回第一个元素(队顶元素)

back() 返回最后被压入的元素(队尾元素)

empty() 当队列为空时，返回true

size() 返回队列的长度

 
使用方法：
头文件：
#include <queue>

 声明方法：
1、普通声明
queue<int>q;
2、结构体
struct node
{    
   int x, y;
};
queue<node>q;
 
 
 
STL 中优先队列的使用方法(priority_queu)

优先队列容器与队列一样，只能从队尾插入元素，从队首删除元素。但是它有一个特性，就是队列中最大的元素总是位于队首，所以出队时，并非按照先进先出的原则进行，而是将当前队列中最大的元素出队。这点类似于给队列里的元素进行了由大互小的顺序排序。元素的比较规则默认按元素值由大到小排序，可以重载“<”操作符来重新定义比较规则。　　

基本操作：

empty() 如果队列为空返回真

pop() 删除对顶元素

push() 加入一个元素

size() 返回优先队列中拥有的元素个数

top() 返回优先队列对顶元素

在默认的优先队列中，优先级高的先出队。在默认的int型中先出队的为较大的数。

使用方法：

头文件：

#include <queue>
 
声明方式：

1、普通方法：

priority_queue<int>q;   //通过操作，按照元素从大到小的顺序出队
priority_queue<int,vector<int>, greater<int> >q;  //通过操作，按照元素从小到大的顺序出队
2、自定义优先级：

struct cmp {     
　　operator bool ()(int x, int y)     
　　{        
　　　　 return　x > y; // x小的优先级高       //也可以写成其他方式，如： return p[x] > p[y];表示p[i]小的优先级高
　　}
};
priority_queue<int, vector<int>, cmp>q;    //定义方法
//其中，第二个参数为容器类型。第三个参数为比较函数。
 
3、结构体声明方式：

struct node {     
　　int x, y;     
　　friend bool operator < (node a, node b)     
　　{         
　　　　return a.x > b.x;    //结构体中，x小的优先级高     
　　}
};
priority_queue<node>q;   //定义方法
//在该结构中，y为值, x为优先级。
//通过自定义operator<操作符来比较元素中的优先级。
//在重载”<”时，最好不要重载”>”，可能会发生编译错误