【LeetCode周赛】第 360 场周赛

爱喝牛奶的男孩

已于 2023-09-12 20:35:14 修改

阅读量46

点赞数 1

分类专栏： LeetCode 文章标签： leetcode 算法数据结构

于 2023-09-12 20:33:25 首次发布

本文链接：https://blog.csdn.net/lunaol/article/details/132839143

版权

LeetCode 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

LeetCode第360场周赛

距离原点最远的点简单
找出美丽数组的最小和中等
使子序列的和等于目标的最少操作次数困难

距离原点最远的点简单

给你一个长度为 n 的字符串 moves ，该字符串仅由字符 'L'、'R' 和 '_' 组成。字符串表示你在一条原点为 0 的数轴上的若干次移动。

你的初始位置就在原点（0），第 i 次移动过程中，你可以根据对应字符选择移动方向：

如果 moves[i] = 'L' 或 moves[i] = '_' ，可以选择向左移动一个单位距离
如果 moves[i] = 'R' 或 moves[i] = '_' ，可以选择向右移动一个单位距离
移动 n 次之后，请你找出可以到达的距离原点最远的点，并返回从原点到这一点的距离。

示例 1：

输入：moves = “L_RL__R”
输出：3
解释：可以到达的距离原点 0 最远的点是 -3 ，移动的序列为"LLRLLLR" 。

示例 2：

输入：moves = “_R__LL_”
输出：5
解释：可以到达的距离原点 0 最远的点是 -5 ，移动的序列为"LRLLLLL" 。

示例 3：

输入：moves = “_______”
输出：7
解释：可以到达的距离原点 0 最远的点是 7 ，移动的序列为"RRRRRRR" 。

提示：

1 <= moves.length == n <= 50
moves 仅由字符 'L'、'R' 和 '_' 组成

分析： 只能左右移动。根据给出的移动序列，得到向左和向右的次数，选取数量多的，与'_'的数量相加，如果向左和向右数量一样，最终结果就为'_'的数量。

代码：

class Solution {
public:
    int furthestDistanceFromOrigin(string moves) {
        int r,l,a;r=l=a=0;
        for(int i=0;i<moves.length();i++){
            if(moves[i]=='R') r++;
            else if(moves[i]=='L') l++;
            else a++;
        }
        if(r>l) return r-l+a;
        return l-r+a; 
    }
};

找出美丽数组的最小和中等

给你两个正整数：n 和 target 。

如果数组 nums 满足下述条件，则称其为美丽数组。

nums.length == n.
nums 由两两互不相同的正整数组成。
在范围 [0, n-1] 内，不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == target 。

返回符合条件的美丽数组所可能具备的最小和，并对结果进行取模 10^9 + 7。

示例 1：

输入：n = 2, target = 3
输出：4
解释：nums = [1,3] 是美丽数组。

nums 的长度为 n = 2 。
nums 由两两互不相同的正整数组成。
不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。

可以证明 4 是符合条件的美丽数组所可能具备的最小和。

示例 2：

输入：n = 3, target = 3 输出：8 解释： nums = [1,3,4] 是美丽数组。

nums 的长度为 n = 3 。
nums 由两两互不相同的正整数组成。
不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。

可以证明 8 是符合条件的美丽数组所可能具备的最小和。

示例 3：

输入：n = 1, target = 1
输出：1
解释：nums = [1] 是美丽数组。

提示：

1 <= n <= 10^9
1 <= target <= 10^9

分析： 美丽数组中任意两个数的和不能为target。因此有两种情况：
num < target：对于小于target的数，存在a+b=target，此时选择更小的值。
num >= target：不在任意两数之和等于target，因此能直接选择。
目标是选择最小和，因此要从1开始选择，因此先判断num < target的情况，后面再考虑num >= target的情况。

代码：

class Solution {
public:
    long long minimumPossibleSum(int n, int target) {
        long long ans=0;int l=0;
        for(int i=1;l<n;i++){
            if(target>i && target-i>=i){
                ans+=i;l++;
            }else if(target<=i){
                ans+=i;l++;
            }
        }
        return ans;
    }
};

使子序列的和等于目标的最少操作次数困难

给你一个下标从 0 开始的数组 nums ，它包含非负整数，且全部为 2 的幂，同时给你一个整数 target 。

一次操作中，你必须对数组做以下修改：

选择数组中一个元素 nums[i] ，满足 nums[i] > 1 。
将 nums[i] 从数组中删除。
在 nums 的末尾添加两个数，值都为 nums[i] / 2 。
你的目标是让 nums 的一个 子序列 的元素和等于 target ，请你返回达成这一目标的 最少操作次数 。如果无法得到这样的子序列，请你返回 -1 。

数组中一个子序列是通过删除原数组中一些元素，并且不改变剩余元素顺序得到的剩余数组。

示例 1：

输入：nums = [1,2,8], target = 7
输出：1
解释：第一次操作中，我们选择元素 nums[2] 。数组变为 nums = [1,2,4,4] 。这时候，nums 包含子序列 [1,2,4] ，和为 7 。无法通过更少的操作得到和为 7 的子序列。

示例 2：

输入：nums = [1,32,1,2], target = 12
输出：2
解释：第一次操作中，我们选择元素 nums[1] 。数组变为nums = [1,1,2,16,16] 。第二次操作中，我们选择元素 nums[3] 。数组变为 nums = [1,1,2,16,8,8] 。这时候，nums 包含子序列 [1,1,2,8] ，和为 12 。无法通过更少的操作得到和为 12 的子序列。

示例 3：

输入：nums = [1,32,1], target = 35
输出：-1
解释：无法得到和为 35 的子序列。

提示：

1 <= nums.length <= 1000
1 <= nums[i] <= 230
nums 只包含非负整数，且均为 2 的幂。
1 <= target < 231

分析： 利用贪心，先将数组从大到小排序，并求数组的和。然后不断遍历数组，直至target变成0。
如果和比target要小，那就无解，返回-1
遍历数组元素时也有几种情况：

数组和 - 当前数组元素 >= target ：数组和减去当前数组元素
数组和 - 当前数组元素 < target && 当前数组元素 > target ：将当前数组元素分成两份，放入数组末尾
数组和 - 当前数组元素 < target && 当前数组元素 <= target ：target减去当前数组元素

代码：

class Solution {
public:
    int minOperations(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end(),[&](long long a,long long b) -> bool {return a<b;});
        long long a = 0, ans=0;
        for(int i=0;i<nums.size();i++){
            a+=nums[i];
        }
        if(a<target) return -1;
        while(target>0){
            long long tmp = nums[nums.size()-1];
            nums.pop_back();
            if(a-tmp >= target) a-=tmp;
            else if(tmp>target) {
                ans++;
                nums.push_back(tmp/2);
                nums.push_back(tmp/2);
            }else{
                target-=tmp;
                a-=tmp;
            }
        }
        return ans;
    }
};