LeetCode 1345. 跳跃游戏 IV（双向bfs） / 1332. 删除回文子序列 / 2034. 股票价格波动

最新推荐文章于 2022-08-23 23:46:27 发布

Zephyr丶J

最新推荐文章于 2022-08-23 23:46:27 发布

阅读量2.1k

点赞数

分类专栏： LeetCode 文章标签： leetcode java

本文链接：https://blog.csdn.net/windyjcy/article/details/122682946

版权

LeetCode 专栏收录该内容

198 篇文章 1 订阅

订阅专栏

1345. 跳跃游戏 IV

2022.1.21 每日一题

题目描述

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/jump-game-iv
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

昨天是石子游戏，今天是跳跃游戏
困难题，但是这个题其实不难，很容易想到从一个点扩散的方法，就是bfs
但是bfs以后，发现超时
然后就自然而然的去想怎么优化，然后又很容易想到，每次去过相同数值的点以后，再去只会重复增加步数，没有必要，所以直接将遍历过的数值从map中删除，这样可以保证每个点都只走了一次，那么就可以通过了

class Solution {
    public int minJumps(int[] arr) {
        //每次只能进行三种操作，需要先统计相同元素的位置
        //广度优先搜索
        //从刚开始扩散，记录已扩散的点

        int n = arr.length;
        //统计相同数值的点
        Map<Integer, Set<Integer>> map = new HashMap<>();
        for(int i = 0; i < n; i++){
            int t = arr[i];
            Set<Integer> set = map.getOrDefault(t, new HashSet<>());
            set.add(i);
            map.put(t, set);
        }
        boolean[] used = new boolean[n];
        used[0] = true;
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(0);

        int step = -1;
        while(!queue.isEmpty()){
            step++;
            int size = queue.size();
            while(size-- > 0){
                int top = queue.poll();
                if(top == n - 1)
                    return step;
                //遍历当前点能去的点
                if(!used[top + 1])
                    queue.offer(top + 1);
                if(top >= 1 && !used[top - 1])
                    queue.offer(top - 1);
                if(!map.containsKey(arr[top]))
                    continue;
                Set<Integer> set = map.get(arr[top]);
                for(int t : set){
                    if(used[t])
                        continue;
                    queue.offer(t);
                    used[t] = true;
                }
                //用了以后肯定都会加入到queue中，为了防止重复遍历，直接删除
                map.remove(arr[top]);
            }
        }
        return 0;
    }
}

好久没写过双向bfs了，看三叶姐写一下
写的真的很优雅

class Solution {
    //双向bfs

    int[] arr;
    int INF = 0x3f3f3f3f;       //表示没有出现
    int n;
    //存放 <值，下标集合>
    Map<Integer, List<Integer>> map = new HashMap<>();
    public int minJumps(int[] _arr) {
        arr = _arr;
        n = arr.length;
        if (n == 1) return 0;
        //倒叙存放，尽可能最快遍历到末尾
        for (int i = n - 1; i >= 0; i--) {
            List<Integer> list = map.getOrDefault(arr[i], new ArrayList<>());
            list.add(i);
            map.put(arr[i], list);
        }
        //两个队列
        Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
        //记录每个位置在第几轮遍历出现过
        int[] dist1 = new int[n], dist2 = new int[n];
        Arrays.fill(dist1, INF);
        Arrays.fill(dist2, INF);
        //从首位开始遍历
        d1.addLast(0);
        dist1[0] = 0;
        d2.addLast(n - 1);
        dist2[n - 1] = 0;
        //如果有一个队列为空，说明首尾不能连通
        while (!d1.isEmpty() && !d2.isEmpty()) {
            int t = -1;
            //更新小的队列
            if (d1.size() < d2.size()) t = update(d1, d2, dist1, dist2);
            else t = update(d2, d1, dist2, dist1);
            if (t != -1) return t;
        }
        return -1; // never
    }
    public int update(Deque<Integer> d1, Deque<Integer> d2, int[] dist1, int[] dist2) {
        int m = d1.size();
        while (m-- > 0) {
            int t = d1.pollFirst(), step = dist1[t];
            if (t + 1 < n) {
                //如果t+1已经被另一个队列遍历过了，那么就说明找到了通路，返回步数
                if (dist2[t + 1] != INF) return step + 1 + dist2[t + 1];
                //如果没有遍历过，那么加入当前队列中并置当前步数
                if (dist1[t + 1] == INF) {
                    d1.addLast(t + 1);
                    dist1[t + 1] = step + 1;
                }
            }
            //同理遍历t-1
            if (t - 1 >= 0) {
                if (dist2[t - 1] != INF) return step + 1 + dist2[t - 1];
                if (dist1[t - 1] == INF) {
                    d1.addLast(t - 1);
                    dist1[t - 1] = step + 1;
                }
            }
            //将所有相同值的位置遍历一下
            List<Integer> list = map.getOrDefault(arr[t], new ArrayList<>());
            for (int ne : list) {
                if (dist2[ne] != INF) return step + 1 + dist2[ne];
                if (dist1[ne] == INF) {
                    d1.addLast(ne);
                    dist1[ne] = step + 1;
                }
            }
            //一样的删除操作，相同的遍历过了，就不需要重复遍历了
            map.remove(arr[t]);
        }
        return -1;
    }
}

