HOT100与剑指Offer

---

前言

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

一、53. 最大子数组和（HOT100）

53. 最大子数组和
Note：贪心解题，类似寻找最大最小值的题目，初始值一定要定义成理论上的最小最大值

class Solution
{
public:
    int maxSubArray(vector<int> &nums)
    {
        int result = INT_MIN;
        int numsSize = int(nums.size());
        int sum = 0;
        for (int i = 0; i < numsSize; i++)
        {
            sum += nums[i];
            result = max(result, sum);
            //如果sum < 0，重新开始找子序串
            if (sum < 0)
            {
                sum = 0;
            }
        }

        return result;
    }
};

Note：动态规划解题

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        //1. 确定dp数组（dp table）以及下标的含义
        //dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。
        vector<int> dp(nums.size());
        
        //2. 确定递推公式
        //dp[i] = max(nums[i], dp[i - 1] + nums[i]);

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

        //4. 确定遍历顺序
        for (int i = 1; i < nums.size(); i++) {
            dp[i] = max(nums[i], dp[i - 1] + nums[i]);
            res = dp[i] > res ? dp[i] : res;
        }

        //5. 确定推导结果
        return res;
    }
};

二、20. 把数字翻译成字符串（剑指Offer）

把数字翻译成字符串

Note：动态规划解题

class Solution {
public:
    int getTranslationCount(string s) {
        int size = s.size();
        if (size <= 0) return 0;
        //if (size == 1) return 1;
        
        //1.确定dp数组
        //长度为i的数字翻译为字符串数目
        vector<int> dp(size, 0);
        
        //2.确定dp公式
        //判断是否为26以下组合，是的话就需要dp[i] += dp[i + 2];
        
        //3.确定dp数组初始化值
        dp[size] = 1;
        dp[size - 1] = 1;
        
        //4.确定遍历顺序
        for (int i = size - 2; i >= 0; i--) {
            dp[i] = dp[i + 1];
            if (s[i] == '1' || (s[i] == '2' && s[i+1] < '6'))
                dp[i] += dp[i + 2];
        }
        
        //5.确定输出结果
        return dp[0];
    }
};

Note：深度优先搜索
当时位，如果是0，不能解码，返回0；
情况1:当前位解码为1-9，遍历下一位；
情况2:若当前位和下一位可以解码为10-26，遍历下下一位。//需要判断下一位是否存在，避免数组越界
情况1和情况2的和，就是本位开始，可以解码的情况。
边界条件，若当前位超过了s的长度，返回1。

减枝
通过n+1的数组记录pos位开始的字符串可以解码的数量。降低复杂度。

//
class Solution {
    vector<int> dp;
public:
    int getTranslationCount(string s) {
        int n = s.size();
        dp.resize(n+1, -1);
        return help(s, 0);
    }
    int help(string& s, int point){
        if(point >= s.size()) return 1;
        int num1 = s[point] - '0';
        if(num1 == 0) return 0;
        int ret = dp[point+1] == -1 ? help(s,point+1):dp[point+1];
        if(point + 1 >= s.size()) {
            dp[point] = ret;
            return ret;
        }
        int num2 = s[point+1] - '0';
        if((num1 * 10 + num2) <= 26)
        ret += dp[point+2] == -1 ? help(s,point+2):dp[point+2];
        dp[point] = ret;
        return ret;
    }
};

总结

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