class Solution {

public:

    bool canCross(vector<int>& stones) {

        if(stones[1]-stones[0]>1)

            return false;

        if(stones.size()==2)

            return (stones[1]-stones[0]==1);

        vector<vector<int>> dp(stones.size(), vector<int> (stones[stones.size()-1]-stones[0], -1));

        return func(0, 1, stones, dp);

    }

    bool func(int i, int jumps, vector<int> &stones, vector<vector<int>> &dp){

        if(i==stones.size()-1)

            return true;

        if(dp[i][jumps] != -1)

            return dp[i][jumps];

        bool ans=false;

        for(int ind=i+1; ind<stones.size(); ind++){

            if(stones[ind]-stones[i]>jumps+1)

                break;

            for(int t=-1; t<2; t++){

                if(stones[ind]-stones[i]==jumps+t)

                    ans = func(ind, jumps+t, stones, dp) || ans;

            }

        }

        return dp[i][jumps] = ans;

    }

};

class Solution {

public:

    bool canCross(vector<int>& stones) {

        if(stones[1]-stones[0]>1)

            return false;

        return func(0, 1, stones);

    }

    bool func(int i, int jumps, vector<int> &stones){

        if(i==stones.size()-1)

            return true;

        bool ans=false;

        for(int ind=i+1; ind<stones.size(); ind++){

            if(stones[ind]-stones[i]>jumps+1)

                break;

            for(int t=-1; t<2; t++){

                if(stones[ind]-stones[i]==jumps+t)

                    ans = func(ind, jumps+t, stones) || ans;

            }

        }

        return ans;

    }

};

class Solution {

public:

    bool canCross(vector<int>& stones) {

        int N = stones.size();

        vector<vector<bool>> dp(N, vector<bool> (N+1, false));

        dp[0][1] = true;

        for(int i = 1; i < N; ++i){

            for(int j = 0; j < i; ++j){

                int diff = stones[i] - stones[j];

                if(diff > N || !dp[j][diff]) 

                    continue;

                if(i == N - 1) 

                    return true;

                dp[i][diff] = true;

                if(diff - 1 >= 0) dp[i][diff - 1] = true;

                if(diff + 1 <= N) dp[i][diff + 1] = true;

            }

        }

​

        return false;

    }

};

class Solution {

public:

    bool canCross(vector<int>& stones) {

        unordered_map<int , unordered_set<int>> hashMap;    

        hashMap[stones[0] + 1] = {1};       

        for(int i = 1 ; i < stones.size() ; ++i){      

            int position = stones[i];               

            for(auto it : hashMap[position]){           

                hashMap[position + it].insert(it);      

                hashMap[position + it + 1].insert(it + 1);

                hashMap[position + it - 1].insert(it - 1);

            }

        }

        return hashMap[stones.back()].size() != 0;    

    }

};