LeetCode231 2 的幂 / 第53场双周赛

最新推荐文章于 2022-03-31 10:49:11 发布

Zephyr丶J

最新推荐文章于 2022-03-31 10:49:11 发布

阅读量211

点赞数

分类专栏： LeetCode 周赛文章标签： leetcode

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

版权

LeetCode 同时被 2 个专栏收录

198 篇文章 1 订阅

订阅专栏

周赛

15 篇文章 0 订阅

订阅专栏

231. 2 的幂

2021.5.30每日一题

题目描述

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。


示例 1：

输入：n = 1
输出：true
解释：20 = 1
示例 2：

输入：n = 16
输出：true
解释：24 = 16
示例 3：

输入：n = 3
输出：false
示例 4：

输入：n = 4
输出：true
示例 5：

输入：n = 5
输出：false

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

思路

昨天双周赛后看了一眼，今天每日一题就完事了

class Solution {
    //这道题，来学两个技巧：
    //第一个，x & (x-1) 这个操作使最右边的1变成0
    //第二个，x & (-x)  -x是x取反再加1， 这个操作取出来最右边的1，这两个都可以用在这道题
    public boolean isPowerOfTwo(int n) {
        if (n == 0) return false;
        long x = (long) n;
        return (x & (-x)) == x;
        //return (x &(x - 1)) == 0;
    }
}

第53场双周赛

咋说呢，昨天晚上在实验室做的，本来想着十二点关门，应该能撑过去，结果11点零几就来清人了，我…然后就着急着回去宿舍，打开电脑，结果不知道咋的黑屏了，又搞了十分钟，一折腾二三十分钟没了。但是昨天做的还是不如意，前两道题还算顺利吧，第三道也就是个模拟，结果测试用例都一下过了，最后提交是错的，又把我弄懵了，到了十二点还没看出来。结果十二点一过，我再看，就知道问题在哪了，最后1200多名，如果第三道过了，估计应该能六七百吧，有点时间说不定还能做出来最后一道哈哈，还是有点遗憾，今天周赛再加油吧

5754. 长度为三且各字符不同的子字符串

题目描述

如果一个字符串不含有任何重复字符，我们称这个字符串为 好 字符串。

给你一个字符串 s ，请你返回 s 中长度为 3 的 好子字符串 的数量。

注意，如果相同的好子字符串出现多次，每一次都应该被记入答案之中。

子字符串 是一个字符串中连续的字符序列。


示例 1：

输入：s = "xyzzaz"
输出：1
解释：总共有 4 个长度为 3 的子字符串："xyz"，"yzz"，"zza" 和 "zaz" 。
唯一的长度为 3 的好子字符串是 "xyz" 。
示例 2：

输入：s = "aababcabc"
输出：4
解释：总共有 7 个长度为 3 的子字符串："aab"，"aba"，"bab"，"abc"，"bca"，"cab" 和 "abc" 。
好子字符串包括 "abc"，"bca"，"cab" 和 "abc" 。

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

思路

一看字符串长度觉得暴力能过，直接写了暴力解

class Solution {
    public int countGoodSubstrings(String s) {
        int l = s.length();
        int count = 0;
        for(int i = 2; i < l; i++){
            char a = s.charAt(i - 2);
            char b = s.charAt(i - 1);
            char c = s.charAt(i);
            if(a != b && b != c && a != c){
                count++;
            }
        }
        return count;
    }
}

5755. 数组中最大数对和的最小值

题目描述

一个数对 (a,b) 的 数对和 等于 a + b 。最大数对和 是一个数对数组中最大的 数对和 。

比方说，如果我们有数对 (1,5) ，(2,3) 和 (4,4)，最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。
给你一个长度为 偶数 n 的数组 nums ，请你将 nums 中的元素分成 n / 2 个数对，使得：

nums 中每个元素 恰好 在 一个 数对中，且
最大数对和 的值 最小 。
请你在最优数对划分的方案下，返回最小的 最大数对和 。


示例 1：

输入：nums = [3,5,2,3]
输出：7
解释：数组中的元素可以分为数对 (3,3) 和 (5,2) 。
最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。
示例 2：

输入：nums = [3,5,4,2,4,6]
输出：8
解释：数组中的元素可以分为数对 (3,5)，(4,4) 和 (6,2) 。
最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。

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

思路

应该算是贪心吧，要想使得最大数对和最小，就是最大和最小配对。开始在考虑其他方法，过了一会还是反应过来了

class Solution {
    public int minPairSum(int[] nums) {
        //想多了，排序，然后从两边向中间求和
        int l = nums.length;
        Arrays.sort(nums);
        int left = 0;
        int right = l - 1;
        int max = 0;
        while(left < right){
            max = Math.max(max, (nums[left] + nums[right]));
            left++;
            right--;
        }
        return max;
    }
}

5757. 矩阵中最大的三个菱形和

题目描述

给你一个 m x n 的整数矩阵 grid 。

