算法复习：BFS与DFS

BFS

leetcode 279. 完全平方数

vector存每一层的节点，弹出一个节点就压入这个节点所有的子节点。

从上往下维护一颗树，根节点是要找的n，第一层子节点是父节点减去i*i以后的值，一直到发现0为止。

注意必须要用一个标记数组记录已经走过的点避免重复查找，否则会超时

如果更改一下顺序，按从大到小的顺序查会更快一点。

#include<vector>
#include<queue>
#include<map>
class Solution {
public:
    int numSquares(int n)
    {
        vector<int>donser;
        queue<int>tree;
        map<int,bool>lable;
        for(int i=1;i*i<=n;i++)
        {
            tree.push(n-i*i);
            donser.push_back(i*i);
        }
        int deepth=0;
        while(n)
        {
            int size=tree.size();
            deepth++;
            for(int i=0;i<size;i++)
            {
                int next=tree.front();
                tree.pop();
                if(next==0)
                    return deepth;
                for(int j=0;j<donser.size();j++)
                {
                    if(lable[next-donser[j]]==true)
                    {
                        continue;
                    }    
                    if(donser[j]<=next)
                    {
                        tree.push(next-donser[j]);
                        lable[next-donser[j]]=true;
                    }
                    else
                        break;
                }
            }
        }
        return 0;
    }
};

leetcode 279

DFS

leedcode 695. 岛屿的最大面积

向四个方向搜，走过的地方做标记

class Solution {
public:
    int dfs(int i,int j,vector<vector<int>>& grid,map<int,int>& lable,int count)
    {
        lable[i*grid[0].size()+j]=1;
        if(i>=1&&lable[(i-1)*grid[0].size()+j]!=1&&grid[i-1][j]==1)//向上
        {
            count=dfs(i-1,j,grid,lable,++count);
        }
        if(i+1<grid.size()&&lable[(i+1)*grid[0].size()+j]!=1&&grid[i+1][j]==1)//向下
        {
            count=dfs(i+1,j,grid,lable,++count);
        }
        if(j>=1&&lable[i*grid[0].size()+j-1]!=1&&grid[i][j-1]==1)//向左
        {
            count=dfs(i,j-1,grid,lable,++count);
        }
        if(j+1<grid[0].size()&&lable[i*grid[0].size()+j+1]!=1&&grid[i][j+1]==1)//向右
        {
            count=dfs(i,j+1,grid,lable,++count);
        }
        return count;
    }
    int maxAreaOfIsland(vector<vector<int>>& grid)
    {
        map<int,int>lable;
        int max=0,count=0;
        for(int i=0;i<grid.size();i++)
        {
            vector<int>line=grid[i];
            for(int j=0;j<line.size();j++)
            {
                count=1;
                if(lable[i*line.size()+j]!=1)//没访问过
                {
                    if(grid[i][j]==0)//0就跳过
                        continue;
                    count=dfs(i,j,grid,lable,count);
                    if(max<count)
                        max=count;
                }
                else
                    continue;
            }
        }
        return max;
    }
};

leedcode 695

改进：不需要标记数组，直接将走过的地方赋值成0，时间和空间都会节省下来

class Solution {
public:
    int dfs(int i,int j,vector<vector<int>>& grid,int count)
    {
        grid[i][j]=0;
        if(i>=1&&grid[i-1][j]==1)//向上
        {
            count=dfs(i-1,j,grid,++count);
        }
        if(i+1<grid.size()&&grid[i+1][j]==1)//向下
        {
            count=dfs(i+1,j,grid,++count);
        }
        if(j>=1&&grid[i][j-1]==1)//向左
        {
            count=dfs(i,j-1,grid,++count);
        }
        if(j+1<grid[0].size()&&grid[i][j+1]==1)//向右
        {
            count=dfs(i,j+1,grid,++count);
        }
        return count;
    }
    int maxAreaOfIsland(vector<vector<int>>& grid)
    {
        int max=0,count=0;
        for(int i=0;i<grid.size();i++)
        {
            vector<int>line=grid[i];
            for(int j=0;j<line.size();j++)
            {
                count=1;
                if(grid[i][j]==0)//0就跳过
                    continue;
                count=dfs(i,j,grid,count);
                if(max<count)
                    max=count;
            }
        }
        return max;
    }
};

leetcode 695

 

leetcode 200. 岛屿数量

和上面的一样，改成char，不需要标记数组，不需要统计每一块内的数量，统计不联通的数量即可

class Solution {
public:
    void dfs(int i,int j,vector<vector<char>>& grid)
    {
        grid[i][j]='0';
        if(i>=1&&grid[i-1][j]=='1')//向上
        {
            dfs(i-1,j,grid);
        }
        if(i+1<grid.size()&&grid[i+1][j]=='1')//向下
        {
            dfs(i+1,j,grid);
        }
        if(j>=1&&grid[i][j-1]=='1')//向左
        {
            dfs(i,j-1,grid);
        }
        if(j+1<grid[0].size()&&grid[i][j+1]=='1')//向右
        {
            dfs(i,j+1,grid);
        }
        return ;
    }
    int numIslands(vector<vector<char>>& grid) {
        int max=0,count=0;
        for(int i=0;i<grid.size();i++)
        {
            vector<char>line=grid[i];
            for(int j=0;j<line.size();j++)
            {
                if(grid[i][j]=='0')//0就跳过
                    continue;
                count++;
                dfs(i,j,grid);
                
            }
        }
        return count;
    }
};

leetcode 200