数据结构和算法经典100题-第21题

题目要求：
给定数组arr,arr[i] == k代表可以从位置i向右跳1~k个距离，比如，arr[2] == 3,代表从位置2可以跳到位置3、位置4或位置5，如果从位置0出发，返回最少跳几次能跳到arr最后的位置上？

解析：
思路：可以考虑从两个角度解决这个问题，关键在于选择参考标准，第一种可以把这个问题归结为到达每个固定坐标至少需要多少步。显然不符合贪心条件，想到用动态规划打表解决。OK这是一种思路。
从另一个角度观察此问题，此问题可以总结为跳跃X步最远能到哪的问题，只要满足X步最远能到的坐标大于等于所求的坐标就可以。下面根据这两个思路分别给出代码和复杂度分析。

思路一：动态规划：
头文件

#ifndef _ALG_15TH_H_
#define _ALG_15TH_H_

#include <vector>

#define MAX_STEPS 65535

class SkipArray {
public:
    SkipArray();
    ~SkipArray();
    int minStep(std::vector<int> &inputArray);
    int minStep(std::vector<int> &inputArray, std::vector<int> &path);
};


#endif

#include <stdio.h>
#include <iostream>
#include <vector>
#ifdef _METHOLD_1_
#include "15.h"

using namespace std;

SkipArray::SkipArray() {}

SkipArray::~SkipArray() {}

int SkipArray::minStep(std::vector<int> &inputArray) {
    int size = inputArray.size();
    if (0 == size || 65535 < size) {
        cout<<"minStep --inputArray is illegal."<<endl;
        return 0;
    }   

    vector<int> steps;
    for (int i = 0; i < size; ++i)
    {   
        steps.push_back(MAX_STEPS);
    }   

    // O(N^2)
    steps[0] = 0;
    for (int i = 0; i < (int)size; ++i) {
        for (int j = 0; j <= inputArray[i]; ++j) {
            if (steps[i+j] > steps[i] + 1) {
                steps[i+j] = steps[i] + 1;
            }   
        }   
    }   

    for (int i = 0; i < size; i++) {
        cout<<"steps["<<i<<"] = "<<steps[i]<<endl;  
    }   

    return steps[9];
}

int main(void) {
    int iarray[] = {3,3,2,5,1,1,1,1,1,1};
    size_t count = sizeof(iarray)/sizeof(int);
    vector<int> ivec(iarray,iarray+count);
  SkipArray skipArray;
  count = skipArray.minStep(ivec);
//    count = minStep(ivec);
   // cout<<"Min steps = "<<count<<endl;
    return 0;
}

可以看到打印结果是3步，是正确的，但时间复杂度是O(N^2),空间复杂度是O(N)
接下来看第二种思路。

int minStep(std::vector<int> &array) {
    if (array.empty()) {
        cout<<"minStep array is empty."<<endl;
        return 0;
    }

    int current = 0;
    int jump = 0;
    int next = 0;
    int tmp = 0;
    int size = (int)array.size();
    //next = array[0];
    cout<<"array size = "<<size<<endl;
// 时间复杂度O(N)，空间复杂度O(1)
    for (int i = 0; i < size; ++i) {
        if (next >= size - 1) {
            return current+1;
        }

        if (jump >= i) {
            int tmp = array[i] + i;
            next = (next < tmp) ? tmp : next;
        } else {
            current++;
            jump = next;
        }
    }

    return current;
}
int main(void) {
    int iarray[] = {3,3,2,5,1,1,1,1,1,1};
    size_t count = sizeof(iarray)/sizeof(int);
    vector<int> ivec(iarray,iarray+count);
//  SkipArray skipArray;
//  count = skipArray.minStep(ivec);
    count = minStep(ivec);
    cout<<"Min steps = "<<count<<endl;
    return 0;
}

---

第一种方法时间复杂度是O(N^2),空间复杂度是O(N);
可以看到第二种方法的时间复杂度是O(N),空间复杂度是O(1)。
所以第二种方法更优。

---

OKay,路漫漫其修远兮