• 深度优先搜索（dfs）--矩阵部分-leetcode以及常见题

    介绍

    深度优先搜索（Depth-First Search，DFS）是一种常用的图搜索算法，它用于查找图或树数据结构中的路径或解决问题。下面是深度优先搜索的常见步骤以及一个示例问题：

    深度优先搜索的常见步骤：

    1. 选择起始节点：首先，选择一个起始节点，从该节点开始搜索。

    2. 访问节点：访问当前节点，并标记它为已访问。这可以通过将节点标记为已访问或将其添加到访问过的节点列表中来实现。

    3. 探索相邻节点：从当前节点出发，探索其相邻节点。这可以通过遍历与当前节点相连接的边或邻接节点来实现。

    4. 递归或栈：对于每个相邻节点，如果它还没有被访问过，就递归地或使用栈将其作为当前节点进行访问。这是深度优先搜索的关键部分，它会一直沿着一个路径深入，直到达到叶子节点或无法继续深入为止。

    5. 回溯：当无法继续深入时，回溯到上一个节点，并尝试探索其他相邻节点，直到找到解决方案或访问完所有节点。

    6. 重复步骤3至步骤5：重复步骤3至步骤5，直到找到问题的解决方案或访问了所有可达节点。

    简单的例子

            

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. // 定义图的节点结构
    7. struct Node {
    8.     int val;
    9.     vector neighbors;
    10.     bool visited;
    11.  
    12.     Node(int _val) : val(_val), visited(false) {}
    13. };
    14.  
    15. // 深度优先搜索函数
    16. bool dfs(Node* current, Node* target, vector& path) {
    17.     if (current == target) {
    18.         path.push_back(current);
    19.         return true;
    20.     }
    21.  
    22.     current->visited = true;
    23.     path.push_back(current);
    24.  
    25.     for (Node* neighbor : current->neighbors) {
    26.         if (!neighbor->visited) {
    27.             if (dfs(neighbor, target, path)) {
    28.                 return true;
    29.             }
    30.         }
    31.     }
    32.  
    33.     // 如果无法找到路径，回溯
    34.     path.pop_back();
    35.     return false;
    36. }
    37.  
    38. int main() {
    39.     // 创建节点
    40.     Node* A = new Node(1);
    41.     Node* B = new Node(2);
    42.     Node* C = new Node(3);
    43.     Node* D = new Node(4);
    44.  
    45.     // 构建图的连接关系
    46.     A->neighbors.push_back(B);
    47.     A->neighbors.push_back(C);
    48.     B->neighbors.push_back(D);
    49.     C->neighbors.push_back(D);
    50.  
    51.     // 初始化路径
    52.     vector path;
    53.  
    54.     // 执行深度优先搜索
    55.     bool foundPath = dfs(A, D, path);
    56.  
    57.     // 输出结果
    58.     if (foundPath) {
    59.         cout << "Path from A to D found:" << endl;
    60.         for (Node* node : path) {
    61.             cout << node->val << " ";
    62.         }
    63.         cout << endl;
    64.     } else {
    65.         cout << "Path from A to D not found." << endl;
    66.     }
    67.  
    68.     // 释放节点内存
    69.     delete A;
    70.     delete B;
    71.     delete C;
    72.     delete D;
    73.  
    74.     return 0;
    75. }
    76. /*
    77. 在这个示例中，我们首先定义了一个表示图节点的结构体Node，每个节点具有一个值、一个标记用于表示是否已访问和一个邻接节点的列表。然后，我们实现了一个深度优先搜索函数dfs，该函数递归地探索图中的节点，同时维护一个路径列表。如果找到从起始节点到目标节点的路径，它将返回true，并在路径列表中存储找到的路径。
    79. 在main函数中，我们创建了图的节点并构建了节点之间的连接关系。然后，我们调用dfs函数来查找从节点A到节点D的路径，并输出结果。如果路径存在，它将打印出路径上的节点值，否则会显示未找到路径。最后，我们释放了节点的内存以避免内存泄漏。
    80. */

    题目1：华为机试题43 迷宫问题。

    地址 迷宫问题_牛客题霸_牛客网

    题目描述：

    定义一个二维数组 N*M ，如 5 × 5 数组下所示：

    1. int maze[5][5] = {
    2. 0, 1, 0, 0, 0,
    3. 0, 1, 1, 1, 0,
    4. 0, 0, 0, 0, 0,
    5. 0, 1, 1, 1, 0,
    6. 0, 0, 0, 1, 0,
    7. };

            

    它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。

    数据范围：

    2≤n,m≤10  ， 输入的内容只包含

    0≤val≤1

    输入描述：

    输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

    输入：

    5 5

    0 1 0 0 0

    0 1 1 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)

    复制

    示例2

    输入：

    5 5

    0 1 0 0 0

    0 1 0 1 0

    0 0 0 0 1

    0 1 1 1 0

    0 0 0 0 0

    复制

    输出：

    (0,0)

    (1,0)

    (2,0)

    (3,0)

    (4,0)

    (4,1)

    (4,2)

    (4,3)

    (4,4)

    复制

    说明：

    注意：不能斜着走！！

    1.  
    2. #include 
    3. #include
    4. using namespace std;
    5.  
    6. vectorint> > res;
    7. bool dfs(vectorint>>& v, int m, int n, int i, int j) {
    8.  
    9.     if (i == m - 1 && j == n - 1) {
    10.         res.push_back({i, j});
    11.         return true;
    12.     }
    13.  
    14.     //通过这个false 判定这个结果。
    15.  
    16.     if (i < 0 || i >= m || j < 0 || j >= n || v[i][j] == -1 || v[i][j] == 1) {
    17.         return false;
    18.     }
    19.  
    20.     v[i][j] = -1;
    21.     res.push_back({i, j});
    22.  
    23.     if (dfs(v, m, n, i - 1, j) || dfs(v, m, n, i + 1, j) ||
    24.             dfs(v, m, n, i, j - 1) || dfs(v, m, n, i, j + 1)) {
    25.         return true;
    26.     }
    27.  
    28.     res.pop_back();
    29.     v[i][j] = 0;
    30.  
    31.     return false;
    32.  
    33. }
    34.  
    35. int main() {
    36.  
    37.     int m, n;
    38.     int temp;
    39.     cin >> m >> n;
    40.     vectorint> > v(m, vector<int>(n, 0));
    41.  
    42.     for (int i = 0; i < m; i++) {
    43.         for (int j = 0; j < n; j++) {
    44.  
    45.             cin >> v[i][j];
    46.         }
    47.     }
    48.  
    49.     dfs(v,m,n,0,0);
    50.  
    51.     for(const auto & x:res){
    52.         // printf("(%d,%d)\n",x[0],[1]);
    53.         // printf("(%d,%d) \n",x[0],[1]);
    54.         printf("(%d,%d)\n", x[0], x[1]);
    55.     }
    56.  
    57.     return 0;
    58.  
    59. }

    题目2：剑指offer12 矩阵中的路径

    链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

    给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

    单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

    例如，在下面的 3×4 的矩阵中包含单词 "ABCCED"（单词中的字母已标出）。

     

    示例 1：

    输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

    示例 2：

    输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false
    1. class Solution6 {
    2. public:
    3.        bool dfs(vectorchar>>& board,string word,int i,int j,int k,vectorint>> &path){
    4.  
    5.         if(i<0||i>=board.size()||j<0||j>=board[0].size()||path[i][j]==1){
    6.             return false;
    7.         }
    8.  
    9.           if(board[i][j]==word[k]&&k==word.size()-1){
    10.             return true;
    11.         }
    12.  
    13.         if(word[k]==board[i][j]){
    14.  
    15.             path[i][j]=1;
    16.             if(dfs(board,word,i+1,j,k+1,path)||dfs(board,word,i-1,j,k+1,path)||dfs(board,word,i,j-1,k+1,path)||dfs(board,word,i,j+1,k+1,path)){
    17.                  return true;
    18.         }
    19.  
    20.         }
    21.  
    22.         path[i][j]=0;
    23.         return false;
    24.  
    25.     }
    26.  
    27.     bool exist(vectorchar>>& board, string word) {
    28.  
    29.         int m=board.size();
    30.         int n=board[0].size();
    31.         bool res=false;
    32.         vectorint> > path(m,vector<int>(n,0));
    33.         for(int i=0;i
    34.             for(int j=0;j
    35.  
    36.                 res = dfs(board, word, i, j, 0, path);
    37.                 if(res){
    38.                     //i,j 是起点只要有一个七点满足条件就可以
    39.                     return true;
    40.                 }
    41.  
    42.             }
    43.         }
    44.  
    45.         return  res;
    46.     }
    47.  
    48. };
    49.  
    50. int main()
    51. {
    52.  
    53.     Solution6 s;
    54.     vectorchar>> board = {{'A', 'B', 'C', 'E'}, {'S', 'F', 'C', 'S'}, {'A', 'D', 'E', 'E'}};
    55.     // vector< vector > board={}
    56.     string word = "ABCCED";
    57.  
    58.     bool res = s.exist(board, word);
    59.     cout << res << endl;
    60.  
    61.     system("pause");
    62.     return 0;
    63. }

    题目3 leetcode 200岛屿的数量 

    leet200 岛屿的数量 https://leetcode.cn/problems/number-of-islands/

    给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

    岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

    此外，你可以假设该网格的四条边均被水包围。

    示例 1：

    输入：grid = [

      ["1","1","1","1","0"],

      ["1","1","0","1","0"],

      ["1","1","0","0","0"],

      ["0","0","0","0","0"]

    ]

    输出：1

    示例 2：

    输入：grid = [

      ["1","1","0","0","0"],

      ["1","1","0","0","0"],

      ["0","0","1","0","0"],

      ["0","0","0","1","1"]

    ]

    //可以这么理解，(遍历整个岛屿的元素，如果是1就对这个点的值进行深度优先搜索，将相邻的全部改成0) 岛屿的数量+1。

    1. class Solution7
    2. {
    3. public:
    4.     int n;
    5.     void dfs(vectorchar>> &grid, int i, int j, int m, int n)
    6.     {
    7.  
    8.         if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0')
    9.         {
    10.             return;
    11.         }
    12.  
    13.         grid[i][j] = '0';
    14.         dfs(grid, i - 1, j, m, n);
    15.         dfs(grid, i + 1, j, m, n);
    16.         dfs(grid, i, j - 1, m, n);
    17.         dfs(grid, i, j + 1, m, n);
    18.  
    19.         return;
    20.     }
    21.  
    22.     int numIslands(vectorchar>> &grid)
    23.     {
    24.  
    25.         int m = grid.size();
    26.         int n = grid[0].size();
    27.  
    28.         int num = 0;
    29.         // vector > path=vector(m,vector(n,0));
    30.  
    31.         for (int i = 0; i < m; i++)
    32.         {
    33.  
    34.             for (int j = 0; j < n; j++)
    35.             {
    36.  
    37.                 if (grid[i][j] == '1')
    38.                 {
    39.                     n++;
    40.                     dfs(grid, i, j, m, n);
    41.                 }
    42.             }
    43.         }
    44.  
    45.         return n;
    46.     }
    47. };
    48.  
    49. int main()
    50. {
    51.  
    52.     Solution7 s7;
    53.  
    54.     vectorchar>> gird = {{'1'}, {'1'}};
    55.  
    56.     auto res = s7.numIslands(gird);
    57.     cout << res << endl;
    58.  
    59.     system("pause");
    60.     return 0;
    61. }

    =================================后续待补=================================

     题目4：剑指offer 38 字符串的全排列

            链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

    输入一个字符串，打印出该字符串中字符的所有排列。

    你可以以任意顺序返回这个字符串数组，但里面不能有重复元素

    输入：s = "abc"

    输出：["abc","acb","bac","bca","cab","cba"]

    1. class Solution8
    2. {
    3.  
    4. public:
    5.     void dfs1(string s, vector<bool> &path, vector &ans, string &str)
    6.     {
    7.  
    8.         if (str.size() == s.size())
    9.         {
    10.             ans.push_back(str);
    11.             //终止条件，需要在前面加上做的事情。否则这个函数没有任何作用。
    12.             return;
    13.         }
    14.  
    15.         for (int i = 0; i < s.size(); i++)
    16.         {
    17.             if (i > 0 && s[i] == s[i - 1] && path[i - 1] == true)
    18.             {
    19.                 continue;
    20.             }
    21.  
    22.             if (path[i] == false)
    23.             {
    24.                 path[i] = true;
    25.                 str.push_back(s[i]);
    26.  
    27.                 dfs1(s, path, ans, str);
    28.                 str.pop_back();
    29.                 path[i] = false;
    30.             }
    31.         }
    32.  
    33.         return;
    34.     }
    35.  
    36.     vector permutation(string s)
    37.     {
    38.  
    39.         sort(s.begin(), s.end());
    40.  
    41.         vector<bool> path(s.size(), false);
    42.         string temp;
    43.         vector ans;
    44.  
    45.         dfs1(s,path,ans,temp);
    46.  
    47.         return ans;
    48.  
    49.         
    50.     }
    51.  
    52.     
    53. };

    题目5：华为机试题：火车进站问题。

    火车进站_牛客题霸_牛客网

    定一个正整数N代表火车数量，0

    输入：

    3

    1 2 3

    复制

    输出：

    1 2 3

    1 3 2

    2 1 3

    2 3 1

    3 2 1

    复制

    说明：

    第一种方案：1进、1出、2进、2出、3进、3出

    第二种方案：1进、1出、2进、3进、3出、2出

    第三种方案：1进、2进、2出、1出、3进、3出

    第四种方案：1进、2进、2出、3进、3出、1出

    第五种方案：1进、2进、3进、3出、2出、1出

    请注意，[3,1,2]这个序列是不可能实现的。

    递归写法：

    新建一个栈stack作为车站，每次只有两种操作：新车入栈、栈顶出栈，两种操作执行的前提分别是：还有车没入过站（id < N，v[id]是待入栈的元素）、栈不为空（!st.empty()）

    递归边界就是当上述两个条件都不满足时（车已经全部入过站并且站里没有车了），递归结束，保存当前递归分支的出栈顺序，最后用sort对结果排序即可。注意每进入一个分支之后，要恢复栈st和数组temp之前的状态。

    1. #include 
    2.  
    3. stack<int> st;
    4. vector<int> temp; //出站序列
    5. vector<int> v;    //入站序列
    6.  
    7. int N;
    8. vectorint>> ans;
    9.  
    10. void dfs2(int id)
    11. {
    12.  
    13.     //边界条件两个都满足。
    14.     if (id == N && st.empty())
    15.     {
    16.  
    17.         ans.push_back(temp);
    18.         return;
    19.     }
    20.  
    21.     //新车入站
    22.  
    23.     if (id < N)
    24.     {
    25.         st.push(v[id]);
    26.         dfs2(id + 1); //进入分支
    27.         st.pop();
    28.     }
    29.  
    30.     //栈顶出栈
    31.  
    32.     if (!st.empty())
    33.     {
    34.         int n = st.top();
    35.         temp.push_back(n);
    36.         st.pop();
    37.         dfs2(id); //进入分支
    38.         st.push(n);
    39.         temp.pop_back();
    40.     }
    41. }
    42.  
    43. int main()
    44. {
    45.  
    46.     // int n;
    47.     cin >> N;
    48.  
    49.     v.resize(N);
    50.  
    51.     for (int i = 0; i < N; i++)
    52.     {
    53.         cin >> v[i];
    54.     }
    55.  
    56.     dfs2(0);
    57.  
    58.     sort(ans.begin(), ans.end());
    59.  
    60.     for (auto plan : ans)
    61.     {
    62.         for (auto n : plan)
    63.             cout << n << " ";
    64.         cout << endl;
    65.     }
    66.     cout << "end " << endl;
    67.  
    68.     system("pause");
    69.     return 0;
    70. }

     

  • 相关阅读:
    图像对比方法介绍及实现
    docker 常用指令
    【代码随想录day24】不同的二叉搜索树
    cache 学习
    接口测试（含文档）
    人工智能|机器学习——K-means系列聚类算法k-means/ k-modes/ k-prototypes/ ......（划分聚类）
    [附源码]计算机毕业设计游戏交易平台Springboot程序
    【Android】编译系统之 make 和 Soong
    Centos安装Docker
    Springboot集成整合Redis-单机版（4）
  • 原文地址：https://blog.csdn.net/cat_fish_rain/article/details/132725245