力扣 第474场周赛

Q1. 找出缺失的元素
签到题，排序之后一个一个找就行。

class Solution {
public:
    vector<int> findMissingElements(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<int> res;
        for(int i=0;i<nums.size()-1;i++){
            for(int j=nums[i]+1;j<nums[i+1];j++){
                res.push_back(j);
            }
        }
        return res;
    }
};

 Q2. 一次替换后的三元素最大乘积

给nums，能改一个元素(改成-1e5~1e5)，获得三个元素的最大乘积。

排序之后，三种情况，最小的两个，最大的两个，或者首尾两端各一个。

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        nums.sort()
        a,b,c=nums[0]*nums[1],nums[-1]*nums[-2],nums[0]*nums[-1]
        print(a,b,c)
        res=0
        res=max(res,abs(a)*100000)
        res=max(res,abs(b)*100000)
        res=max(res,abs(c)*100000)
        return res

Q3. 完成所有送货任务的最少时间

两个无人机，分别要送d_i个物品，而且在r_i倍数时不能送货，问完成送货任务的最少时间。

首先，时间越长越能完成任务，那么我们可以二分时间来求完成任务的最少时间。

那么给定时间t，我们如何判断在该时间内是否能完成任务呢？

第一台无人机在1~t能送货的时间为t - t // d₁，同理，第二台t - t // d₂.

此外，lcm(r₁,r₂)的倍数时间时，d₁和d₂都不能送货，我们同时需要保证d₁+d₂ <= t - t // lcm(r₁,r₂)。

如果有三个无人机，则需要加上三个判定条件。d2+d3 <= t - t // lcm(r2,r3),....,d1+d2+d3 <= t - t // lcm(r1,r2,r3)

class Solution:
    def minimumTime(self, d: List[int], r: List[int]) -> int:
        left,right=0,1
        def check(t,d1,d2,r1,r2):
            if d1>t-t//r1:
                return False
            if d2>t-t//r2:
                return False
            if d1+d2>t-t//lcm(r1,r2):
                return False
            return True
        while not check(right,d[0],d[1],r[0],r[1]):
            right<<=1
        while left<right:
            mid=left+right>>1
            if check(mid,d[0],d[1],r[0],r[1]):
                right=mid
            else:
                left=mid+1
        return left

Q4. 大于目标字符串的最小字典序回文排列

要求s的严格大于target的最小回文排列。

用回溯来写能清晰一点，和之前周赛的一个t4很像，之前是用循环来写的，这里循环非常不好写，所以浪费了好多时间去改。

每个i直接从target[i]开始枚举，保证大于等于target，如果填过一个大于target[i]的字母，那么后面的就能直接fill_min了。

class Solution {
public:
    bool can_pal(int n,vector<int>& cnt){
        int odd=0;
        for(int i=0;i<cnt.size();i++){
            if(cnt[i]%2)
                odd++;
        }
        return n%2==0?odd==0:odd==1;
    }
    string lexPalindromicPermutation(string s, string target) {
        vector<int> cnt(26,0);
        int n=s.size();
        for(int i=0;i<s.size();i++){
            cnt[s[i]-'a']++;
        }
        if(!can_pal(n,cnt))
            return "";
        string ans(n,'?');
        auto fillmin=[&](int k,vector<int> cnt){
            int i=k,j=n-k-1;
            while(i<j){
                int c=0;
                while(c<26&&cnt[c]<2)
                    c++;
                if(c==26) return false;
                ans[i]=ans[j]=char(c+'a');
                cnt[c]-=2;
                i++,j--;
            }
            if(i==j){
                int c=0;
                while(c<26&&cnt[c]==0)
                    c++;
                if(c==26)
                    return false;
                ans[i]=char(c+'a');
            }
            return true;
        };
        function<bool(int)> dfs=[&](int i)->bool{
            int j=n-i-1;
            if(i>j) return ans>target;
            char st=target[i];
            for(char c=st;c<='z';c++){
                int need=(i==j?1:2);
                int id=c-'a';
                if(cnt[id]<need) continue;
                cnt[id]-=need;
                ans[i]=ans[j]=c;
                if(c==target[i]){
                    if(dfs(i+1)) return true;
                }else{
                    string backans=ans;
                    if(fillmin(i+1,cnt)) return true;
                    ans=backans;
                }
                cnt[id]+=need;
            }
            ans[i]=ans[j]='?';
            return false;
        };
        return dfs(0)?ans:"";
    }
};