LeetCode 937. 重新排列日志文件 / 1823. 找出游戏的获胜者（约瑟夫环问题） / 713. 乘积小于 K 的子数组

Zephyr丶J

于 2022-05-05 11:45:32 发布

阅读量130

点赞数

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

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

版权

LeetCode 专栏收录该内容

198 篇文章 1 订阅

订阅专栏

937. 重新排列日志文件

2022.5.3 每日一题

题目描述

给你一个日志数组 logs。每条日志都是以空格分隔的字串，其第一个字为字母与数字混合的标识符。

有两种不同类型的日志：

字母日志：除标识符之外，所有字均由小写字母组成
数字日志：除标识符之外，所有字均由数字组成

请按下述规则将日志重新排序：

所有字母日志都排在数字日志之前。
字母日志在内容不同时，忽略标识符后，按内容字母顺序排序；在内容相同时，按标识符排序。
数字日志应该保留原来的相对顺序。
返回日志的最终顺序。

示例 1：

输入：logs = [“dig1 8 1 5 1”,“let1 art can”,“dig2 3 6”,“let2 own kit dig”,“let3 art zero”]
输出：[“let1 art can”,“let3 art zero”,“let2 own kit dig”,“dig1 8 1 5 1”,“dig2 3 6”]
解释：
字母日志的内容都不同，所以顺序为 “art can”, “art zero”, “own kit dig” 。
数字日志保留原来的相对顺序 “dig1 8 1 5 1”, “dig2 3 6” 。

示例 2：

输入：logs = [“a1 9 2 3 1”,“g1 act car”,“zo4 4 7”,“ab1 off key dog”,“a8 act zoo”]
输出：[“g1 act car”,“a8 act zoo”,“ab1 off key dog”,“a1 9 2 3 1”,“zo4 4 7”]

提示：

1 <= logs.length <= 100
3 <= logs[i].length <= 100
logs[i] 中，字与字之间都用单个空格分隔
题目数据保证 logs[i] 都有一个标识符，并且在标识符之后至少存在一个字

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

思路

split(s, 2) #将字符串分成两部分
在这里插入图片描述

class Solution {
    public String[] reorderLogFiles(String[] logs) {
        Arrays.sort(logs, (a, b) -> {
            char alast = a.charAt(a.length() - 1);
            char blast = b.charAt(b.length() - 1);
            //如果都是数字，不排序
            if(Character.isDigit(alast) && Character.isDigit(blast))
                return 0;
            //如果a是数字，那么需要把b排在前面，所以返回1，表示a大于b，a要排到后面
            else if(Character.isDigit(alast))
                return 1;
            else if(Character.isDigit(blast))
                return -1;
            //如果都是字母
            else{
                //将字符串分成两部分
                String[] aa = a.split(" ", 2);
                String[] bb = b.split(" ", 2);
                if(aa[1].equals(bb[1])){
                    return aa[0].compareTo(bb[0]);
                }else{
                    return aa[1].compareTo(bb[1]);
                }
            }
        });
        return logs;
    }
}

1823. 找出游戏的获胜者

2022.5.4 每日一题

题目描述

共有 n 名小伙伴一起做游戏。小伙伴们围成一圈，按顺时针顺序从 1 到 n 编号。确切地说，从第 i 名小伙伴顺时针移动一位会到达第 (i+1) 名小伙伴的位置，其中 1 <= i < n ，从第 n 名小伙伴顺时针移动一位会回到第 1 名小伙伴的位置。

游戏遵循如下规则：

从第 1 名小伙伴所在位置开始。
沿着顺时针方向数 k 名小伙伴，计数时需要包含起始时的那位小伙伴。逐个绕圈进行计数，一些小伙伴可能会被数过不止一次。
你数到的最后一名小伙伴需要离开圈子，并视作输掉游戏。
如果圈子中仍然有不止一名小伙伴，从刚刚输掉的小伙伴的顺时针下一位小伙伴开始，回到步骤 2 继续执行。
否则，圈子中最后一名小伙伴赢得游戏。
给你参与游戏的小伙伴总数 n ，和一个整数 k ，返回游戏的获胜者。

示例 1：