1332. 删除回文子序列

2022.1.22 每日一题

题目描述

给你一个字符串 s，它仅由字母 ‘a’ 和 ‘b’ 组成。每一次删除操作都可以从 s 中删除一个回文子序列。

返回删除给定字符串中所有字符（字符串为空）的最小删除次数。

「子序列」定义：如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到，那么这个字符串就是原字符串的一个子序列。

「回文」定义：如果一个字符串向后和向前读是一致的，那么这个字符串就是一个回文。

示例 1：

输入：s = “ababa”
输出：1
解释：字符串本身就是回文序列，只需要删除一次。

示例 2：

输入：s = “abb”
输出：2
解释：“abb” -> “bb” -> “”.
先删除回文子序列 “a”，然后再删除 “bb”。

示例 3：

输入：s = “baabb”
输出：2
解释：“baabb” -> “b” -> “”.
先删除回文子序列 “baab”，然后再删除 “b”。

提示：

1 <= s.length <= 1000
s 仅包含字母 ‘a’ 和 ‘b’

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-palindromic-subsequences
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

class Solution {
    public int removePalindromeSub(String s) {
        //因为只有两个字母，所以最多就删除两次，先删除全部a，再删除全部b
        //如果本身就是一个回文，那么就删除一次
        int l = s.length();
        int left = 0;
        int right = l - 1;
        boolean flag = true;
        while(left < right){
            if(s.charAt(left) != s.charAt(right)){
                flag = false;
                break;
            }
            left++;
            right--;
        }
        return flag ? 1 : 2;
    }
}

2034. 股票价格波动

2022.1.23 每日一题

题目描述

给你一支股票价格的数据流。数据流中每一条记录包含一个时间戳和该时间点股票对应的价格。

不巧的是，由于股票市场内在的波动性，股票价格记录可能不是按时间顺序到来的。某些情况下，有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中，前一条记录视为错误记录，后出现的记录更正前一条错误的记录。

请你设计一个算法，实现：

更新股票在某一时间戳的股票价格，如果有之前同一时间戳的价格，这一操作将更正之前的错误价格。
找到当前记录里最新股票价格。最新股票价格定义为时间戳最晚的股票价格。
找到当前记录里股票的最高价格。
找到当前记录里股票的最低价格。

请你实现 StockPrice 类：

StockPrice() 初始化对象，当前无股票价格记录。
void update(int timestamp, int price) 在时间点 timestamp 更新股票价格为 price 。
int current() 返回股票最新价格。
int maximum() 返回股票最高价格。
int minimum() 返回股票最低价格。

示例 1：

