LeeCode 45 dp + 线段树 / 贪心法

题意

传送门 LeeCode 45. 跳跃游戏 II

题解

dp + 线段树

dp 基本思路是从终点返回，每一个位置从可前进位置中找最小值

d p [ i ] = m i n i + 1 ≤ j ≤ i + n u m s [ i ] { d p [ j ] } + 1 dp[i]=min_{i+1\leq j\leq i+nums[i]}\{dp[j]\}+1 dp[i]=mini+1≤j≤i+nums[i]​{dp[j]}+1

区间查询用线段树维护，复杂度 $O(nlogn)$。

class Solution {
public:
    int INF = 0x3f3f3f3f;
    void init(vector<int>& nums, vector<int>& st, int k, int l, int r){
        if(r - l == 1){
            st[k] = nums[l];
            return;
        }
        int chl = (k << 1) + 1, chr = (k << 1) + 2, m = (l + r) >> 1;
        init(nums, st, chl, l, m);
        init(nums, st, chr, m, r);
        st[k] = min(st[chl], st[chr]);
    }
    void update(vector<int>& st, int a, int b, int v, int k, int l, int r){
        if(a <= l && r <= b) st[k] = min(st[k], v);
        else if(r <= a || b <= l) return;
        else{
            int chl = (k << 1) + 1, chr = (k << 1) + 2, m = (l + r) >> 1;
            update(st, a, b, v, chl, l, m);
            update(st, a, b, v, chr, m, r);
            st[k] = min(st[chl], st[chr]);
        }
    }
    int query(vector<int>& st, int a, int b, int k, int l, int r){
        if(a <= l && r <= b) return st[k];
        if(r <= a || b <= l) return INF;
        int chl = (k << 1) + 1, chr = (k << 1) + 2, m = (l + r) >> 1;
        return min(query(st, a, b, chl, l, m), query(st, a, b, chr, m, r));
    }
    int jump(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n, INF);
		// 初始化 dp
        dp[n - 1] = 0;
        for(int i = 0; i < n - 1; i++){
            if(i + nums[i] >= n - 1) dp[i] = 1;
        }
		// 初始化线段树
        int x = 1;
        while(x < n) x <<= 1;
        vector<int> st(x << 1);
        init(dp, st, 0, 0, n);
		// 从终点开始 dp
        for(int i = n - 2; i >= 0; i--){
            int tmp;
            if(dp[i] > (tmp = 1 + query(st, i + 1, min(n, i + nums[i] + 1), 0, 0, n))){
                dp[i] = tmp;
                update(st, i, i + 1, dp[i], 0, 0, n);
            }
        }

        return dp[0];
    }
};

贪心法

维护上一步终点与这一步终点间各点能抵达的最远距离（有点类似 $bfs$），将其设为下一步的终点，步数增一，可以贪心求得最短步数。

class Solution {
public:
    int jump(vector<int>& nums) {
        int n = nums.size(), maxpos = 0, end = 0, step = 0;
        for(int i = 0; i < n - 1; i++){
            maxpos = max(maxpos, i + nums[i]);
            if(i == end) ++step, end = maxpos;
        }
        return step;
    }
};