菱形和 指的是 grid 中一个正菱形 边界 上的元素之和。本题中的菱形必须为正方形旋转45度，且四个角都在一个格子当中。下图是四个可行的菱形，每个菱形和应该包含的格子都用了相应颜色标注在图中。

在这里插入图片描述

注意，菱形可以是一个面积为 0 的区域，如上图中右下角的紫色菱形所示。

请你按照 降序 返回 grid 中三个最大的 互不相同的菱形和 。如果不同的和少于三个，则将它们全部返回。

示例 1：
在这里插入图片描述

输入：grid = [[3,4,5,1,3],[3,3,4,2,3],[20,30,200,40,10],[1,5,5,4,1],[4,3,2,2,5]]
输出：[228,216,211]
解释：最大的三个菱形和如上图所示。
- 蓝色：20 + 3 + 200 + 5 = 228
- 红色：200 + 2 + 10 + 4 = 216
- 绿色：5 + 200 + 4 + 2 = 211

示例 2：
在这里插入图片描述

输入：grid = [[1,2,3],[4,5,6],[7,8,9]]
输出：[20,9,8]
解释：最大的三个菱形和如上图所示。
- 蓝色：4 + 2 + 6 + 8 = 20
- 红色：9 （右下角红色的面积为 0 的菱形）
- 绿色：8 （下方中央面积为 0 的菱形）
示例 3：

输入：grid = [[7,7,7]]
输出：[7]
解释：所有三个可能的菱形和都相同，所以返回 [7] 。

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

思路

看到的第一眼想到的就是模拟，然后用一个数存储三个最大的值，因为是排序并且不重复的，也是这样实现的，可能代码有点复杂，但思路并不难，我当时写的代码是这样的

class Solution {
    int m;
    int n;
    public int[] getBiggestThree(int[][] grid) {
        TreeSet<Integer> set = new TreeSet<>();
        
        m = grid.length;
        n = grid[0].length;
        int l = m < n ? (m + 1) / 2 : (n + 1) / 2;
        //遍历所有的中心点
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                for(int k = 1; k <= l; k++){
                    int cur = 0;
                    if(k == 1)
                        cur = grid[i][j];
                    //左顶点
                    else{
                        int left = j - k + 1;
                        int right = j + k - 1;
                        int up = i - k + 1;
                        int down = i + k - 1;
                        if(!isinner(i, left) || !isinner(i, right) || !isinner(up, j) || !isinner(down, j))
                            continue;
                        cur = count(grid, i, j, left, right, up, down);
                    }
                    if(set.size() < 3)
                        set.add(cur);
                    else{
                        if(cur > set.first()){
                            set.pollFirst();
                            set.add(cur);
                        }
                    }
                    
                }
                
            }
        }
        int[] res = new int[3];
        int i = 0;
        for(i = 0; i < 3; i++){
            if(set.isEmpty())
                break;
            res[i] = set.pollLast();
        }
        
        return Arrays.copyOfRange(res, 0, i);
    }
    
    public boolean isinner(int i, int j){
        return i >= 0 && i < m && j >= 0 && j < n;
    }
    
    public int count(int[][] a, int i, int j, int left, int right, int up, int down){
        //从左边开始i,left > up,j
        int res = 0;
        for(int x = i; x > up; x--){
            for(int y = left; y < j; y++)
                res += a[x][y];
        }
        //up,j>i,right
        for(int x = up; x < i; x++){
            for(int y = j; y < right; y++)
                res += a[x][y];
        }
        //i,right>down,j
        for(int x = i; x < down; x++){
            for(int y = right; y > j; y--)
                res += a[x][y];
        }
        for(int x = down; x > i; x--){
            for(int y = j; y > left; y--)
                res += a[x][y];
        }
        return res;
    }
}

测试用例都秒过，但是一提交就错，搞的我不知道改哪了，后面时间过了以后认真看了一下，发现计算边的时候，两层循环我是嵌套的…当时就给了自己十几拳
改了这个问题以后，再提交，最后一个测试用例没过，然后又看着给的答案想了半天，发现是添加到set集合中的时候，如果当前计算值，大于set中的最小值，但是却和set中其他值相同的话，也会添加到set集合中，导致这个值不会被记录下来，同时又把应该有的值给丢失了，所以需要在加入set集合那里加一句判断set中是否有当前元素这句话
唉，继续加油吧，做题的时候还是不能着急

