广度优先

最新推荐文章于 2024-08-17 11:47:21 发布
最新推荐文章于 2024-08-17 11:47:21 发布
阅读量428 收藏
点赞数
分类专栏： C++ 学习 文章标签： CC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nana1988/article/details/28860293
版权

1） word ladder


描述
Given two words (start and end), and a dictionary, find the length of shortest transformation sequence
from start to end, such that:
• Only one leer can be changed at a time
• Each intermediate word must exist in the dictionary
For example, Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]
As one shortest transformation is ”hit” -> ”hot” -> ”dot” -> ”dog” -> ”cog”, return its length 4.
Note:
• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.



// OOD.cpp : 定义控制台应用程序的入口点。
//


#include "stdafx.h"
#include<iostream> 
#include<vector>
#include<map>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

int ladderlength(string start, string end, map<string,int> &dict)
{
	queue<string> cur;
	int length = 0;
	cur.push(start);
	string nullstring = "";
	cur.push(nullstring);
	map<string,int> visited;
	visited[start]++;

	int i,j;
    char tmpc;
	bool findsign = false;

	while(!cur.empty() && !findsign)
	{
		string curstring = cur.front();
		cur.pop();
		if(curstring == nullstring && !cur.empty())
		{
			length++;
			cur.push(nullstring);
		}
		else
		{
			for(i = 0; i < curstring.size(); i++)
			{
				for(tmpc = 'a'; tmpc <= 'z'; tmpc++)
				{
					swap(curstring[i],tmpc);
					if(curstring == end)
					{
						length++;
						findsign = true;
						return length;
					}
					if(dict.find(curstring)!=dict.end() && visited.find(curstring) == visited.end())
					{
						cur.push(curstring);
						visited[curstring]++;
					}
					swap(curstring[i],tmpc);
				}
			}
		}
	}

	if(!findsign)
		return -1;
	else
		return length;
}

int main()
{
	string start = "hit";
	string end = "cog";
	map<string, int> dict;
	string M[]={"hot","dot","dog","lot","log"};
	for(int i = 0; i < sizeof(M)/sizeof(string); i++)
	{
		dict[M[i]]++;
	}

	int r = ladderlength(start,end,dict);
    cout << "Change from "<< start << " to " << end << " needs "<<r<< " steps!"<<endl;
	system("pause");
	return 0;
}

2） word ladder ||


#include "stdafx.h"
#include<iostream> 
#include<vector>
#include<map>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

void printpath(map<string, vector<string> >father,string start,string end,vector<string> &path, vector<vector<string>> &result)
{
	if(start == end)
	{
		path.push_back(start);
		result.push_back(path);
		path.pop_back();
		return;
	}
	
	vector<string> cur = father[end];
	path.push_back(end);
	for(int i = 0; i < cur.size(); i++)
	{
		printpath(father,start,cur[i],path,result);
	}
	path.pop_back();
}

void buildpath(map<string,vector<string>> father, string start, string end)
{
	vector<string> path;
	vector<vector<string>> result;
	printpath(father,start,end,path,result);
	for(int i = 0; i < result.size(); i++)
	{
		cout << "[ ";
		for(int j = result[i].size()-1; j >= 0; j--)
			cout << result[i][j] << " ";
		cout << " ]" << endl;
	}
	return;
}

