leetcode 656. Coin Path

Given an array A (index starts at 1) consisting of N integers: A1, A2, ..., AN and an integer B. The integer B denotes that from any place (suppose the index is i) in the array A, you can jump to any one of the place in the array A indexed i+1, i+2, …, i+B if this place can be jumped to. Also, if you step on the index i, you have to pay Ai coins. If Ai is -1, it means you can’t jump to the place indexed i in the array.

Now, you start from the place indexed 1 in the array A, and your aim is to reach the place indexed N using the minimum coins. You need to return the path of indexes (starting from 1 to N) in the array you should take to get to the place indexed N using minimum coins.

If there are multiple paths with the same cost, return the lexicographically smallest such path.

If it's not possible to reach the place indexed N then you need to return an empty array.

Example 1:

Input: [1,2,4,-1,2], 2
Output: [1,3,5]

Example 2:

Input: [1,2,4,-1,2], 1
Output: []

Note:

1. Path Pa1, Pa2, ..., Pan is lexicographically smaller than Pb1, Pb2, ..., Pbm, if and only if at the first i where Pai and Pbi differ, Pai < Pbi; when no such i exists, then n < m.
2. A1 >= 0. A2, ..., AN (if exist) will in the range of [-1, 100].
3. Length of A is in the range of [1, 1000].
4. B is in the range of [1, 100].

dp 输出路径

class Solution {
public:
    const int inf = 0x3f3f3f3f;
    vector<int> cheapestJump(vector<int>& A, int B) {
        vector<int> v;
        int n = A.size();
        if (n == 0 || A[n - 1] == -1) return v;
        vector<int> dp(n, inf);
        vector<int> pre(n, -1);
        dp[n - 1] = A[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            if (A[i] == -1) continue;
            for (int j = 1; j <= B; ++j) {
                if (i + j < n && dp[i + j] + A[i] < dp[i]) {
                    dp[i] = dp[i + j] + A[i];
                    pre[i] = i + j;
                }
             }
        }
        int m = 0;
        if (dp[0] == inf ) return v; 
        while (m != -1) {
            v.push_back(m + 1);
            m = pre[m];
        }
        return v;
    }
};