leetcode周赛 227

A:问能否将一个数组通过轮换的方式得到一个单调不减的数组。

因为范围只有100，直接将数组拷贝并排序，然后对原数组轮换n次，每次进行一下判断。

class Solution {
public:
    bool check(vector<int>&a,vector<int>& b){
        int n=a.size();
        for(int i=0;i<n;i++){
            if(a[i]!=b[i]){
                return false;
            }
        }
        return true;
    }
    bool check(vector<int>& nums) {
        int n=nums.size();
        vector<int> tmp=nums;
        sort(tmp.begin(),tmp.end());
        for(int i=0;i<n;i++){
            int t=tmp.back();
            tmp.pop_back();
            tmp.insert(tmp.begin(),t);
            if(check(tmp,nums)) return true;
        }
        return false;
    }
};

 

B:给定三堆石子，每次操作从其中两堆各拿走一个石子，获得价值1，问价值最大为多少。

三堆石子数量分别为a，b，c。

不妨设a<=b<=b。

　　1.若a+b<=c，那么ans=a+b

　　2.若a+b>c，那么必然可以消耗成两两之间的差小于等于1，即|a-b|<=1,|a-c|<=1,|b-c|<=1。

　　　　而且可以发现，这种情况之后的都会一直保持上述性质。

　　　　故最终答案为0,0,0或者0,0,1，1取决于石子总数的奇偶。

class Solution {
public:
    int maximumScore(int a, int b, int c) {
        int d[]={a,b,c};
        sort(d,d+3);
        if(d[0]+d[1]<=d[2]) return d[0]+d[1];
        else return (d[0]+d[1]+d[2])/2;
    }
};

 

C:给定两个字符串，每次操作选择其中一个串的首字符，放到res的末尾，问字典序最大的串是什么。

原始写法：考试的时候想的是每次挑字典序大的字符，如果相同，就需要判断后面的字符的大小，假设A串为"ccbda"，B串为"ccaza"，那么我们应该先将A串的 ‘c’ 拿尽。

根据这个思路，在每次A和B相同的时候就继续往后判断。

class Solution {
public:
    int finds(int i,int j,string& w1,string& w2){
        char c=w1[i];
        while(i<w1.size()&&j<w2.size()){
            if(w1[i]>w2[j]){
                return 1;
            }else if(w1[i]<w2[j]){
                return 2;
            }
            i++,j++;
        }
        while(i<w1.size()){
            if(w1[i]>c){
                return 1;
            }else if(w1[i]<c){
                return 2;
            }
            i++;
        }
        while(j<w2.size()){
            if(w2[j]>c){
                return 2;
            }else if(w2[j]<c){
                return 1;
            }
            j++;
        }
        return 1;
    }
    string largestMerge(string w1, string w2) {
        int i=0,j=0;
        string res="";
        while(i<w1.size()&&j<w2.size()){
            if(w1[i]>w2[j]){
                res+=w1[i];
                i++;
            }else if(w1[i]<w2[j]){
                res+=w2[j];
                j++;
            }else{
                int t=finds(i,j,w1,w2);
                if(t==1){
                    res+=w1[i];
                    i++;
                }else{
                    res+=w2[j];
                    j++;
                }
            }
        }
        while(i<w1.size()){
            res+=w1[i];
            i++;
        }
        while(j<w2.size()){
            res+=w2[j];
            j++;
        }
        return res;
    }
};

优化写法:如果两个串首字母相等，就比较往后的第一个不想的的字母的本质就是子串的比较。

　　　　故可直接利用substr函数进行比较。

class Solution {
public:
    string largestMerge(string w1, string w2) {
        int i=0,j=0;
        string res="";
        while(i<w1.size()||j<w2.size()){
            if(w1.substr(i)>w2.substr(j)){
                res+=w1[i++];
            }else{
                res+=w2[j++];
            }
        }
        return res;
    }
};

 

D:给定一个长度为n的数组，从中选出一个子序列，其和记为sum，求|sum-goal|最小为多少，输出这个最小值。

如果数组长度<20，那么就可以直接暴搜，时间复杂度为2^20=1e6

如果要求的是最大和或者最小和，那么可以应用01背包的模型。

而这个题数组长度为40，就需要用双向dfs来做。

首先对前一半数组做一遍dfs，处理出全部的的和，再排序。

对于后半部分的数组同样进行dfs，到终点时，利用二分找到和小于goal的最大值和大于goal的最小值。

const int N=1e7;
int q[N];
class Solution {
public:
    int cnt,res,n,goal;
    void dfs1(vector<int>& nums,int u,int s){
        if(u==(n+1)/2){
            q[cnt++]=s;
            return ;
        }
        dfs1(nums,u+1,s);
        dfs1(nums,u+1,s+nums[u]);
    }
    void dfs2(vector<int>&nums,int u,int s){
        if(u==n){
            int l=0,r=cnt-1;
            while(l<r){
                int mid=l+r+1>>1;
                if(q[mid]+s<=goal) l=mid;
                else r=mid-1;
            }
            res=min(res,abs(q[r]+s-goal));
            if(r+1<cnt){
                res=min(res,abs(q[r+1]+s-goal));
            }
            return ;
        }
        dfs2(nums,u+1,s);
        dfs2(nums,u+1,s+nums[u]);
    }
    int minAbsDifference(vector<int>& nums, int _goal) {
        n=nums.size();
        goal=_goal;
        res=INT_MAX;
        dfs1(nums,0,0);
        sort(q,q+cnt);
        dfs2(nums,(n+1)/2,0);
        return res;
    }
};

时间复杂度为1e6 + 1e6*log(1e6) + 1e6*log(1e6) 。