void ladderlength(string start, string end, map<string,int> &dict)
{
	queue<string> cur;
	int length = 0;
	cur.push(start);
	string nullstring = "";
	cur.push(nullstring);
	map<string,int> visited;
	map<string,vector<string>> father;
	visited[start]++;

	int i,j;
    char tmpc;
	bool findsign = false;

	while(!cur.empty())
	{
		string curstring = cur.front();
		cur.pop();
		if(curstring == nullstring && !cur.empty())
		{
			length++;
			cur.push(nullstring);
		}
		else
		{
			for(i = 0; i < curstring.size(); i++)
			{
				string prestring = curstring;
				for(tmpc = 'a'; tmpc <= 'z'; tmpc++)
				{
					swap(curstring[i],tmpc);
					if(curstring == end)
					{
						father[curstring].push_back(prestring);
						length++;
						findsign = true;
					}
					if(dict.find(curstring)!=dict.end() && visited.find(curstring) == visited.end())
					{
						father[curstring].push_back(prestring);
						cur.push(curstring);
						visited[curstring]++;
					}
					swap(curstring[i],tmpc);
				}
			}
		}
	}

	if(!findsign)
	{
		cout << " NOT FIND a path!!!"<<endl;
		return;
	}
	else
	{
		//print the result;
        cout << "find!"<<endl;
		cout << "The Dict is:------------------------ "<<endl;
		map<string, int>::iterator dictitr;

		cout << " [ ";
		for(dictitr = dict.begin();dictitr!=dict.end();dictitr++)
		{
			cout << (*dictitr).first<< " ";
		}
		cout << " ]"<< endl;
		cout << "Change From "<<start << " to " << end << " needs following ways "<<endl;

		buildpath(father,start,end);
	}
}

int main()
{
	string start = "hit";
	string end = "cog";
	map<string, int> dict;
	string M[]={"hot","dot","dog","lot","log"};
	for(int i = 0; i < sizeof(M)/sizeof(string); i++)
	{
		dict[M[i]]++;
	}

	
	ladderlength(start,end,dict);
	system("pause");
	return 0;
}

3） surrounded region

Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'. A region is captured by flipping all 'O's into 'X's in that surrounded region .
For example,
X X X X
X O O X
X X O X
X O X X
After running your function, the board should be:
X X X X
X X X X
X X X X
X O X X


#include "stdafx.h"
#include<iostream> 
#include<vector>
#include<map>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

struct position
{
	int x;
	int y;
	position(int px, int py)
	{
		x = px;
		y = py;
	}
};

void print(vector<vector<char>> &board)
{
	for(int i = 0; i < board.size(); i++)
	{
		for(int j = 0; j  <board[0].size(); j++)
		{
			cout<<board[i][j] << " ";
		}
		cout<< endl;
	}
}

bool isvalid(int x, int y, vector<vector<char>> &board)
{
	if(x < 0 || y < 0 || x >= board.size()||y >= board[0].size())
		return false;
	if(board[x][y] == '0')
		return true;
	else
		return false;
}

void SurroundRegion(vector<vector<char>>&board)
{
	cout<<"The input board is: " << endl;
	print(board);
	queue<position> zerosqueue;
	int height,width;
	height = board.size();
	width = board[0].size();
	position tmp(-1,-1);
	int i,j;
	for( i = 0; i < height; i++)
	{
		if(board[i][0] == '0')
		{
			tmp = position(i,0);
			zerosqueue.push(tmp);
		}
		if(board[i][width-1] == '0')
		{
			tmp = position(i,width-1);
			zerosqueue.push(tmp);
		}
	}

	for( j = 0 ; j < width; j++)
	{
		if(board[0][j] == '0')
		{
			tmp  = position(0,j);
			zerosqueue.push(tmp);
		}
		if(board[height-1][j] == '0')
		{
			tmp = position(height-1, j);
			zerosqueue.push(tmp);
		}
	}
	
	while(!zerosqueue.empty())
	{
		tmp = zerosqueue.front();
		zerosqueue.pop();
		if(board[tmp.x][tmp.y] != '0')
			continue;
		board[tmp.x][tmp.y] = '#'; // visited
		if(isvalid(tmp.x-1,tmp.y,board))
		{
			zerosqueue.push(position(tmp.x-1,tmp.y));
		}
		if(isvalid(tmp.x+1,tmp.y,board))
		{
			zerosqueue.push(position(tmp.x+1,tmp.y));
		}
		if(isvalid(tmp.x,tmp.y-1,board))
		{
			zerosqueue.push(position(tmp.x,tmp.y-1));
		}
		if(isvalid(tmp.x,tmp.y+1,board))
		{
			zerosqueue.push(position(tmp.x,tmp.y+1));
		}
	}

	for(i = 0; i < height; i++)
		for(j = 0; j < width; j++)
		{
			if(board[i][j] == '#')
				board[i][j] = '0';
			else if(board[i][j] == '0')
				board[i][j] = 'X';
		}

	cout << "The final result is: "<<endl;
	print(board);
}


