LeetCode 1345. 跳跃游戏 IV (bfs+哈希表)

题目描述

给你一个整数数组 arr ，你一开始在数组的第一个元素处（下标为 0）。
每一步，你可以从下标 i 跳到下标：
i + 1 满足：i + 1 < arr.length
i - 1 满足：i - 1 >= 0
j 满足：arr[i] == arr[j] 且 i != j
请你返回到达数组最后一个元素的下标处所需的最少操作次数 。
注意：任何时候你都不能跳到数组外面。

输入格式

首先输入数组arr的长度n，
然后输入n个整数，以空格分隔。
1 <= n <= 5 * $10^4$
-$10^8$ <= arr[i] <= $10^8$

输出格式

输出一个整数，表示到达数组最后一个元素的下标处所需的最少操作次数

输入样例

10
100 -23 -23 404 100 23 23 23 3 404

输出样例

3

解释：需要跳跃 3 次，下标依次为 0 --> 4 --> 3 --> 9 。下标 9 为数组的最后一个元素的下标。

---

分析

我们需要使用一个哈希表将所有的相同数的下标记录在同一个数组v[i]中。
之后使用bfs，将起点0入队，之后每一次将所有值相同的坐标入队列并及时清空v[i]，直到找到终点为止。

C++ 代码

#include <iostream>
#include<set>
#include <vector>
#include<queue>
#include<algorithm>
#include<cstring>
#include<unordered_map>
#include<string>
using namespace std;
const int N = 210;
class Solution {
public:
    //哈希表，映射一个数和其在数组v中对应的下标
    unordered_map<int,int> mp;
    int minJumps(vector<int>& arr) {
        int len=arr.size(),idx=1;
        bool st[len];
        memset(st,0,sizeof st);
        vector<vector<int> > v; //用来记录相同的数的下标
        for(int i=0;i<len;i++)
        {
            //哈希表中没有这个数，就给其一个对应的下标idx，并将其加入到数组v[idx]中
            if(!mp[arr[i]])
            {
                mp[arr[i]]=idx++;
                vector<int> temp;
                temp.push_back(i);
                v.push_back(temp);
            }
            else{
                //由于我们初始idx为1，所以这里需要-1偏移一个下标
                v[mp[arr[i]]-1].push_back(i);
            }
        }
        
        int time=0;
        queue<int> q;
        //起点入队
        q.push(0);
        st[0]=1;
        while(q.size())
        {
            //第time轮一共有le个下标可以参与搜索
            int le=q.size();
            while(le--)
            {
                auto t=q.front(); q.pop();
                st[t]=1;
                if(t==len-1) return time;
                //将所有两个点加入到队列q
                if(t-1>=0 && t-1<len && !st[t-1]) st[t-1]=1,q.push(t-1);
                if(t+1>=0 && t+1<len && !st[t+1]) st[t+1]=1,q.push(t+1);
                
                int id=mp[arr[t]]-1;
                //将相同值的所有下标加入到队列q
                for(int i=0;i<v[id].size();i++)
                {
                    if(v[id][i]!=t && !st[v[id][i]]){
                        if(v[id][i]==len-1) return time+1;
                        st[v[id][i]]=1;
                        q.push(v[id][i]);
                    }
                }  
                
                //这里非常关键，我们已经将该数的所有下标加入了队列q，所以直接清空该数组，不然会TLE
                v[id].clear();
            }
            time++;
        }
        
        return 0;
    }
};
int main()
{
    int n,m,x;
    cin>>n;
    
    vector<int>  g;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        g.push_back(x);
    }
    cin>>m;
    cout<<Solution().minJumps(g);
    
    return 0;

}