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

Posted 2022-05-07 Zephyr丶J

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. 从小伙伴 1 开始。
2. 顺时针数 2 名小伙伴，也就是小伙伴 1 和 2 。
3. 小伙伴 2 离开圈子。下一次从小伙伴 3 开始。
4. 顺时针数 2 名小伙伴，也就是小伙伴 3 和 4 。
5. 小伙伴 4 离开圈子。下一次从小伙伴 5 开始。
6. 顺时针数 2 名小伙伴，也就是小伙伴 5 和 1 。
7. 小伙伴 1 离开圈子。下一次从小伙伴 3 开始。
8. 顺时针数 2 名小伙伴，也就是小伙伴 3 和 5 。
9. 小伙伴 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;
    

创作打卡挑战赛 赢取流量/现金/CSDN周边激励大奖