int main()
{
	vector<vector<char>>  board(4, vector<char>(4));
	char M[4][4] = {{'X','X','X','X'},{'X','0','0','X'},{'X','X','0','X'},{'X','0','X','X'}};

	for(int i = 0; i < 4; i++)
		board[i].assign(M[i],M[i]+4);
	SurroundRegion(board);
	system("pause");
	return 0;
}

4） 迷宫：


描述：
一个迷宫由一个 01 矩阵表示，每个单元格要么是空地（用 0 表示），要么是障碍物（用 1 表示）。你的任务是找到一条从入口到出口的最短路径。任何时候都不能在障碍物格子中，也不能走到迷宫之外。只能横着走或竖着走，不能斜着走。数据保证有唯一解。


输入：
一个 5 5 的二维数组
输出：
左上角到右下角的最短路径
样例输入
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
样例输出
(0, 0) (1, 0) (2, 0) (2, 1) (2, 2) (2, 3) (2, 4) (3, 4) (4, 4)

#include "stdafx.h"
#include<iostream> 
#include<vector>
#include<map>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

struct position
{
	int x;
	int y;
	position()
	{
		x = -1;
		y = -1;
	}
	position(int px, int py)
	{
		x = px;
		y = py;
	}
};


bool isvalid(int x, int y, vector<vector<int>> &board)
{
	if(x< 0 || y < 0 ||x >= board.size() || y >= board[0].size())
		return false;
	if(board[x][y] == 0)
		return true;
	else
		return false;
}

void printpath(map<int,vector<int>> father, int start, int end, vector<int>&path, vector<vector<int>>&result)
{
	if(start == end)
	{
		//path.push_back(end);
		result.push_back(path);
		//path.pop_back();
		return;
	}
	vector<int> cur = father[end];

	if(cur.size() < 1)
		return;

	for(int i = 0; i<cur.size(); i++)
	{
		path.push_back(cur[i]);
		printpath(father,start,cur[i],path,result);
		path.pop_back();
	}
}
void buildpath(map<int, vector<int>>father,int start, int end, int height, int width)
{
	vector<int> path;
	vector<vector<int>> result;
	printpath(father,start,end,path,result);
	for(int i = 0; i < result.size(); i++)
	{
		for(int j = result[i].size()-1; j>=0; j--)
		{
			int tmpx = result[i][j]/width;
			int tmpy = result[i][j]%width;
			cout << "(" << tmpx << ","<< tmpy << ")---";
		}
		cout << "(" << height-1 << ","<<width-1 << ")" << endl; 
	}
	return;
}

void print(vector<vector<int>> &board)
{
	for(int i = 0; i < board.size(); i++)
	{
		for(int j = 0; j < board[i].size(); j++)
		{
			cout << board[i][j] << " "; 
		}
		cout << endl;
	}
}

void maze(vector<vector<int>> &board)
{
	cout << "the original board is " << endl;
	print(board);
	queue<position> posqueue;
	position start(0,0);
	int height = board.size();
	int width = board[0].size();
	map<int,vector<int>> father;
	posqueue.push(start);
	
	bool findsign = false;

	while(!posqueue.empty())
	{
		position tmp = posqueue.front();
		int tmpint = tmp.x*width+tmp.y;
		posqueue.pop();
		board[tmp.x][tmp.y] = 2; // visited
		if(tmp.x == height-1 && tmp.y == width-1)
		{
			findsign = true;
		}

		if(isvalid(tmp.x+1, tmp.y, board))
		{
			posqueue.push(position(tmp.x+1,tmp.y));
			int posint = (tmp.x+1)*width + tmp.y;
			father[posint].push_back(tmpint);
		}
		if(isvalid(tmp.x-1, tmp.y, board))
		{
			posqueue.push(position(tmp.x-1,tmp.y));
			int posint = (tmp.x-1)*width + tmp.y;
			father[posint].push_back(tmpint);
		}
		if(isvalid(tmp.x, tmp.y+1, board))
		{
			posqueue.push(position(tmp.x,tmp.y+1));
			int posint = tmp.x*width + tmp.y+1;
			father[posint].push_back(tmpint);
		}
		if(isvalid(tmp.x, tmp.y-1, board))
		{
			posqueue.push(position(tmp.x,tmp.y-1));
			int posint = tmp.x*width + tmp.y-1;
			father[posint].push_back(tmpint);
		}
	}

	if(findsign)
	{
		cout << "The path from (0,0) to (" <<height-1 << ","<<width-1<<") is "<<endl; 
		buildpath(father, 0,height*width-1,height,width);
	}
	return;
}

