深度优先搜索

深度优先搜索

算法解释

      深度优先搜索（depth-first search,DFS）在搜索到一个新的未曾访问过的节点之后，立刻对于当前的节点进行遍历；因此可以使用递归来实现，相应的很自然的也就可以使用先进后出的栈来实现。对于数或者图而言，由于总是遍历新的节点，所以总是向着更深处前进。
      一般来说，深度优先搜索类型的题可以分为主函数和辅函数，主函数用于遍历所有的位置，也就是说主函数提供一个进入遍历环节的入口，判断是否可以进行遍历，如果可以就进行深度优先遍历。辅函数则负责深度优先搜索的递归使用，要注意递归的时候一定要设置好基线条件。
      刷题的时候，一般建议采用递归写法，当然在最终工程上的时候还是建议采用栈的方式，因为这样的化运行速度会更快并且不会出现递归栈满的情况。

具体的题目学习

leetcode 695

695. 岛屿的最大面积
     给定一个包含了一些 0 和 1 的非空二维数组 grid 。

一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid的四个边缘都被 0（代表水）包围着。找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

示例 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0], [0,0,0,0,0,0,0,1,1,0,0,0,0]]
对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。

示例 2:

[[0,0,0,0,0,0,0,0]] 对于上面这个给定的矩阵, 返回 0。

非递归写法

class Solution {
public:
    vector<int> direction{-1,0,1,0,-1};
    int maxAreaOfIsland(vector<vector<int>>& grid) {
     int m = grid.size(), n = m?grid[0].size():0, local_area, area =0,x,y;
     for(int i = 0;i < m; i++)
     {
         for(int j = 0;j < n; j++)
         {
             if(grid[i][j])
             {
                 local_area = 1;
                 grid[i][j] = 0;
                 stack<pair<int,int>> s;
                 s.push({i,j});
                 while(!s.empty())
                 {
                     auto [p,q] = s.top();
                     s.pop();
                     for(int k = 0;k < 4; k++)
                     {
                         x = p+direction[k];
                         y = q+direction[k+1];
                         if(x>=0&&x<m&&y>=0&&y<n&&grid[x][y])
                         {
                             s.push({x,y});
                             grid[x][y] = 0;
                             local_area++;
                         }
                     }
                 }
                 area = max(area,local_area);
             }
         }
     }
     return area;
    }
};

注：
（1）这里使用了第一个小技巧：那就是对于二维数组上的四个方向的遍历，我们采用了一个{-1，0，1，0，-1}来进行存储，简化了表示的步骤。
（2）一定要注意边界条件的表示，不能超过数组的边界
（3）那就是对于本题的状态记录或者说是记录化，没有按照一般的遍历时额外设置visit数组来存储遍历情况，而是使得遍历过的1变成了0，在原来基础上表示出已经遍历的信息是刷题时优先要考虑的，会简化空间复杂度。

递归的两种写法

一般是要分开设置为主函数和辅助函数，提供深度优先遍历的接口和具体实现的细节

第一种

class Solution {
public:
    //存储四个遍历方向的数组
    vector<int> direction{-1,0,1,0,-1};
    //主函数
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        int m = grid.size(),n = m?grid[0].size():0,area = 0;
        if(!m||!n) return 0;
        for(int i = 0;i < m;++i)
        {
            for(int j = 0;j < n;++j)
            {
                if(grid[i][j])
                {
                    area = max(area,helper(grid,i,j));
                }
            }
        }
        return area;
    }
    //辅助函数
    int helper(vector<vector<int>>&grid,int i,int j)
    {
       //优先设置边界条件，在递归中也就是所谓的基线条件
       if(i<0||i>=grid.size()||j<0||j>=grid[0].size()||grid[i][j]==0) return 0;
       int sum = 1;
       //将原来的单元置零以表示已经遍历过了
       grid[i][j] = 0;
       for(int k = 0;k<4;++k)
       {
           sum += helper(grid,i+direction[k],j+direction[k+1]);
       }
       return sum;
    }
};

这种递归是先进行下一步的搜索，但是在下一次的搜索的开始会进行检查是否满足遍历的条件。

第二种递归

主函数不改变，主要是对于辅助函数的判断条件进行微调

int helper(vector<vector<int>>&grid,int i,int j)
    {
       //优先设置边界条件，在递归中也就是所谓的基线条件
       int sum = 1,x,y;
       //将原来的单元置零以表示已经遍历过了
       grid[i][j] = 0;
       for(int k = 0;k<4;++k)
       {
           x = i+direction[k],y = j+direction[k+1];
           //对于是否进入下一次递归而进行判断
           if(x>=0&&x<grid.size()&&y>=0&&y<grid[0].size()&&grid[x][y])
           {
               sum += helper(grid,x,y);
           }
       }
       return sum;
    }