输入：
[“StockPrice”, “update”, “update”, “current”, “maximum”, “update”, “maximum”, “update”, “minimum”]
[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
输出：
[null, null, null, 5, 10, null, 5, null, 2]
解释：
StockPrice stockPrice = new StockPrice();
stockPrice.update(1, 10); // 时间戳为 [1] ，对应的股票价格为 [10] 。
stockPrice.update(2, 5); // 时间戳为 [1,2] ，对应的股票价格为 [10,5] 。
stockPrice.current(); // 返回 5 ，最新时间戳为 2 ，对应价格为 5 。
stockPrice.maximum(); // 返回 10 ，最高价格的时间戳为 1 ，价格为 10 。
stockPrice.update(1, 3); // 之前时间戳为 1 的价格错误，价格更新为 3 。
// 时间戳为 [1,2] ，对应股票价格为 [3,5] 。
stockPrice.maximum(); // 返回 5 ，更正后最高价格为 5 。
stockPrice.update(4, 2); // 时间戳为 [1,2,4] ，对应价格为 [3,5,2] 。
stockPrice.minimum(); // 返回 2 ，最低价格时间戳为 4 ，价格为 2 。

提示：

1 <= timestamp, price <= 10^9
update，current，maximum 和 minimum 总调用次数不超过 10^5 。
current，maximum 和 minimum 被调用时，update 操作至少已经被调用过一次。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/stock-price-fluctuation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

主要是要查找股票的最高和最低价格，这个用优先队列来处理
两个优先队列，一个从小到大，一个从大到小，顶部就是要找的值
但是这个值可能被更新了，如果被更新了，就从队列顶部弹出

class StockPrice {
    //最高最低用优先队列处理
    //map存储对应的时间股票，最新股票记录时间戳最晚的股票价格

    Map<Integer, Integer> map;
    int newTime;
    int newPrice;
    PriorityQueue<int[]> maxpq;
    PriorityQueue<int[]> minpq;
    public StockPrice() {
        map = new HashMap<>();
        newTime = 0;
        newPrice = 0;
        minpq = new PriorityQueue<>((a, b) -> (a[1] - b[1]));
        maxpq = new PriorityQueue<>((a, b) -> (b[1] - a[1]));
    }
    
    public void update(int timestamp, int price) {
        map.put(timestamp, price);
        if(timestamp >= newTime){
            newTime = timestamp;
            newPrice = price;
        }
        int[] temp = new int[]{timestamp, price};
        minpq.offer(temp);
        maxpq.offer(temp);
    }
    
    public int current() {
        return newPrice;
    }
    
    public int maximum() {
        while(true){
            int[] top = maxpq.poll();
            //如果有这个股票
            if(map.containsKey(top[0]) && map.get(top[0]) == top[1]){
                maxpq.offer(top);
                return top[1];
            }else{
                continue;
            }
        }
    }
    
    public int minimum() {
        while(true){
            int[] top = minpq.poll();
            //如果有这个股票
            if(map.containsKey(top[0]) && map.get(top[0]) == top[1]){
                minpq.offer(top);
                return top[1];
            }else{
                continue;
            }
        }
    }
}

/**
 * Your StockPrice object will be instantiated and called as such:
 * StockPrice obj = new StockPrice();
 * obj.update(timestamp,price);
 * int param_2 = obj.current();
 * int param_3 = obj.maximum();
 * int param_4 = obj.minimum();
 */

Zephyr丶J

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode 1345. 跳跃游戏 IV（双向bfs） / 1332. 删除回文子序列 / 2034. 股票价格波动

1345. 跳跃游戏 IV2022.1.21 每日一题题目描述给你一个整数数组 arr ，你一开始在数组的第一个元素处（下标为 0）。每一步，你可以从下标 i 跳到下标：i + 1 满足：i + 1 < arr.lengthi - 1 满足：i - 1 >= 0j 满足：arr[i] == arr[j] 且 i != j请你返回到达数组最后一个元素的下标处所需的最少操作次数。注意：任何时候你都不能跳到数组外面。示例 1：输入：arr = [100,-23,-23,
复制链接

扫一扫