HOT100与剑指Offer

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划刷完hot100和剑指Offer的刷题计划，加油！
根据要求，每一道题都要写出两种以上的解题技巧。

一、152. 乘积最大子数组（HOT100）

152. 乘积最大子数组
Note：动态规划解题（这题需要同时记录最大值和最小值，因为负数相乘可能会变成最大值）

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int size = nums.size();
        if (size == 0) return 0;
        if (size == 1) return nums[0];
        //1.确定dp数组（分为两个）
        //i的位置下的以nums[i]结尾的最大乘积
        //i的位置下的以nums[i]结尾的最小乘积
        vector<int> dpMax(size, INT_MIN);
        vector<int> dpMin(size, INT_MAX);

        //2.确定递推公式
        //dpMax[i] = max(max(dpMax[i - 1] * nums[i], nums[i]), dpMin[i - 1] * nums[i]);
        //dpMin[i] = min(min(dpMin[i - 1] * nums[i], nums[i]), dpMax[i - 1] * nums[i]);

        //3.确定dp数组初始化
        int res = nums[0];
        dpMax[0] = nums[0];
        dpMin[0] = nums[0];

        //4.确定遍历顺序
        for (int i = 1; i < size; i++) {
            dpMax[i] = max(max(dpMax[i - 1] * nums[i], nums[i]), dpMin[i - 1] * nums[i]);
            dpMin[i] = min(min(dpMin[i - 1] * nums[i], nums[i]), dpMax[i - 1] * nums[i]);
            res = max(dpMax[i], res);
        }

        //5.确定推导dp数组
        return res;
    }
};

Note：或者也可以使用两个变量做记录，不用dp数组

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int size = nums.size();
        if (size == 0)
            return 0;
        else if (size == 1)
            return nums[0];

        int p = nums[0];
        int maxP = nums[0];
        int minP = nums[0];

        for (int i = 1; i < size; i++) {
            int t = maxP;
            maxP = max(max(maxP * nums[i], nums[i]), minP * nums[i]);
            minP = min(min(t * nums[i], nums[i]), minP * nums[i]);
            p = max(maxP, p);
        }

        return p;
    }
};

二、32. 最长有效括号（HOT100）

32. 最长有效括号

Note：参考大佬做的，很难

class Solution {
public:
    int longestValidParentheses(string s) {
        int size = s.length();
        //1.确定dp数组
        //第i个元素表示以下标为i的字符结尾的最长有效子字符串的长度
        vector<int> dp(size, 0);

        //2.确定递推公式
        //分为两种情况：
        //1. i位为( 这时，s[i]无法和其之前的元素组成有效的括号对
        //1. dp[i] = 0; 
        //2. i位为), 也分为两种情况：
        //2.1 i - 1位为( 有效括号长度新增长度2
        //dp[i] = dp[i - 2] + 2
        //2.2 i - 1位为) 如果前面有和i位组成有效括号对的字符，就要求i − 1位必然是有效的括号对
        //这里还有一个问题，就是必须计算前前一个(i - dp[i - 1] - 2)的位置的dp，防止前面子序列出现()
        //dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2)]

        //3.确定dp数组初始化
        int res = 0;

        //4.确定递推顺序
        for (int i = 1; i < size; i++) {
            if (s[i] == '(')
                dp[i] = 0;
            else {
                if (s[i - 1] == '(') {
                    if (i >= 2)
                        dp[i] = dp[i - 2] + 2;
                    else 
                        dp[i] = 2;
                } else if (dp[i - 1] > 0) {
                    if ((i - dp[i - 1] - 1) >= 0 && s[i - dp[i - 1] - 1] == '(') {
                        if ((i - dp[i - 1] - 2) >= 0)
                            dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2];
                        else 
                            dp[i] = dp[i - 1] + 2;
                    }
                }
            }
            //5.确定推导dp数组
            res = max(res, dp[i]);
        }
        return res;
    }
};

Note：用栈来做相对好理解：用栈维护当前待匹配的左括号的位置，同时用 start 记录一个新的可能合法的子串的起始位置。
如果s[i] ==‘(’，那么进栈
如果s[i] == ‘)’,那么弹出栈顶元素
如果栈为空，说明以当前右括号为右端点的合法括号序列的左端点为start，则更新答案 i - start + 1。
如果栈不为空，说明以当前右括号为右端点的合法括号序列的左端点为栈顶元素的下一个元素，则更新答案i - st.top()
遇到右括号)且当前栈为空，则当前的 start 开始的子串不再可能为合法子串了，下一个合法子串的起始位置可能是 i + 1，更新 start = i + 1

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> st;
        int ans = 0;
        for (int i = 0,start = 0; i < s.size(); i++) 
        {
            if (s[i] == '(') st.push(i);      
            else 
            {
                if (!st.empty()) 
                {
                    st.pop();
                    if (st.empty()) ans = max(ans, i - start + 1);
                    else  ans = max(ans, i - st.top());
                }
                else  start = i + 1;                   
            }
        }
        return ans;
    }
};

总结

祝大家都能学有所成，找到一份好工作！