图论篇--代码随想录算法训练营第五十三天打卡| 110. 字符串接龙，105.有向图的完全可达性，106. 岛屿的周长

110. 字符串接龙

题目链接：110. 字符串接龙

题目描述：

字典 strList 中从字符串 beginStr 和 endStr 的转换序列是一个按下述规格形成的序列：

序列中第一个字符串是 beginStr。
序列中最后一个字符串是 endStr。
每次转换只能改变一个字符。
转换过程中的中间字符串必须是字典 strList 中的字符串，且strList里的每个字符串只用使用一次。

给你两个字符串 beginStr 和 endStr 和一个字典 strList，找到从 beginStr 到 endStr 的最短转换序列中的字符串数目。如果不存在这样的转换序列，返回 0。

解题思路：

这道题要解决两个问题：

图中的线是如何连在一起的

起点和终点的最短路径长度

1）判断点与点之间的关系，需要判断是不是差一个字符，如果差一个字符，那就是有链接。

2）求起点和终点的最短路径长度，这里无向图求最短路，广搜最为合适，广搜只要搜到了终点，那么一定是最短的路径。因为广搜就是以起点中心向四周扩散的搜索。

另外需要有一个注意点：

本题是一个无向图，需要用标记位，标记着节点是否走过，否则就会死循环！

使用set来检查字符串是否出现在字符串集合里更快一些

代码：

cpp 复制代码

#include<iostream>
#include<unordered_set>
#include<queue>
#include<unordered_map>
#include<string>
using namespace std;

int main()
{
    int n;
    cin >> n;
    unordered_set<string> strList;
    string beginStr, endStr;
    cin >> beginStr >> endStr;
    for(int i = 0; i < n; i++) 
    {
        string s;
        cin >> s;
        strList.insert(s);
    }
    unordered_map<string,int> visitStr;
    queue<string> q;
    q.push(beginStr);
    visitStr.insert({beginStr,1});
    while(!q.empty())
    {
        string val = q.front();
        q.pop();
        int path = visitStr[val];
        for(int i = 0; i < val.size(); i++)
        {
            string newStr = val;
            for(int j = 0; j < 26; j++)
            {
                newStr[i] = j + 'a';
                if(newStr == endStr)
                {
                    cout << path + 1 << endl;
                    return 0;
                }
                if(visitStr.find(newStr) == visitStr.end() && strList.find(newStr) != strList.end())
                {
                    visitStr[newStr] = path + 1;
                    q.push(newStr);
                }
            }
        }
    }
    
    cout << 0 << endl;
    return 0;
}

105.有向图的完全可达性

题目链接：105. 有向图的完全可达性

题目描述：

给定一个有向图，包含 N 个节点，节点编号分别为 1，2，...，N。现从 1 号节点开始，如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。

解题思路：

使用数组visited来保存当前节点的访问情况，使用dfs来遍历所有节点。最后如果所有节点均被访问，则输出1。

代码：

cpp 复制代码

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>
using namespace std;

void dfs(vector<list<int>>& graph,vector<bool>& visited,int key)
{
    if(visited[key]) return;
    visited[key] = true;
    for(auto x : graph[key])
        dfs(graph,visited,x);
}

int main()
{
    int n,k;
    cin >> n >> k;
    vector<list<int>> graph(n+1);
    for(int i = 0; i < k ; i++)
    {
        int s,t;
        cin >> s >> t;
        graph[s].push_back(t);
    }
    
    vector<bool> visited(n+1);
    dfs(graph,visited,1);
    for(int i = 1; i <= n; i++) 
        if(visited[i] == false) 
        {
            cout << -1 << endl;
            return 0;
        }
    cout << 1 << endl;
    return 0;
}

106. 岛屿的周长

题目链接：106. 岛屿的周长

题目描述：

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。

你可以假设矩阵外均被水包围。在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。

解题思路：

1）找边法

遍历每一个空格，遇到岛屿则计算其上下左右的空格情况。如果该陆地上下左右的空格是有水域，则说明是一条边；如果该陆地上下左右的空格出界了，则说明是一条边；

2）公式法

结果 result = 岛屿数量 * 4 - cover * 2;

有一对相邻两个陆地，边的总数就要减2

每次只统计节点上边相邻陆地和其左边相邻陆地，其余方向不统计防止重复。

代码：

1）dfs找边法

cpp 复制代码

#include<iostream>
#include<vector>
using namespace std;
 
int cnt = 0;
int dx[4] = {-1,0,0,1};
int dy[4] = {0,-1,1,0};
 
void dfs(vector<vector<int>>& grid,vector<vector<bool>>& visited,int r, int c)
{
    visited[r][c] = true;
    for(int i = 0 ; i < 4; i++)
    {
        int x = r + dx[i], y = c + dy[i];
        if(x < 0 || y < 0 || x >= grid.size() || y >= grid[0].size() || grid[x][y] == 0)
        {
            cnt++;
            continue;
        }
        if(grid[x][y] == 1 && !visited[x][y])
            dfs(grid,visited,x,y);
    }
}
 
int main()
{
    int n,m;
    cin >> n >> m;
    vector<vector<int>> grid(n,vector<int>(m));
    vector<vector<bool>> visited(n,vector<bool>(m));
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> grid[i][j];
    for(int i = 0 ; i < n; i++)
        for(int j = 0; j < m; j++)
            if(grid[i][j] == 1 && !visited[i][j])
            {
                dfs(grid,visited,i,j);
                break;
            }
                 
    cout << cnt << endl;
    return 0;
}

2）直接找边法

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, m;
    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 direction[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};
    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 x = i + direction[k][0];
                    int y = j + direction[k][1];    // 计算周边坐标x,y
                    if (x < 0                       // x在边界上
                            || x >= grid.size()     // x在边界上
                            || y < 0                // y在边界上
                            || y >= grid[0].size()  // y在边界上
                            || grid[x][y] == 0) {   // x,y位置是水域
                        result++;
                    }
                }
            }
        }
    }
    cout << result << endl;
 
}

3）公式法

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, m;
    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 cover = 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) cover++;
                // 统计左边相邻陆地
                if(j - 1 >= 0 && grid[i][j - 1] == 1) cover++;
                // 为什么没统计下边和右边？ 因为避免重复计算
            }
        }
    }

    cout << sum * 4 - cover * 2 << endl;

}