leetcode 第五天

1 跳跃游戏

给你一个整数数组 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

解题思路：BFS
将数组想象成一张图，节点i与节点j相连，当且仅当i,j相邻，或者i,j的值相同，如果节点i和j之间存在边，那么节点j和i之间不再有边，每次搜索时，依次遍历当前节点的邻接顶点，如果遍历的节点是最后一个节点，则结束遍历，返回路径长度

class Solution {
public:
    int minJumps(vector<int>& arr) {
        int n = arr.size();
        //保存遍历到节点i时刻的路径长度
        vector<int> dis(n,-1);
        //用来存储节点值相同的节点
        unordered_map<int,vector<int>> mp;
        //保存接下来要遍历的节点
        queue<int> q;
        dis[0]=0;
        q.push(0);
        for(int i=0;i<n;i++){
            mp[arr[i]].push_back(i);
        }
        while(!q.empty()){
            int node = q.front();
            q.pop();
            if(node==n-1){
            //如果当前节点是最后一个节点，返回路径长度
                return dis[node];
            }
            if(node>0&&dis[node-1]==-1){
                q.push(node-1);
                dis[node-1]=dis[node]+1;
            }
            if(node<n-1&&dis[node+1]==-1){
                q.push(node+1);
                dis[node+1]=dis[node]+1;
            }
            for(int i:mp[arr[node]]){
                if(dis[i]==-1){
                    q.push(i);
                    dis[i]=dis[node]+1;
                }
            }
            mp[arr[node]]={};
        }
        return dis[0];

    }
};

**[注]**第一次做这种题目，很遗憾，没有解出来，一点思路都没有，参考了别人的解题思路写出自己的代码，多理解解题思想吧

2 盛水最多的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2

图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例：
输入：[1,8,6,2,5,4,8,3,7]
输出：49

解题思路：双指针
第一想法是暴力解法，从当前位置向后遍历，找出最大的容器，时间复杂度为O(N*N),超时
后来才了解到，可以用双指针來解此题
双指针思路：头指针指向第一个元素，尾指针指向最后一个元素，计算此时容器大小，然后移动较小的一个指针，为什么移动较小的指针呢，因为容器的容积是由较小的边决定的，如果移动较大的边，那么容器的容积必定减小，因为高不变，但底边必定减小，故移动较小边指针。
或者可以这样理解：假定初始状态左边较小，则左右两边在边界处是固定左边不动，遍历右边能达到的最大容积；然后左边往右移动，此时再判断，假设此时右边较小，则此时左右两边在边界处是固定右边的边不动，遍历左边能达到的最大容积，依次类推，便能求出最大容积，这种思考方式跟第一种暴力解法思想相同，只是减少了很多不必要的比较过程，时间复杂度为O(N).

class Solution {
public:
    int maxArea(vector<int>& height) {
        int i=0,j=height.size()-1;
        int maxV=0;
        while(i<j){
            if(height[i]<=height[j]){
                maxV = max(maxV,height[i]*(j-i));
                i++;
            }else{
                maxV = max(maxV,height[j]*(j-i));
                j--;
            }
        }
        return maxV;
    }
};