leetcode 第40场双周赛 题解

最大重复子字符串
思路：计算一下长度比值，然后从大到小枚举，用c++的find函数即可

class Solution {
public:
    int maxRepeating(string a, string b) {
        int ma=a.size()/b.size();
        for(int i=ma;i;i--){
            string z="";
            for(int j=1;j<=i;j++) z+=b;
            if(a.find(z)!=string::npos) return i;
        }
        return 0;
    }
};

合并两个链表
思路：按照题意模拟就好了。把第一个链表a前面位置接上第二个链表全部。
然后再街上第一个链表b后面的位置即可。注意要先把b位置的链表处理出来。
不然先接上第二个链表，就得不到原有第一个链表后部分的值了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) {
        ListNode* h=list1,*d=list1;
        for(int i=1;i<a;i++){
            h=h->next;
        }
        for(int i=1;i<=b;i++){
            d=d->next;
        }
        d=d->next;
        h->next=list2;
        while(h->next) h=h->next;
        h->next=d;
        return list1;
    }
};

设计前中后队列
思路：就是让手写支持中位数的push和pop的队列。
我们开两个双端队列。维护一下当前队列的前后两部分。保持前半部分的个数小于等于后半部分的个数，即
1、如果第一个双端队列和第二个双端队列个数一样，中位数就在第一个的最后一个
2、如果第一个双端队列个数比第二个双端队列个数少1.中位数就是第二个双端队列的头部第一个
每次操作后，进行两部分的个数维护一下即可

class FrontMiddleBackQueue {
public:
    deque<int> a,b;
    FrontMiddleBackQueue() {
        while(!a.empty()) a.pop_back();
        while(!b.empty()) b.pop_back();
    }
    void ok(){
        int len=a.size()+b.size();
        len/=2;
        while(a.size()>len){
            b.push_front(a.back());
            a.pop_back();
        }
        len=(a.size()+b.size())/2;
        if((a.size()+b.size())&1) len++;
        while(b.size()>len){
            a.push_back(b.front());
            b.pop_front();
        }
    }
    void pushFront(int val) {
        a.push_front(val);
        ok();
    }
    
    void pushMiddle(int val) {
        if(a.size()==b.size()) b.push_front(val);
        else a.push_back(val);
        ok();
    }
    
    void pushBack(int val) {
        b.push_back(val);
        ok();
    }
    
    int popFront() {
        if(a.empty() && b.empty()) return -1;
        if(a.size()){
            int x=a.front();
            a.pop_front();
            ok();
            return x;
        }
        else{
            int x=b.front();
            b.pop_front();
            ok();
            return x;
        }
    }
    
    int popMiddle() {
        if(a.empty() && b.empty()) return -1;
        if(a.size()==b.size()){
            int x=a.back();
            a.pop_back();
            ok();
            return x;
        }
        else {
            int x=b.front();
            b.pop_front();
            ok();
            return x;
        }
    }
    
    int popBack() {
        if(b.empty()) return -1;
        int x=b.back();
        b.pop_back();
        ok();
        return x;
    }
};

/**
 * Your FrontMiddleBackQueue object will be instantiated and called as such:
 * FrontMiddleBackQueue* obj = new FrontMiddleBackQueue();
 * obj->pushFront(val);
 * obj->pushMiddle(val);
 * obj->pushBack(val);
 * int param_4 = obj->popFront();
 * int param_5 = obj->popMiddle();
 * int param_6 = obj->popBack();
 */

得到山形数组的最少删除次数
思路：枚举分割点，正序和逆序求一下最长上升子序列即可。
注意两部分的最长上升子序列个数要都大于2，不然就是一个降序或者升序序列，不满足要求

class Solution {
public:
    int a[1005],b[1005],aa[1005];
    int get1(int n){
        b[1]=a[1];
        int len=1,i;
        for(i=1;i<=n;i++)
        {
            if(a[i]>b[len])
                b[++len]=a[i];
            else
            {
                int j=lower_bound(b,b+len+1,a[i])-b;
                b[j]=a[i];

            }
        }
        return len;
    }
    int get2(int n){
        b[1]=aa[1];
        int len=1,i;
        for(i=1;i<=n;i++)
        {
            if(aa[i]>b[len])
                b[++len]=aa[i];
            else
            {
                int j=lower_bound(b,b+len+1,aa[i])-b;
                b[j]=aa[i];

            }
        }
        return len;
    }
    int minimumMountainRemovals(vector<int>& n) {
        int ans=1005;
        int l=n.size();
        for(int i=0;i<l;i++) a[i+1]=n[i];
        for(int i=1;i<=l;i++) aa[i]=a[l-i+1];
        for(int i=1;i<l-1;i++){
            int x=get1(i+1);
            int y=get2(l-i+1);
            if(x>=2 && y>=2) ans=min(ans,l-(x+y-1));
        }
        return ans;
    }
};