leetcode 403. 青蛙过河（记忆化搜索+dfs）

题目描述

题目链接：leetcode 403. 青蛙过河（困难）
一只青蛙想要过河。 假定河流被等分为若干个单元格，并且在每一个单元格内都有可能放有一块石子（也有可能没有）。 青蛙可以跳上石子，但是不可以跳入水中。

给你石子的位置列表 stones（用单元格序号 升序 表示）， 请判定青蛙能否成功过河（即能否在最后一步跳至最后一块石子上）。

开始时， 青蛙默认已站在第一块石子上，并可以假定它第一步只能跳跃一个单位（即只能从单元格 1 跳至单元格 2 ）。

如果青蛙上一步跳跃了 k 个单位，那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。 另请注意，青蛙只能向前方（终点的方向）跳跃。

示例 1：

输入：stones = [0,1,3,5,6,8,12,17]
输出：true
解释：青蛙可以成功过河，按照如下方案跳跃：跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后，跳 5 个单位到第 8 个石子（即最后一块石子）。

示例 2：

输入：stones = [0,1,2,3,4,8,9,11]
输出：false
解释：这是因为第 5 和第 6 个石子之间的间距太大，没有可选的方案供青蛙跳跃过去。

提示：

• 2 <= stones.length <= 2000
• 0 <= stones[i] <= $2^{31}$ - 1
• stones[0] == 0

思路

1.由于第一个石头只能跳一个单元格到第二个石头，则第二个石头位置不是1直接返回false。排除前面这种情况，直接从第二个石头开始往后搜，能搜到最后一个石头就能跳到终点。

2.用unordered_map<int,int>map存储石头所在位置（key）和石头的数组下标（value）的映射关系。

3.假设上一步跳了k个单元格到达当前下标为u的石头上，则接下来可以到达的位置为x（x为stones[u]+k-1 、stones[u]+k 、stones[u]+k+1中的任意一个）。假设x在map中（即x落在石头上），就从x处继续搜终点。三条路径中任意一条能到终点，则能从u跳到终点。

4.用vis[u][k]记录状态“上一步跳了k个单元格到达当前下标为u的石头上”能否到达终点。确定了vis[u][k]的值就记录下来，下次遇到此状态直接用，减少递归的时间消耗。

记忆化搜索代码

const int N=2200;
class Solution {
public:
      /*
       dfs参数说明：
       stones:石头位置数组
       t:最后一个石头的下标
       u:当前所在石头的下标
       k:上一步跳跃的距离  
      */
   bool dfs(vector<int>& stones,int t,int u,int k){
        if(vis[u][k]!=-1) return vis[u][k];  //之前记录过这个状态则直接返回
        if(u==t)  return true;        
         unordered_map<int,int>::iterator it; 
         int res=false;
         for(int i=k+1;i>=k-1&&i>0;i--){
             it=map.find(stones[u]+i);
             if(it!=map.end()){   
             //下一步可以跳到石头上，则继续搜索
                res|=dfs(stones,t,(*it).second,i);
             }
         }
         vis[u][k]=res;
         return res;
    }


    bool canCross(vector<int>& stones) {
        if(stones[1]!=1) return false;
        int n=stones.size();
        for(int i=0;i<n;i++){
            map.insert(pair<int,int>(stones[i],i));
        }
        memset(vis,-1,sizeof(vis));
        return dfs(stones,n-1,1,1);
    }


     private:
     int vis[N][N];
     unordered_map<int,int>map;
};

bfs超时代码

和dfs搜索思路相似，但不能优化，故超时。

struct Jump{
    int s;
    int k;
};
class Solution {
public:
    bool canCross(vector<int>& stones) {
    int n=stones.size();
    if(n==1) return true;
    if(stones[1]-stones[0]!=1) return false; 
    unordered_set<int>set;
    for(int i=0;i<n;i++){
        set.insert(stones[i]);
    }
    unordered_set<int>::iterator it; 
    queue<Jump>q;
    q.push((Jump){stones[0],1});
    while(!q.empty()){
        Jump now=q.front();
        q.pop();
        int s=now.s;
        int k=now.k;
        for(int i=k-1;i<=k+1;i++){
           if(i==0) continue; 
           if(s+i==stones[n-1]) return true;
           it=set.find(s+i);
           if(it!=set.end()) q.push((Jump){s+i,i}); 
        }
    }
    return false;
    }
};