LeetCode学习-第三十天

第二十九天

我使用的C++，错误的地方请见谅，文章初衷仅用来督促本人学习，如果恰巧能够给你带来帮助，我会十分开心。

一、39. 组合总和

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

class Solution {
public:
    vector<string> ans;
    string stk;
    void back (int n, int left, int right){
        if (stk.size() == n * 2){
            ans.push_back(stk);
            return;
        }
        if (left < n){
            stk.push_back('(');
            back(n, left + 1, right);
            stk.pop_back();
        }
        if (left > right){
            stk.push_back(')');
            back(n, left, right + 1);
            stk.pop_back();
        }
    }
    vector<string> generateParenthesis(int n) {
        //括号的有效组合，这里的时间复杂度是第n个卡特兰数，不知道是怎么来的
        back(n, 0, 0);
        return ans;
    }
};

双变量递归

二、79. 单词搜索

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    bool back (vector<vector<char>>& board, string& word, int i, int j, int cur, vector<vector<int>>& visited){
        if (board[i][j] != word[cur]){
            return false;
        }
        else if (cur == word.size() - 1){
            return true;
        }
        
        vector<pair<int, int>> dirs{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
        visited[i][j] = true;
        bool result = false;
        
        for (const auto& dir : dirs){
            int ni = i + dir.first, nj = j + dir.second;
            if (ni >= 0 && ni < board.size() && nj >= 0 && nj < board[0].size() && !visited[ni][nj]){
                bool flag = back(board, word, ni, nj, cur + 1, visited);
                if (flag){
                    result = true;
                    break;
                }
            }
        }
        visited[i][j] = false;
        return result;
    }
    bool exist(vector<vector<char>>& board, string word) {
        //深度优先遍历，思路还是很清晰的，遍历整个矩阵，对每一个正确的开头进行深度遍历,需要一个visited来避免重复遍历
        
        vector<vector<int>> visited(board.size(), vector<int>(board[0].size()));

        for (int i = 0; i < board.size(); ++i){
            for (int j = 0; j < board[0].size(); ++j){
                bool flag = back(board, word, i, j, 0, visited);
                if (flag){
                    return true;
                }
            }
        }
        return false;
    }
};

三、213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int Rob (vector<int>& nums, int start, int end){
        int first = nums[start], second = max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; ++i){
            int temp = second;
            second = max(first + nums[i], second);
            first = temp;
        }
        return second;
    }
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n == 1){
            return nums[0];
        }
        else if (n == 2){
            return max(nums[0], nums[1]);
        }
        
            return max(Rob(nums, 0, n - 2), Rob(nums, 1, n - 1));
        
    }
};