Leetcode之跳跃游戏整理

1306. 跳跃游戏 III

题目：

这里有一个非负整数数组 arr，你最开始位于该数组的起始下标 start 处。当你位于下标 i 处时，你可以跳到 i + arr[i] 或者 i - arr[i]。

请你判断自己是否能够跳到对应元素值为 0 的 任一 下标处。

注意，不管是什么情况下，你都无法跳到数组之外。

示例 1：

输入：arr = [4,2,3,0,3,1,2], start = 5
输出：true
解释：
到达值为 0 的下标 3 有以下可能方案： 
下标 5 -> 下标 4 -> 下标 1 -> 下标 3 
下标 5 -> 下标 6 -> 下标 4 -> 下标 1 -> 下标 3 
示例 2：

输入：arr = [4,2,3,0,3,1,2], start = 0
输出：true 
解释：
到达值为 0 的下标 3 有以下可能方案： 
下标 0 -> 下标 4 -> 下标 1 -> 下标 3
示例 3：

输入：arr = [3,0,2,1,2], start = 2
输出：false
解释：无法到达值为 0 的下标 1 处。 

提示：

1 <= arr.length <= 5 * 10^4
0 <= arr[i] < arr.length

代码：

方法一——深度优先搜索递归+记忆化搜索：

class Solution {
public:
    vector<int> record;

bool tranverse(vector<int>& arr,set<int>& visited, int start){
    int len=arr.size();
    if(start<0||start>=len)return false;
    if(record[start]!=-1)return record[start];
    
    if(arr[start]==0){
        record[start]=true;
        return true;}
    bool temp=false;
    if(!visited.count(start-arr[start])){
        visited.insert(start-arr[start]);
        temp=temp|tranverse(arr,visited,start-arr[start]);
        visited.erase(start-arr[start]);
    }
    if(!visited.count(start+arr[start])){
        visited.insert(start+arr[start]);
        temp=temp|tranverse(arr,visited,start+arr[start]);
        visited.erase(start+arr[start]);
    }
    record[start]=temp;
    return record[start];
}

bool canReach(vector<int>& arr, int start) {
    int len=arr.size();
    record.resize(len, -1);
    set<int> visited;
    return tranverse(arr,visited,start);
}

};

思路：递归+记忆化搜索，模拟跳跃过程；

方法二——广度优先搜索：

class Solution {
public:

bool canReach(vector<int>& arr, int start) {
    if(arr[start]==0){
        return true;
    }
    int n=arr.size();
    vector<bool> used(n);
    queue<int> q;
    q.push(start);
    used[start]=true;

    while(!q.empty()){
        int u=q.front();
        q.pop();
        if(u+arr[u]<n&&!used[u+arr[u]]){
            if(arr[u+arr[u]]==0)return true;
            q.push(u+arr[u]);
            used[u+arr[u]]=true;
        }
        if(u-arr[u]>=0&&!used[u-arr[u]]){
            if(arr[u-arr[u]]==0)return true;
            q.push(u-arr[u]);
            used[u-arr[u]]=true;
        }
    }
    return false;
}

};

想法：广度优先遍历和深度优先遍历都可以尝试，广度优先遍历一般是和队列queue相关，深度优先遍历一般是和递归相关；广度优先遍历首先把start放到队列中，然后遍历start未访问的左右符合条件的点，看是否是0，如果是0，返回true，如果不是0，那么可以放到队列中去；依次类推，如果最后都没有返回true,表示访问不到下标为0的点，如果最后返回了true，这表示可以访问到下标为0的点；

1340. 跳跃游戏 V

题目：

给你一个整数数组 arr 和一个整数 d 。每一步你可以从下标 i 跳到：

i + x ，其中 i + x < arr.length 且 0 < x <= d 。
i - x ，其中 i - x >= 0 且 0 < x <= d 。
除此以外，你从下标 i 跳到下标 j 需要满足：arr[i] > arr[j] 且 arr[i] > arr[k] ，其中下标 k 是所有 i 到 j 之间的数字（更正式的，min(i, j) < k < max(i, j)）。

你可以选择数组的任意下标开始跳跃。请你返回你 最多 可以访问多少个下标。

请注意，任何时刻你都不能跳到数组的外面。

示例 1：

输入：arr = [6,4,14,6,8,13,9,7,10,6,12], d = 2
输出：4
解释：你可以从下标 10 出发，然后如上图依次经过 10 --> 8 --> 6 --> 7 。
注意，如果你从下标 6 开始，你只能跳到下标 7 处。你不能跳到下标 5 处因为 13 > 9 。你也不能跳到下标 4 处，因为下标 5 在下标 4 和 6 之间且 13 > 9 。
类似的，你不能从下标 3 处跳到下标 2 或者下标 1 处。
示例 2：

输入：arr = [3,3,3,3,3], d = 3
输出：1
解释：你可以从任意下标处开始且你永远无法跳到任何其他坐标。
示例 3：

输入：arr = [7,6,5,4,3,2,1], d = 1
输出：7
解释：从下标 0 处开始，你可以按照数值从大到小，访问所有的下标。
示例 4：

输入：arr = [7,1,7,1,7,1], d = 2
输出：2
示例 5：

