HOT100与剑指Offer

---

前言

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

一、55. 跳跃游戏（HOT100）

55. 跳跃游戏
Note：贪心解题，首先进行边界判断，然后循环遍历能跳跃的最大范围，并且循环也每次更新。在循环中判断是否能够跳到终点并输出true

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if (nums.empty()) return true;
        if (nums.size() == 1) return true;

        int res = 0;

        for (int i = 0; i <= res; i++) {
            res = max(res, nums[i] + i);
            if (res >= nums.size() - 1) return true;
        }
        return false;
    }
};

Note：动态规划解题

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if (nums.empty()) return true;
        if (nums.size() == 1) return true;

        int len = nums.size();

        //1.确定dp数组
        //在该位置上能往前跳动的最大距离
        vector<int> dp(len);

        //2.确定dp公式
        //dp[i] = max(dp[i - 1] - 1, nums[i]); 

        //3.确定数组初始化
        dp[0] = nums[0];
        if (dp[0] == 0) return false;

        //4.确定遍历顺序
        for (int i = 1; i < len - 1; i++) {
            dp[i] = max(dp[i - 1] - 1, nums[i]);
            if (dp[i] == 0) return false;
        }

        //5.确定输出结果
        return true;
    }
};

二、45. 跳跃游戏 II（HOT100）

45. 跳跃游戏 II

Note：贪心解题，与上一题类似，判断最大的范围覆盖，如果覆盖不到终点，就必须增加一步。并且需要记录当前这一步的最大范围覆盖和下一步最大范围覆盖。

class Solution {
public:
    int jump(vector<int>& nums) {
        if (nums.empty()) return 0;

        int len = nums.size();
        int maxDistance = 0;
        int res = 0;
        int nextDistance = 0;

        if (len == 1) return 0;

        for (int i = 0; i < len; i++) {
            nextDistance = max(nums[i] + i, nextDistance);

            if (i == maxDistance) {
                res++;
                maxDistance = nextDistance;
                if (nextDistance >= len - 1)
                    break;
            }
        }
        return res;
    }
};

Note：动态规划

class Solution {
public:
    int jump(vector<int>& nums) {
        int len = nums.size();
        //1.确定dp数组
        //能够到达该位置的最少步数
        vector<int> dp(len, INT_MAX);

        //2.确定dp公式
        //dp[i] = min(dp[i], dp[j] + 1);

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

        //4.确定遍历顺序
        for (int i = 1; i < len; i++) {
            for (int j = 0; j < i; j++) {
                if (j + nums[j] >= i)
                    dp[i] = min(dp[i], dp[j] + 1);
            }
        }

        //5.确定输出结果
        return dp[len - 1];
    }
};

总结

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