代码随想录day29

最新推荐文章于 2024-07-24 20:44:05 发布

想进个大厂

最新推荐文章于 2024-07-24 20:44:05 发布

阅读量22

点赞数

文章标签：深度优先算法 leetcode

本文链接：https://blog.csdn.net/JC0728/article/details/131946794

版权

491递增子序列

class Solution {
public:
    vector<int>path;
    vector<vector<int>>res;
    vector<vector<int>> findSubsequences(vector<int>& nums)     
    {
        dfs(nums,0);
        return res;
    }
    void dfs(vector<int>& nums,int index)
    {
        if (path.size()>=2) 
        {
            res.push_back(path);
        }
        unordered_set<int> used;
        for(int i=index;i<nums.size();i++)
        {
            if(path.size()>0&&path.back()>nums[i]||used.count(nums[i]))
            {
                continue;
            }
            used.insert(nums[i]);
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }
    }
};

827最大人工岛

class Solution {
public:
    int result=0;
    int res=0;
    int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; 
    int largestIsland(vector<vector<int>>& grid) 
    {
        int m=grid.size();
        int n=grid[0].size();
        unordered_map<int ,int> gridNum;
        int mark=2;
        for (int i = 0; i < m; i++) 
        {
            for (int j = 0; j < n; j++) 
            {
                if (grid[i][j] == 1) 
                {
                    res = 0;
                    dfs(grid,i,j,mark);
                    gridNum[mark++] = res;
                    result=max(result,res);
                }
            }
        }
        for (int i = 0; i < m; i++) 
        {
            for (int j = 0; j < n; j++) 
            {
                if (grid[i][j] == 0) 
                {
                    int cur = 1; 
                    unordered_set<int> v; 
                    for (int k = 0; k < 4; k++) 
                    {
                        int neari = i + dir[k][1];
                        int nearj = j + dir[k][0];
                        if (neari < 0 || neari >= grid.size() || nearj < 0 || nearj >= grid[0].size()) continue;
                        if (v.count(grid[neari][nearj])) continue;
                        cur += gridNum[grid[neari][nearj]];   
                        v.insert(grid[neari][nearj]);
                    }
                    result = max(result, cur);
                }
                
            }
        }
        return result;
    }
    void dfs(vector<vector<int>>& grid,int i,int j, int mark)
    {
        if(i<0||i>=grid.size()||j<0||j>=grid[0].size()) return;
        if(grid[i][j]!=1) return;
        grid[i][j]=mark;
        res++;
        dfs(grid, i + 1, j, mark);
        dfs(grid, i, j + 1, mark);
        dfs(grid, i - 1, j, mark);
        dfs(grid, i, j - 1, mark);
    }
};