输入：arr = [66], d = 1
输出：1

提示：

1 <= arr.length <= 1000
1 <= arr[i] <= 10^5
1 <= d <= arr.length

代码：

class Solution {
private:
    vector<int> f;
    
public:
    void dfs(vector<int>& arr, int id, int d, int n) {
        if (f[id] != -1) {
            return;
        }
        f[id] = 1;
        for (int i = id - 1; i >= 0 && id - i <= d && arr[id] > arr[i]; --i) {
            dfs(arr, i, d, n);
            f[id] = max(f[id], f[i] + 1);
        }
        for (int i = id + 1; i < n && i - id <= d && arr[id] > arr[i]; ++i) {
            dfs(arr, i, d, n);
            f[id] = max(f[id], f[i] + 1);
        }
    }
    
    int maxJumps(vector<int>& arr, int d) {
        int n = arr.size();
        f.resize(n, -1);
        for (int i = 0; i < n; ++i) {
            dfs(arr, i, d, n);
        }
        return *max_element(f.begin(), f.end());
    }
};

思路：

dp[i]=max(dp[j])+1,其中j在数组内，且在i左d右d范围内，且d[i]大于i到j之间的元素；

这里可以用递归和记忆化搜索方法，使用一个数组保存dp[i]，然后对每一个i进行递归，如果这个算过了，那么可以记忆化直接return；如果没算过，那么在他左右小于这个元素，且d范围内分别递归，选最大的dp[i]，根据动态规划公式进行计算；

1345. 跳跃游戏 IV

题目：

给你一个整数数组 arr ，你一开始在数组的第一个元素处（下标为 0）。

每一步，你可以从下标 i 跳到下标：

i + 1 满足：i + 1 < arr.length
i - 1 满足：i - 1 >= 0
j 满足：arr[i] == arr[j] 且 i != j
请你返回到达数组最后一个元素的下标处所需的 最少操作次数 。

注意：任何时候你都不能跳到数组外面。

示例 1：

输入：arr = [100,-23,-23,404,100,23,23,23,3,404]
输出：3
解释：那你需要跳跃 3 次，下标依次为 0 --> 4 --> 3 --> 9 。下标 9 为数组的最后一个元素的下标。
示例 2：

输入：arr = [7]
输出：0
解释：一开始就在最后一个元素处，所以你不需要跳跃。
示例 3：

输入：arr = [7,6,9,6,9,6,9,7]
输出：1
解释：你可以直接从下标 0 处跳到下标 7 处，也就是数组的最后一个元素处。
示例 4：

输入：arr = [6,1,9]
输出：2
示例 5：

输入：arr = [11,22,7,7,7,7,7,7,7,22,13]
输出：3

提示：

1 <= arr.length <= 5 * 10^4
-10^8 <= arr[i] <= 10^8

代码：

方法一——递归(超时):

class Solution {
public:
    int minnum=INT_MAX;
void tranverse(map<int,vector<int>>& m,vector<bool>& visted,int current,vector<int>& arr,int times){
    if(current<0||current>=arr.size())return;

    if(visted[current])return;

    if(current==arr.size()-1){
        minnum=min(minnum,times);
        return;
    }

    visted[current]=true;

    tranverse(m,visted,current+1,arr,times+1);
    tranverse(m,visted,current-1,arr,times+1);

    vector<int> temp=m[arr[current]];
    for(int i=0;i<temp.size();i++){
        if(temp[i]!=current){
            tranverse(m,visted,temp[i],arr,times+1);
        }
    }

    visted[current]= false;
}

int minJumps(vector<int>& arr){
    int len=arr.size();
    map<int,vector<int>> m;
    for(int i=0;i<arr.size();i++){
        m[arr[i]].push_back(i);
    }
    vector<bool> visted(len,false);
    tranverse(m,visted,0,arr,0);
    return minnum;
}
};

方法二——记忆化搜索：

class Solution {
public:

int minJumps(vector<int>& arr){
    int n = arr.size();

    unordered_map<int, vector<int>> height_idx;     //相同高度的 点的indedx
    for (int i = 0; i < n; i ++)
        height_idx[arr[i]].push_back(i);
    
    vector<bool> visited(n, false);
    queue<tuple<int,int>> Q;
    
    Q.push(make_tuple(0, 0));
    visited[0] = true;
    
    while(Q.size())                     //记忆化 + BFS + 不回头
    {
        auto[i, step] = Q.front();  Q.pop();
        vector<int> tmp = height_idx[arr[i]];    tmp.push_back(i-1);     tmp.push_back(i+1);
        for(int j:tmp){
            if(0<=j&&j<n&&visited[j]==false){
                if(j==n-1)
                    return step+1;
                visited[j]=true;
                Q.push(make_tuple(j,step+1));
            }
        }
        height_idx[arr[i]]={};  //这个高度的都已经搞定了，不用下一个相同高度的index重复遍历判断了！！(否则TLE)
    }
    return 0;
}
};

使用BFS进行搜索，比DFS好一些，因为这里求的是最短的步数，所以采用不回头的话，就直接过滤了有环的情况；每一个高度的都搞定以后，就进行清理，不需要在这里浪费时间了；