leetcode-算法基础-5、6、7、8

leetcode-算法基础-5、6、7、8

---

438. 找到字符串中所有字母异位词

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int n = s.size(), m = p.size();
        int left = 0, right = 0;
        vector<int> mp(26), np(26);
        vector<int> ans;

        for ( auto& ch : p ){
            mp[ch-'a']++;
        }

        while (right < n){
            np[s[right]-'a']++;
            if (right-left == m){
                np[s[left]-'a']--;
                left++;
            }

            if (mp == np){
                ans.push_back(left);
            }
            right++;
        }

        return ans;
    }
};

713. 乘积小于 K 的子数组

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int n = nums.size(), ans = 0, tmp = 1;
        int left = 0, right = 0;

        while (right < n){
            tmp *= nums[right];
            while ( left <= right && tmp >= k ){
                tmp /= nums[left];
                left++;
            }

            ans += right-left+1;
            right++;
        }

        return ans;
    }
};

209. 长度最小的子数组

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size(), ans = INT_MAX, tmp = 0;
        int left = 0, right = 0;
        
        while ( right < n ){
            tmp += nums[right];
            while ( tmp-nums[left] >= target ){
                tmp -= nums[left];
                left++;
            }
            if ( tmp >= target ){
                ans = min(ans, right-left+1);
            }
            right++;
        }

        return ans == INT_MAX ? 0 : ans;
    }
};

200. 岛屿数量

class Solution {
public:
    vector<int> dic{-1, 0, 1, 0, -1};
    void dfs(vector<vector<char>>& grid, int i, int j){
        int x, y;
        for ( int k = 0 ; k < 4 ; ++k ){
            x = i + dic[k], y = j + dic[k+1];
            if ( x >= 0 && y >= 0 && x < grid.size() && y < grid[0].size() && grid[x][y] == '1' ){
                grid[x][y] = '0';
                dfs(grid, x, y);
            }
        }
    }

    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size(), m = grid[0].size();
        int ans = 0;
        for ( int i = 0 ; i < n ; ++i ){
            for ( int j = 0 ; j < m ; ++j ){
                if ( grid[i][j] == '1' ){
                    grid[i][j] = '0';
                    dfs(grid, i, j);
                    ans++;
                }
            }
        }
        return ans;
    }
};

547. 省份数量

class Solution {
public:
    void dfs(vector<vector<int>>& isConnected, vector<int>& flag, int n, int i){
        for ( int j = 0 ; j < n ; ++j ){
            if ( isConnected[i][j] && !flag[j] ){
                flag[j] = 1;
                dfs(isConnected, flag, n, j);
            }
        }
    }


    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        int ans = 0;
        vector<int> flag(n, 0);

        for ( int i = 0 ; i < n ; ++i ){
            if ( !flag[i] ){
                dfs(isConnected, flag, n, i);
                ans++;
            }
        }

        return ans;
    }
};

117. 填充每个节点的下一个右侧节点指针 II

class Solution {
public:
    Node* connect(Node* root) {
        if (!root){
            return nullptr;
        }

        queue<Node*> q;
        q.push(root);

        while(q.size()){
            int n = q.size();
            Node* start = nullptr;
            for ( int i = 0 ; i < n ; ++i ){
                Node* a = q.front();
                q.pop();
                if ( a->left ){
                    q.push(a->left);
                }
                if ( a->right ){
                    q.push(a->right);
                }

                if ( i != 0 ){
                    start->next = a;
                }
                start = a;
            }
        }
        return root;
    }
};

1091. 二进制矩阵中的最短路径

class Solution {
public:
    vector<vector<int>> dic{{-1,-1}, {-1,0}, {0,-1}, {-1,1}, {1,-1}, {1,1}, {1,0}, {0,1}};
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        if(grid[0][0]==1)return -1;
        int n = grid.size();
        grid[0][0] = 1;
        int ans = 1;
        queue<pair<int, int>> q;
        q.emplace(0, 0);

        while (q.size()){
            int le = q.size();
            while (le--){
                auto [a, b] = q.front();
                q.pop();
                if ( a == n-1 && b == n-1 ){
                    return ans;
                }

                int x, y;
                for ( int k = 0 ; k < 8 ; ++k ){
                    x = a + dic[k][0];
                    y = b + dic[k][1];

                    if ( x >= 0 && y >= 0 && x < n && y < n && grid[x][y] == 0){
                        q.emplace(x, y);
                        grid[x][y] = 1;
                    }
                }
            }
            ++ans;
        }
        
        return -1;
    }
};

130. 被围绕的区域

class Solution {
public:
    vector<int> dir{-1, 0, 1, 0, -1};
    void dfs(vector<vector<char>>& board, vector<vector<char>>& flag, int i, int j){
        if ( i < 0 || j < 0 || i >= board.size() || j >= board[0].size() || board[i][j] == 'X' || flag[i][j] == 'O' ){
            return;
        }

        flag[i][j] = 'O';
        int x, y;
        for ( int k = 0 ; k < 4 ; ++k ){
            x = i + dir[k], y = j + dir[k+1];
            dfs(board, flag, x, y);
        }
    }

    void solve(vector<vector<char>>& board) {
        int n = board.size(), m = board[0].size();
        vector<vector<char>> flag(n, vector<char>(m, 'X'));

        for ( int i = 0 ; i < n ; ++i ){
            for ( int j = 0 ; j < m ; ++j ){
                if ( ( i == 0 || j == 0 || i == n-1 || j == m-1 ) && board[i][j] == 'O' ){
                    dfs(board, flag, i, j);
                }
            }
        }

        board = flag;
    }
};

797. 所有可能的路径

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> tmp{0};
    void dfs(vector<vector<int>>& graph, int i, int  n){
        if ( i == n-1 ){
            ans.push_back(tmp);
            return ;
        }

        for ( int k = 0 ; k < graph[i].size() ; ++k ){
            tmp.push_back(graph[i][k]);
            dfs(graph, graph[i][k], n);
            tmp.pop_back();
        }
    }

    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        int n = graph.size();
        dfs(graph, 0, n);
        return ans;
    }
};

---