LeetCode 热题 HOT 100 第七天

31. 最小覆盖子串：思维很具有跳跃性

思路：哈希+双指针

类似于LC第三题，$t$字符串每个字母的个数，$i$指针不停右移，如果说$hs[s[i]]<=ht[s[i]]$那么合法的字符串长度$+1$，移动左指针直到$hs[s[j]]==ht[[s[j]]$为止，使得当前滑动窗口中的字符串数量最少，那么就得到一个合法的区间，每一次保留长度最短的合法区间

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> hs, ht;
        for (auto& c : t) ht[c] ++ ;

        string res;
        int cnt = 0;
        for (int i = 0, j = 0; i < s.size(); i ++ ) {
            hs[s[i]] ++ ;
            if (hs[s[i]] <= ht[s[i]]) cnt ++ ;
            
            while (hs[s[j]] > ht[s[j]]) hs[s[j ++ ]] -- ;
            if (cnt == t.size()) {
                if(res.empty() || i - j + 1 < res.size())
                    res = s.substr(j, i - j + 1);
            }
        }
        return res;
    }
};

32. 子集

思路一：递归

一个数组记录答案，一个数组记录当前选择的数。
如果已经枚举到最后一位数字就返回

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums, 0);
        return res;
    }

    void dfs(vector<int>& nums, int u) {
        if (u == nums.size()) {
            res.push_back(path);
            return ;
        }
        dfs(nums, u + 1);

        path.push_back(nums[u]);
        dfs(nums, u + 1);
        path.pop_back();


    }
};

思路二：迭代

枚举所有选择的位数，用二进制表示是否选择

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        int n = nums.size();
        for (int i = 0; i < 1 << n; i ++ ) {
            vector<int> path;
            for (int j = 0; j < n; j ++ ) {
                if (i >> j & 1)
                    path.push_back(nums[j]);
            }
            res.push_back(path);
        }
        return res;
    }
};

33. 单词搜索

class Solution {
public:

    int n, m;
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    bool exist(vector<vector<char>>& board, string word) {
        n = board.size(), m = board[0].size();
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ ) {
                    if (dfs(board, word, 0, i, j))
                        return true;
                }
        return false;
    }

    bool dfs(vector<vector<char>>& board, string word, int u, int x, int y) {
        if (board[x][y] != word[u]) return false;
        if (u == word.size() - 1) return true;

        char c = board[x][y];
        board[x][y] = '.';
        for (int i = 0; i < 4; i ++ ) {
            int a = x + dx[i], b = y + dy[i];
            if (a >= 0 && a < n && b >= 0 && b < m && board[a][b] != '.') {
                if (dfs(board, word, u + 1, a, b))
                    return true;
            }
        }
        board[x][y] = c;
        return false;
    }
};

34. 柱状图中的最大矩形

思路：单调栈

分别从两端扫描， 用单调栈维护得到每一个下标左右可以取到的边界

class Solution {
public:
    int largestRectangleArea(vector<int>& h) {
        // 单调栈
        int n = h.size();
        vector<int> l(n), r(n);
        stack<int> stk;
        for (int i = 0; i < n; i ++ ) {
            while (stk.size() && h[stk.top()] >= h[i]) stk.pop();
            if (stk.empty()) l[i] = -1;
            else l[i] = stk.top();
            stk.push(i);
        }

        stk = stack<int>();
        for (int i = n - 1; i >= 0; i -- ) {
            while (stk.size() && h[stk.top()] >= h[i]) stk.pop();
            if (stk.empty()) r[i] = n;
            else r[i] = stk.top();
            stk.push(i);
        }
        int res = 0;
        for (int i = 0; i < n; i ++ )
            res = max(res, h[i] *(r[i] - l[i] - 1));
        return res;
    }
};

35. 最大矩形

思路：

寻找每一行为最下边缘的可以得到的最大矩形，相当于34题的应用

class Solution {
public:
    int largestRectangleArea(vector<int>& h) {
        // 单调栈
        int n = h.size();
        vector<int> l(n), r(n);
        stack<int> stk;
        for (int i = 0; i < n; i ++ ) {
            while (stk.size() && h[stk.top()] >= h[i]) stk.pop();
            if (stk.empty()) l[i] = -1;
            else l[i] = stk.top();
            stk.push(i);
        }

        stk = stack<int>();
        for (int i = n - 1; i >= 0; i -- ) {
            while (stk.size() && h[stk.top()] >= h[i]) stk.pop();
            if (stk.empty()) r[i] = n;
            else r[i] = stk.top();
            stk.push(i);
        }
        int res = 0;
        for (int i = 0; i < n; i ++ )
            res = max(res, h[i] *(r[i] - l[i] - 1));
        return res;
    }
    int maximalRectangle(vector<vector<char>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) return 0;
        int n = matrix.size(), m = matrix[0].size();
        vector<vector<int>> h(n, vector<int>(m));
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ ) {
                if (matrix[i][j] == '1') {
                    if (i) h[i][j] = 1 + h[i - 1][j];
                    else h[i][j] = 1;
                }
            }
        
        int res = 0;
        for(int i = 0; i < n; i ++ )
            res = max(res, largestRectangleArea(h[i]));
        
        return res;
    }
};