目录
1、字符串接龙
题目描述
字典 strList 中从字符串 beginStr 和 endStr 的转换序列是一个按下述规格形成的序列：
1. 序列中第一个字符串是 beginStr。
2. 序列中最后一个字符串是 endStr。
3. 每次转换只能改变一个字符。
4. 转换过程中的中间字符串必须是字典 strList 中的字符串，且strList里的每个字符串只用使用一次。
给你两个字符串 beginStr 和 endStr 和一个字典 strList，找到从 beginStr 到 endStr 的最短转换序列中的字符串数目。如果不存在这样的转换序列，返回 0。
输入描述
第一行包含一个整数 N，表示字典 strList 中的字符串数量。 第二行包含两个字符串，用空格隔开，分别代表 beginStr 和 endStr。 后续 N 行，每行一个字符串，代表 strList 中的字符串。
输出描述
输出一个整数，代表从 beginStr 转换到 endStr 需要的最短转换序列中的字符串数量。如果不存在这样的转换序列，则输出 0。
输入示例
6 abc def efc dbc ebc dec dfc yhn
输出示例
4
提示信息
从 startStr 到 endStr，在 strList 中最短的路径为 abc -> dbc -> dec -> def，所以输出结果为 4，如图：
数据范围：
2 <= N <= 500
思路：这里判断字符串接龙，每次只能变换一个元素的值，然后到下一个字符串，所以就是找从beginStr字符串开始到endStr字符串的最短路径长度。
如果使用深搜的话，会统计所有的可达路径，最后还需要从里面找最短的那条，比较繁琐；
而如果使用广搜的话，因为本身广度搜索找到结果就会是最短的那条，所以这道题使用广搜要简单得多。
需要注意的是因为设计到判断变换后的字符串是否出现在字符串字典中，所以使用set集合来存储比较方便查询，同时还需要记录下路径长度，以免能够最终输出。
#include<iostream>
#include<vector>
#include<string>
#include<unordered_set>
#include<unordered_map>
#include<utility>
#include<queue>
using namespace std;
int main(){
int n;
while(cin >> n){
string beginStr, endStr, str;
cin >> beginStr >> endStr;
vector<string> worDict(n);
unordered_set<string> strSet;//记录字符串字典，使用set方便判断是否在字典里
for(int i = 0; i < n; i ++){
cin >> str;
strSet.insert(str);
}
unordered_map<string, int> visitedStr;//记录遍历过的字符串以及路径
visitedStr.insert(pair<string, int>(beginStr, 1));//初始化visitedStr
queue<string> que;
que.push(beginStr);
while(!que.empty()){
string word = que.front();
que.pop();
int path = visitedStr[word];
for(int i = 0; i < word.size(); i ++){
string newword = word;//这里需要使用newword来替换word进行下面的变化
for(int j = 0; j < 26; j ++){
newword[i] = j + 'a';
if(newword == endStr){
cout << path + 1 << endl;
return 0;
}
//这里要求字符串字典里面要有newword,并且之前没有遍历过，否则可能陷入死循环
if(strSet.find(newword) != strSet.end() && visitedStr.find(newword) == visitedStr.end()){
visitedStr.insert(pair<string, int>(newword, path + 1));
que.push(newword);
}
}
}
}
cout << 0 << endl;//不存在这样的转换
}
}2、有向图的完全可达性
题目描述
给定一个有向图，包含 N 个节点，节点编号分别为 1，2，...，N。现从 1 号节点开始，如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。
输入描述
第一行包含两个正整数，表示节点数量 N 和边的数量 K。 后续 K 行，每行两个正整数 s 和 t，表示从 s 节点有一条边单向连接到 t 节点。
输出描述
如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。
输入示例
4 4 1 2 2 1 1 3 2 4
输出示例
1
提示信息
从 1 号节点可以到达任意节点，输出 1。
数据范围：
1 <= N <= 100；
1 <= K <= 2000。
思路：这道题其实采用深搜还是广搜都是可以的。我这里主要介绍使用深搜的两种方式。
2.1 深搜处理当前节点
深搜处理当前节点的话，就涉及到在进入dfs时就需要做出判断结束条件的判断，然后再进行后续的操作。
#include<iostream>
#include<vector>
#include<list>
using namespace std;
void dfs(vector<list<int>>& grid, vector<bool>& visited, int x){
if(visited[x]) return;//这里是处理当前节点
visited[x] = true;
list<int> keys = grid[x];//将x相连接的节点都放入keys中
for(int key : keys){
dfs(grid, visited, key);
}
}
int main(){
int n, k;
while(cin >> n >> k){
vector<list<int>> grid(n + 1);
int node1, node2;
while(k --){
cin >> node1 >> node2;
grid[node1].push_back(node2);
}
vector<bool> visited(n + 1, false);
dfs(grid, visited, 1);
for(int i = 2; i <= n; i ++){
if(visited[i] == false){
cout << -1 << endl;
return 0;
}
}
cout << 1 << endl;
}
}2.2 深搜处理下一个节点
深搜如果是处理下一个节点的情况，那么就没有了结束条件的判断，因为在循环中就给出了判断条件，如果不满足条件是不会进入递归的。
#include<iostream>
#include<vector>
#include<list>
using namespace std;
void dfs(vector<list<int>>& grid, vector<bool>& visited, int x){
list<int> keys = grid[x];//将x相连接的节点都放入keys中
for(int key : keys){
if(visited[key]) continue; //这里是处理下一个节点的dfs写法
visited[key] = true;
dfs(grid, visited, key);
}
}
int main(){
int n, k;
while(cin >> n >> k){
vector<list<int>> grid(n + 1);
int node1, node2;
while(k --){
cin >> node1 >> node2;
grid[node1].push_back(node2);
}
vector<bool> visited(n + 1, false);
visited[1] = true;
dfs(grid, visited, 1);
for(int i = 2; i <= n; i ++){
if(visited[i] == false){
cout << -1 << endl;
return 0;
}
}
cout << 1 << endl;
}
}3、岛屿的周长
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。
你可以假设矩阵外均被水包围。在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出一个整数，表示岛屿的周长。
输入示例
5 5 0 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0
输出示例
14
提示信息
岛屿的周长为 14。
数据范围：
1 <= M, N <= 50。
思路：这里有两种思路求解。
第一种是当遍历到岛屿时，对其四周的方向分别进行判断，当越界或者是水域的时候，周长加1，最后返回最终结果即可。
#include<iostream>
#include<vector>
using namespace std;
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int main(){
int n, m;
while(cin >> n >> m){
vector<vector<int>> grid(n, vector<int>(m, 0));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
int result = 0;
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(grid[i][j] == 1){
for(int k = 0; k < 4; k ++){
int nearx = i + dir[k][0];
int neary = j + dir[k][1];
if(nearx < 0 || nearx >= grid.size() || neary < 0 || neary >= grid[0].size() || grid[nearx][neary] == 0){
result ++;
}
}
}
}
}
cout << result << endl;
}
}第二种是统计所有的陆地数量以及所有的相邻陆地数量，所有陆地的周长单独算的话周长等于陆地数量*4，但是每个陆地不是独立的，所以每存在相邻的两个陆地，那么周长就要减去2，所以最终的周长就等于陆地数量*4-相邻陆地数量*2。
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n, m;
while(cin >> n >> m){
vector<vector<int>> grid(n, vector<int>(m, 0));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
int sum = 0;//记录岛屿的面积
int count = 0;//记录相交的岛屿个数
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(grid[i][j] == 1){
sum ++;
//记录上面相邻节点是否为岛屿
if(i - 1 >= 0 && grid[i - 1][j] == 1) count ++;
//记录左边相邻节点是否为岛屿
if(j - 1 >= 0 && grid[i][j - 1] == 1) count ++;
//这里只需要上下选一边记录，左右选一边记录即可
//如果全部记录会出现重复计算相邻边数
}
}
}
cout << sum * 4 - count * 2 << endl;
}
}感谢你的阅读，希望我的文章能够给你帮助，如果有帮助，麻烦点赞加收藏，或者点点关注，非常感谢。
如果有什么问题欢迎评论区讨论！
扫一扫
225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
