题解13-18

32. 最长有效括号 - 力扣（LeetCode）

给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例 1：

输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"

示例 2：

输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"

示例 3：

输入：s = ""
输出：0

提示：

• 0 <= s.length <= 3 * 104
• s[i] 为 '(' 或 ')'

思路:

使用栈来维护当前待匹配的左括号的位置，并使用变量 start 记录一个新的可能合法的子串的起始位置，初始设为 0。

1. 当遇到左括号时，将当前位置进栈。
2. 当遇到右括号时，
   • 如果当前栈不为空，则当前栈顶出栈。出栈后，如果栈为空，则更新答案为 i - start + 1；否则更新答案为 i - st.top()。
   • 如果当前栈为空，则当前的 start 开始的子串不再可能为合法子串了，下一个合法子串的起始位置是 i + 1，更新 start = i + 1。

class Solution {
public:
    int longestValidParentheses(string s) {
        int n = s.size();
        stack<int> st;
        int start = 0, ans = 0;
        for(int i = 0; i < n; i ++)
        {
            if(s[i] == '(')
                st.push(i);
            else
            {
                if(st.size())
                {
                    st.pop();
                    if(st.empty())
                        ans = max(ans, i - start + 1);
                    else
                        ans = max(ans, i - st.top());//这个需要反复思考一下
                }
                else
                {
                    start = i + 1;
                }
            }
        }
        return ans;
    }
};

33. 搜索旋转排序数组 - 力扣（LeetCode）

todo

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

思路:

运用二分来写

class Solution {
    // lower_bound 返回最小的满足 nums[i] >= target 的 i
    // 如果数组为空，或者所有数都 < target，则返回 nums.size()
    // 要求 nums 是非递减的，即 nums[i] <= nums[i + 1]
    // 开区间写法
    int lower_bound3(vector<int> &nums, int target) {
        int left = -1, right = nums.size(); // 开区间 (left, right)
        while (left + 1 < right) { // 区间不为空
            // 循环不变量：
            // nums[left] < target
            // nums[right] >= target
            int mid = left + (right - left) / 2;
            if (nums[mid] >= target)
                right = mid; // 范围缩小到 (mid, right)
            else
                left = mid; // 范围缩小到 (left, mid)
        }
        return right; // 或者 left+1
    }

public:
    vector<int> searchRange(vector<int> &nums, int target) {
        int start = lower_bound3(nums, target); // 使用其中一种写法即可
        if (start == nums.size() || nums[start] != target)
            return {-1, -1};
        // 如果 start 存在，那么 end 必定存在
        int end = lower_bound3(nums, target + 1) - 1;
        //找到最后一个>=8的数,等价于找到第一个>=9的数的前面那个数
        return {start, end};
    }
};

39. 组合总和 - 力扣（LeetCode）

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

• 1 <= candidates.length <= 30
• 2 <= candidates[i] <= 40
• candidates 的所有元素 互不相同
• 1 <= target <= 40

思路:

经典dfs问题,需要注意的是因为可以无限次选取,所以我们只需要注意每次传入的下标都是不变的

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    void dfs(vector<int> candidates, int sum, int target, int startindex)
    {
        if(sum > target)
            return;
        if(sum == target)
        {
            ans.push_back(path);
            return;
        }
        for(int i = startindex; i < candidates.size(); i ++)
        {
            sum += candidates[i];
            path.push_back(candidates[i]);
            dfs(candidates, sum, target, i);
            path.pop_back();
            sum -= candidates[i];
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        dfs(candidates, 0, target, 0);
        return ans;
    }
};

42. 接雨水 - 力扣（LeetCode）

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示：

• n == height.length
• 1 <= n <= 2 * 104
• 0 <= height[i] <= 105

思路:

这道题有多个思路,这里先写一个前后缀分解的思路,前后缀分解最需要注意的是下标问题,前缀是i - 1,后缀是i + 1

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        vector<int> pre(n);
        pre[0] = height[0];
        for(int i = 1; i < n; i ++)
        {
            pre[i] = max(pre[i - 1], height[i]);
        }
        vector<int> suf(n);
        suf[n - 1] = height[n - 1];
        for(int i = n - 2; i >= 0; i --)
        {
            suf[i] = max(suf[i + 1], height[i]);
        }
        int ans = 0;
        for(int i = 0; i < n; i ++)
            ans += min(pre[i], suf[i]) - height[i];
        return ans;
    }
};

46. 全排列 - 力扣（LeetCode）

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示：

• 1 <= nums.length <= 6
• -10 <= nums[i] <= 10
• nums 中的所有整数 互不相同

思路:

这道题也是dfs的问题,因为这里需要统计的是全排列,所以我们可以使用一个used数组来检查是否有放入排列中

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    void dfs(vector<int>& nums, vector<bool>& used)
    {
        if(path.size() == nums.size())
        {
            ans.push_back(path);
            return;
        }
        for(int i = 0; i < nums.size(); i ++)
        {
            if(!used[i])
            {
                path.push_back(nums[i]);
                used[i] = true;
                dfs(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        dfs(nums, used);
        return ans;
    }
};