class Solution {
    int m;
    int n;
    public int[] getBiggestThree(int[][] grid) {
        TreeSet<Integer> set = new TreeSet<>();
        
        m = grid.length;
        n = grid[0].length;
        int l = m < n ? (m + 1) / 2 : (n + 1) / 2;
        //遍历所有的中心点
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                for(int k = 1; k <= l; k++){
                    int cur = 0;
                    if(k == 1)
                        cur = grid[i][j];
                    //左顶点
                    else{
                        int left = j - k + 1;
                        int right = j + k - 1;
                        int up = i - k + 1;
                        int down = i + k - 1;
                        if(!isinner(i, left) || !isinner(i, right) || !isinner(up, j) || !isinner(down, j))
                            continue;
                        cur = count(grid, i, j, left, right, up, down);
                    }
                    if(set.size() < 3)
                        set.add(cur);
                    else{
                        if(!set.contains(cur) && cur > set.first()){
                            set.pollFirst();
                            set.add(cur);
                        }
                    }
                    
                }
                
            }
        }
        int[] res = new int[set.size()];
        for(int i = 0; i < res.length; i++){
            res[i] = set.pollLast();
        }
        
        return res;
    }
    
    public boolean isinner(int i, int j){
        return i >= 0 && i < m && j >= 0 && j < n;
    }
    
    public int count(int[][] a, int i, int j, int left, int right, int up, int down){
        //从左边开始i,left > up,j
        int res = 0;
        for(int x = i, y = left; x > up; x--, y++){
            //for(int y = left; y < j; y++)
            res += a[x][y];
        }
        //up,j>i,right
        for(int x = up, y = j; x < i; x++, y++){
            //for(int y = j; y < right; y++)
            res += a[x][y];
        }
        //i,right>down,j
        for(int x = i, y = right; x < down; x++, y--){
            //for(int y = right; y > j; y--)
            res += a[x][y];
        }
        for(int x = down, y = j; x > i; x--, y--){
            //for(int y = j; y > left; y--)
            res += a[x][y];
        }
        return res;
    }
}

5756. 两个数组最小的异或值之和

题目描述

给你两个整数数组 nums1 和 nums2 ，它们长度都为 n 。

两个数组的 异或值之和 为 (nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1]) （下标从 0 开始）。

比方说，[1,2,3] 和 [3,2,1] 的 异或值之和 等于 (1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4 。
请你将 nums2 中的元素重新排列，使得 异或值之和 最小 。

请你返回重新排列之后的 异或值之和 。


示例 1：

输入：nums1 = [1,2], nums2 = [2,3]
输出：2
解释：将 nums2 重新排列得到 [3,2] 。
异或值之和为 (1 XOR 3) + (2 XOR 2) = 2 + 0 = 2 。
示例 2：

输入：nums1 = [1,0,3], nums2 = [5,3,4]
输出：8
解释：将 nums2 重新排列得到 [5,4,3] 。
异或值之和为 (1 XOR 5) + (0 XOR 4) + (3 XOR 3) = 4 + 4 + 0 = 8 。

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

思路

这道题就在回去的路上简单想了想，觉得应该是位运算
但是今天看到数组长度最多14，突然事情没这么简单，感觉可以枚举
去看题解了，状态压缩dp，一时半会真看不懂，更别说自己想到了

31号又看了半天，终于有点眉目了。
首先看到数组长度最大为14，想到可以状压；然后把nums2中各位位置元素被选择的状态，定义成一个长度为n的二进制数mask。mask从低到高的第 i 位为1，说明nums2中国第 i 个位置的数被选择了
定义f[mask]为在nums2中选择元素状态为mask的情况下，并且选择了nums1中前count(mask)【表示mask中1的个数】个元素的情况下，组成的最小异或和
那么对于每一个状态，枚举此时选择的nums1中的元素也就是nums1[count(mask)]，与nums2中哪一个元素进行了异或运算，并且在找到前面的状态，也就是让mask中（在nums2中选择元素的位置）为0，加起来就是当前的状态值，具体看代码

考虑完这个状态转移以后，再看状态定义，就会更加通透，状态定义是选择了nums1中前c个，nums2中是按mask选的，而状态转移呢，这2c个元素共有c的平方个组合，而状态转移让这种完全列举的情况，变成了c种，也就是从之前c-1的状态转移而来。即考虑两个数组中的第c个元素（从1开始），对于nums1中就是第c个，对于nums2中就是mask中1的位置；而前面c-1的状态，已经完成了，因为mask是从小到大增大的。

class Solution {
    public int minimumXORSum(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int[] dp = new int[(1 << n)];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        //遍历所有状态
        for(int mask = 1; mask < (1 << n); mask++){
            int c = Integer.bitCount(mask);
            //遍历n个数
            for(int i = 0; i < n; i++){
                //如果第i个数在nums2中被选择
                if((mask & (1 << i)) > 0){
                    //mask ^ (1 << i)，让mask的第i位变成0
                    dp[mask] = Math.min(dp[mask], dp[mask ^ (1 << i)] + (nums1[c - 1] ^ nums2[i]));
                }
            }
        }
        return dp[(1 << n) - 1];
    }
}

这种题还要多练练

小结

这次比赛比上次有进步，尽管排名没有进步啊哈哈；但是三道题应该还是能做出来的，目标还是三道题，遇到代码多的要更加考虑好细节，加油！

Zephyr丶J

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
LeetCode231 2 的幂 / 第53场双周赛

231. 2 的幂2021.5.30每日一题题目描述给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。示例 1：输入：n = 1输出：true解释：20 = 1示例 2：输入：n = 16输出：true解释：24 = 16示例 3：输入：n = 3输出：false示例 4：输入：n = 4输出：true示例 5：输入：n
复制链接

扫一扫