2021-12-28每日刷题打卡

2021-12-28每日刷题打卡

力扣——排序

1464. 数组中两元素的最大乘积

给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使 (nums[i]-1)*(nums[j]-1) 取得最大值。

请你计算并返回该式的最大值。

示例 1：

输入：nums = [3,4,5,2]
输出：12
解释：如果选择下标 i=1 和 j=2（下标从 0 开始），则可以获得最大值，(nums[1]-1)* (nums[2]-1) = (4-1)* (5-1) = 3*4 = 12 。

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int max1=0,max2=0,n=nums.size();
        bool flag=true;
        for(int i=0;i<n;i++)
        {
            flag=true;
            if(nums[i]>max1)
            {
                if(max2<max1)max2=max1;
                max1=nums[i];
                flag=false;
            }
            if(flag&&nums[i]>max2)max2=nums[i];
        }
        return (max1-1)*(max2-1);
    }
};

1460. 通过翻转子数组使两个数组相等

给你两个长度相同的整数数组 target 和 arr 。

每一步中，你可以选择 arr 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。

如果你能让 arr 变得与 target 相同，返回 True；否则，返回 False 。

示例 1：

输入：target = [1,2,3,4], arr = [2,4,1,3]
输出：true
解释：你可以按照如下步骤使 arr 变成 target：
1- 翻转子数组 [2,4,1] ，arr 变成 [1,4,2,3]
2- 翻转子数组 [4,2] ，arr 变成 [1,2,4,3]
3- 翻转子数组 [4,3] ，arr 变成 [1,2,3,4]
上述方法并不是唯一的，还存在多种将 arr 变成 target 的方法。

直接对两个数组进行排序，然后比较元素是否一样。

class Solution {
public:
    bool canBeEqual(vector<int>& target, vector<int>& arr) {
        int n=target.size(),m=arr.size();
        if(n!=m)return false;
        sort(target.begin(),target.end());
        sort(arr.begin(),arr.end());
        for(int i=0;i<n;i++)
        {
            if(target[i]!=arr[i])return false;
        }
        return true;
    }
};

389. 找不同

给定两个字符串 s 和 t，它们只包含小写字母。

字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。

请找出在 t 中被添加的字母。

示例 1：

输入：s = “abcd”, t = “abcde”
输出：“e”
解释：‘e’ 是那个被添加的字母。

对s和t进行排序，然后对比相同位置上的元素，如果有不一样的就返回t位置上的元素。

class Solution {
public:
    char findTheDifference(string s, string t) {
        int n=s.size();
        sort(s.begin(),s.end());
        sort(t.begin(),t.end());
        for(int i=0;i<n;i++)
        {
            if(s[i]!=t[i])return t[i];
        }
        return t[n];
    }
};

2089. 找出数组排序后的目标下标

给你一个下标从 0 开始的整数数组 nums 以及一个目标元素 target 。

目标下标 是一个满足 nums[i] == target 的下标 i 。

将 nums 按 非递减 顺序排序后，返回由 nums 中目标下标组成的列表。如果不存在目标下标，返回一个 空 列表。返回的列表必须按 递增 顺序排列。

示例 1：

输入：nums = [1,2,5,2,3], target = 2
输出：[1,2]
解释：排序后，nums 变为 [1,2,2,3,5] 。
满足 nums[i] == 2 的下标是 1 和 2 。

class Solution {
public:
    vector<int> targetIndices(vector<int>& nums, int target) {
        int n=nums.size();
        vector<int>v;
        sort(nums.begin(),nums.end());
        for(int i=0;i<n;i++)
        {
            if(nums[i]==target)v.push_back(i);
            else if(nums[i]>target)break;
        }
        return v;
    }
};

1403. 非递增顺序的最小子序列

给你一个数组 nums，请你从中抽取一个子序列，满足该子序列的元素之和 严格 大于未包含在该子序列中的各元素之和。

如果存在多个解决方案，只需返回 长度最小 的子序列。如果仍然有多个解决方案，则返回 元素之和最大 的子序列。

与子数组不同的地方在于，「数组的子序列」不强调元素在原数组中的连续性，也就是说，它可以通过从数组中分离一些（也可能不分离）元素得到。

注意，题目数据保证满足所有约束条件的解决方案是 唯一 的。同时，返回的答案应当按 非递增顺序 排列。

示例 1：

输入：nums = [4,3,10,9,8]
输出：[10,9]
解释：子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列。但是 [10,9] 的元素之和最大。

对nums降序排序，计算nums的所有元素之和sum，再遍历一次nums，从最大值开始，计算遍历到的元素之和res，同时再sum里减去遍历到的元素，并把遍历到的元素存入另一个数组里，当res大于sum时停止遍历，返回数组。

class Solution {
public:
    vector<int> minSubsequence(vector<int>& nums) {
        int n=nums.size(),sum=0,res=0;
        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++)
                if(nums[i]<nums[j])swap(nums[i],nums[j]);
        vector<int>v;
        for(auto i:nums)sum+=i;
        for(int i=0;i<n;i++)
        {
            res+=nums[i];
            sum-=nums[i];
            v.push_back(nums[i]);
            if(res>sum)break;
        }
        return v;
    }
};