int main()
{
	const int N = 5;
	vector<vector<int>>  board(N, vector<int>(N));
	int M[N][N] = {{0, 1, 0, 0, 0},{0, 1, 0, 1, 0},{0, 0, 0, 0, 0},{0, 1,1, 1, 0},{0, 0, 0, 1, 0}};

	for(int i = 0; i < N; i++)
		board[i].assign(M[i],M[i]+N);
	maze(board);
	system("pause");
	return 0;
}


nativecoder
关注
专栏目录
广度优先搜索算法
流月的博客
04-25 12万+
一、简介 广度优先搜索算法（Breadth-First Search，BFS）是一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。BFS并不使用经验法则算法。 广度优先搜索让你能够找出两样东西之间的最短距离，不过最短距离的含义有很多！使用广度优先搜索可以： 编写国际跳棋AI，计算最少走多少步就可获胜； ...
深度优先遍历和广度优先遍历
a2217018103的博客
05-29 6万+
深度优先遍历和广度优先遍历 什么是 深度/广度 优先遍历？ 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。 这两种遍历方式有什么不同呢？我们来举个栗子： 我们来到一个游乐场，游乐场里有11个景点。我们从景点0开始，要玩遍游乐场的所有景点，可以有什么...
算法：深度优先遍历和广度优先遍历
热门推荐
OceanStar的博客
01-13 9万+
什么是深度、广度优先遍历 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。 这两种遍历方式有什么不同呢？ 举个例子。我们来到一个游乐场，游乐场里有11个景点。我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？ 第一种是一头扎到底的玩法。我们选择一条支路，尽可能不断地深入，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入。 在图中，我们首先选择
深度优先和广度优先
学海无涯,我用JAVA
12-30 2411
搜索方式不同。深度优先搜索算法不全部保留结点，扩展完的结点从数据库中弹出删去；广度优先搜索算法需存储产生的所有结点。运行速度不同。深度优先搜索算法有回溯操作，运行速度慢；广度优先搜索算法无回溯操作，运行速度快。占用空间不同。深度优先搜索算法占用空间少；广度优先搜索算法占用空间大。作用不同。虽然都可以完成树形结构的遍历，但是深度优先一般用于需要先处理最深层级逻辑，广度优先一般用于层层节点展开的处理逻辑；深度优先 用栈;广度优先 用队列;
广度优先搜索和深度优先搜索
liulanba的博客
03-09 2020
假设从a结点开始访问，a先入队。例题：在一个n*m的矩阵上，分布着如下数字，0代表通路，1代表墙，无法通行，2代表起点，3代表终点，4代表陷阱，6代表炸弹，现在要求从起点到终点的最短路径，0可以通行，1无法通行，陷阱则需要花费3个单位时间，6可以把上下左右的四个坐标炸为通路，请给出从起点到终点的最短距离。在广度遍历的过程中，我们可以得到一棵遍历树，称为广度优先生成树，需要注意的是，一给定图的邻接矩阵存储表示是唯一的，故其广度优先生成树也是唯一的，但由于邻接表存储表示不唯一，故其广度优先生成树也是不唯一的。
广度优先搜索以及C++实现
C1172440795的博客
04-05 6148
一文带你搞懂广度优先搜索算法
广度优先搜索（BFS）
m0_68805093的博客
08-03 9455
/ 定义图的边结构// 与边相连的另一顶点的索引Edge* next;// 指向下一条邻接边的指针} Edge;// 定义图的顶点结构// 顶点数据// 指向第一个邻接边的指针} Vertex;// 定义图的邻接表结构// 图中顶点的数量// 存储顶点的数组} Graph;
图的遍历（深度优先和广度优先）
2302_77758423的博客
05-09 2308
相比于树结构的遍历，图的遍历要复杂得多，因为图中的任何一个节点都可能与其它所有节点相邻接。这就意味着，在访问了某个节点之后，可能会顺着某条路径再次返回到这个节点。为了防止对节点进行重复访问，在图的遍历过程中需要记录下已经访问过的节点。深度优先搜索（DFS）和广度优先搜索（BFS）是两种基本的图遍历方法。DFS更适合深入挖掘问题的解决方案，而BFS则适用于逐层分析问题，寻找最短路径或按层次顺序进行操作。
图的遍历 —— 广度优先遍历
谢谢你们的关注
10-02 3万+
图的遍历 —— 广度优先遍历
数据结构与算法——BFS(广度优先搜索)
最新发布
大三计算机在读，分享我的算法之路
08-17 3876
广度优先搜索（Breadth-First Search，简称BFS）是一种遍历或搜索树和图的算法，也称为宽度优先搜索，BFS算法从图的某个节点开始，依次对其所有相邻节点进行探索和遍历，然后再对这些相邻节点的相邻节点进行探索，直到遍历完所有的节点。
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
重排九宫问题(广度优先搜索、启发式搜索）九宫格大解密：数字的魔法排列，你能破解吗？
03-28
本文以通俗易懂的语言，为初学者详细讲解了如何使用广度优先搜索和启发式搜索解决重排九宫问题。通过案例和代码示例，读者可以快速上手，并在实际项目中应用这些算法。 ### 适用人群 本文适用于所有对算法和编程感...
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
其中，BFS（广度优先搜索）是一种常用的策略。本资源“MATLAB源码集锦-基于BFS广度优先搜索算法代码”是专门为MATLAB用户提供的，旨在帮助他们理解和实现BFS算法。 BFS算法的基本思想是从起点开始，首先访问其所有...
js代码-二叉树广度优先遍历
07-16
本篇文章将深入探讨如何使用JS进行二叉树的广度优先遍历（BFS）。 **一、二叉树的基础概念** 二叉树的基本元素是节点，每个节点包含三个部分：数据、左指针和右指针。在JS中，我们可以创建一个Node类来表示二叉树...
广度优先搜索
12-21
**广度优先搜索（Breadth-First Search, BFS）** 广度优先搜索是一种图论中的搜索算法，它按照从源节点开始，逐层探索节点的顺序进行搜索。BFS 主要应用于解决以下两类问题： 1. **路径存在性问题**：从节点A出发...
ACM 输入输出模板
nana1988的专栏
08-17 1320
对于ACM 比赛中，输入输出的模板： 1） 第一行是shuru
什么时候需要些析构函数
nana1988的专栏
02-20 1280
当我们声明的class的构造函数中使用了new， 那我们需要在这个class析构的时候delete， 否则会造成内存泄露，此时，我们需要写class 的析构函数，显示delete掉指针。#include #include #include using namespace std; struct CP { int a; int b; }; class TEST { publ
point 类
nana1988的专栏
05-29 1006
实现了一个point类，主要是熟悉C++ 中类的构造以及yixi
hashmap 模板实现
nana1988的专栏
06-01 747
建立了一个hashmap类，该类得key
C语言实现二叉树的广度优先遍历方法
资源摘要信息:"二叉树的层数遍历（广度优先遍历）" 知识点: 1. 二叉树概念: 二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。 2. 层数遍历定义: 层数遍历，也称为广度优先遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值