看这道题不懂深度搜索的可以看看下面讲述 

岛屿的最大面积

 

解题思路

 代码

class Solution {
    int dfs(vector<vector<int>>& grid, int cur_i, int cur_j) {
        //确定边界
        if((cur_i >=0 && cur_i < grid.size()) && (cur_j >=0 && cur_j < grid[0].size()))
        {
            //判断是否是陆地
            if(grid[cur_i][cur_j] == 0) return 0;
            else{
                grid[cur_i][cur_j] = 0;
                //在进行dfs深度遍历
                return 1+dfs(grid,cur_i-1,cur_j) + dfs(grid,cur_i+1,cur_j) +dfs(grid,cur_i,cur_j-1) + dfs(grid,cur_i,cur_j+1);
            }
        }
        else{
            return 0;
        }
        
    }
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int count = 0;
        for(int i = 0;i< grid.size();i++)
        {
            for(int j=0;j<grid[0].size();j++)
            {
                count = max(count,dfs(grid,i,j));
            }
        }
        return count;
    }
};

时间复杂度O(i*j) 每次都会以二维数组中某一个点为起点，进行深度搜索。

空间复杂度O(I*J) 因为递归的最大情况是，所有数组的元素都是1，这样递归的深度最大就是数组的面积大小。

深度搜索

具体解释 

深度搜素需要用到栈来实现

@ 1 第一步如果以0为起点 ，先输出0，再以（1,4,3）中其中任意一个邻接点进行深度搜索也就是递归。

@ 2 第二步，如果到达4，在到达4之前将0入栈，输出4

@ 3 第三步 ,到达下一个邻接点2，将4入栈，输出2.

@4 第四步，到达下一个邻接电1，将2入栈，输出1.

@5 第五步，访问1后，1没有邻接点，于是将栈出栈。

@6 第六步，出栈2，发现2有邻接点3，将3输出，3后没有没有访问的邻接点继续出栈

@7第七步，出栈4,0。栈空。程序截止。

下面举一个具体的深度搜索的例子

画一个横着的图： 4----2---0---1---3 从起始点0开始进行深搜。

结果是：02413 或者 01324.

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

// 图的结构体，使用邻接表表示
struct Graph {
    int V; // 图的顶点数
    vector<vector<int>> adj; // 邻接表

    // 构造函数，初始化图的顶点数和邻接表
    Graph(int V) {
        this->V = V;
        adj.resize(V);
    }

    // 添加边，无向图
    void addEdge(int v, int w) {
        adj[v].push_back(w); // v 和 w 之间有一条边
        adj[w].push_back(v); // 因为是无向图，所以也要反向添加
    }

    // 深度优先搜索
    void DFS(int start) {
        // 记录访问状态的数组，初始都未访问过
        vector<bool> visited(V, false);

        // 使用栈来实现递归调用的效果
        stack<int> stack;

        // 将起始节点压入栈中
        stack.push(start);

        while (!stack.empty()) {
            // 弹出栈顶元素
            int v = stack.top();
            stack.pop();

            // 如果当前节点未访问过，则访问它
            if (!visited[v]) {
                cout << v << " ";
                visited[v] = true;
            }

            // 遍历当前节点的所有邻接节点
            for (int neighbor : adj[v]) {
                // 如果邻接节点未访问过，则压入栈中
                if (!visited[neighbor]) {
                    stack.push(neighbor);
                }
            }
        }
    }
};

int main() {
    // 创建一个包含 5 个顶点的图
    Graph g(5);

    // 添加边构成图
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 3);
    g.addEdge(2, 4);

    cout << "深度优先搜索结果（从顶点0开始）: ";
    g.DFS(0); // 从顶点 0 开始进行深度优先搜索

    return 0;
}

结果展示