输入：n = 5, k = 2
输出：3
解释：游戏运行步骤如下：

从小伙伴 1 开始。
顺时针数 2 名小伙伴，也就是小伙伴 1 和 2 。
小伙伴 2 离开圈子。下一次从小伙伴 3 开始。
顺时针数 2 名小伙伴，也就是小伙伴 3 和 4 。
小伙伴 4 离开圈子。下一次从小伙伴 5 开始。
顺时针数 2 名小伙伴，也就是小伙伴 5 和 1 。
小伙伴 1 离开圈子。下一次从小伙伴 3 开始。
顺时针数 2 名小伙伴，也就是小伙伴 3 和 5 。
小伙伴 5 离开圈子。只剩下小伙伴 3 。所以小伙伴 3 是游戏的获胜者。

示例 2：

输入：n = 6, k = 5
输出：1
解释：小伙伴离开圈子的顺序：5、4、6、2、3 。小伙伴 1 是游戏的获胜者。

提示：

1 <= k <= n <= 500

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

思路

模拟，用队列

class Solution {
    public int findTheWinner(int n, int k) {
        //约瑟夫环问题，每次做每次忘
        //可以模拟
        Queue<Integer> queue = new LinkedList<>();
        for(int i = 1; i <= n; i++){
            queue.offer(i);
        }
        int temp = 1;
        while(queue.size() > 1){
            while(temp < k){
                temp++;
                queue.offer(queue.poll());
            }
            temp = 1;
            queue.poll();
        }
        return queue.poll();
    }
}

标准解法，倒推
https://leetcode-cn.com/problems/find-the-winner-of-the-circular-game/solution/by-fuxuemingzhu-laof/

class Solution {
    public int findTheWinner(int n, int k) {
        //约瑟夫环问题，每次做每次忘
        //倒推，最后一个数字剩下的时候，下标为0，这个数字记为t
        //因为每次移走的是第k个数字，下标就是k-1，那么剩下的起始位置就是第k+0个数字，而第k+0个数字会重新标记为第1个数字
        //所以如果倒推的话，当前轮次第i个位置的数字，在上一轮中的位置就是(i+k)%上一轮圈的大小
        //所以剩下两个的时候，因为t没有被删除，所以t的下标为(1 + k) % 2
        //同理，一直递推就可以得到初始位置

        int pos = 0;
        for(int i = 2; i <= n; i++){
            pos = (pos + k) % i;
        }
        return pos + 1;
    }
}

713. 乘积小于 K 的子数组

2022.5.5 每日一题

题目描述

给你一个整数数组 nums 和一个整数 k ，请你返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。

示例 1：

输入：nums = [10,5,2,6], k = 100
输出：8
解释：8 个乘积小于 100 的子数组分别为：[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。

示例 2：

输入：nums = [1,2,3], k = 0
输出：0

提示:

1 <= nums.length <= 3 * 10^4
1 <= nums[i] <= 1000
0 <= k <= 10^6

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

思路

滑动窗口，找以每个位置开头的子数组

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        //找以每个位置开头的符合条件的子数组
        //用滑动窗口，例如找第一个位置开头的子数组窗口大小为5，遍历到第六个不满足条件，那么结果加5
        //然后左边右移一位，继续往右找
        //如果找到头了，那么就一直移动左边下标

        int l = nums.length;
        int left = 0;
        int right = 0;
        int product = nums[0];
        int ans = 0;
        while(left < l){
            //如果乘积大于等于k了，那么就右移left
            //或者说已经遍历到最后了
            while(left <= right && product >= k){
                ans += right - left;
                product /= nums[left];
                left++;
            }
            while(left <= right && right == l - 1){
                ans += right - left + 1;
                left++;
            }
            if(right < l - 1){
                right++;
                product *= nums[right];
            }
        }
        return ans;
    }
}

统计结束位置写起来更简单

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        int n = nums.length, ret = 0;
        int prod = 1, i = 0;
        for (int j = 0; j < n; j++) {
            prod *= nums[j];
            while (i <= j && prod >= k) {
                prod /= nums[i];
                i++;
            }
            ret += j - i + 1;
        }
        return ret;
    }
}