LeetCode Weekly Contest 133

1030. Matrix Cells in Distance Order
分析：这个题很简单，读懂题，照着模拟就好了，把曼哈顿距离排个序即可

struct node{
    int x,y,sum;
};
bool cmp(node a,node b){
    return a.sum<b.sum;
}
class Solution {
public:
    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
        vector<node>v;
        for(int i=0;i<R;i++){
            for(int j=0;j<C;j++){
                int ans=abs(i-r0)+abs(j-c0);
                node tmp;
                tmp.x=i,tmp.y=j,tmp.sum=ans;
                v.push_back(tmp);
            }
        }
        sort(v.begin(),v.end(),cmp);
        vector<vector<int>>res;
        for(auto t:v){
            vector<int>c;
            c.push_back(t.x);
            c.push_back(t.y);
            res.push_back(c);
        }
        return res;
    }
};

1029. Two City Scheduling
分析：这道题很多人都是贪心过的，我的做法是DP。dp(i,j)表示前i个里面有j个属于种类A的最小价值是多少,接着我们初始化dp(i,0)和dp(i,i)。然后我们知道dp(i,j)必然由dp(i-1,j-1)+cost(i-1,0)和dp(i-1,j)+costs(i-1,1)两者的最小值转化过来。最后求dp(len,len/2)就好了

class Solution {
public:
    int twoCitySchedCost(vector<vector<int>>& costs) {
        int len=costs.size();
        int dp[len+10][len+10];
        memset(dp,0,sizeof(dp));
        dp[0][0]=0;
        for(int i=1;i<=len;i++) dp[i][0]=dp[i-1][0]+costs[i-1][1];
        for(int i=1;i<=len;i++) dp[i][i]=dp[i-1][i-1]+costs[i-1][0];
        for(int i=1;i<=len;i++){
            for(int j=1;j<i;j++){
                dp[i][j]=min(dp[i-1][j-1]+costs[i-1][0],dp[i-1][j]+costs[i-1][1]);
            }
        }
        return dp[len][len/2];
    }
};

1031. Maximum Sum of Two Non-Overlapping Subarrays
分析：这个题维护一些前缀和，就可以过，复杂度\(O(N^2)\)

class Solution {
public:
    int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
        int mx=0;
        int len=A.size();
        int dp[len+10];
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=len;i++){
            dp[i]=dp[i-1]+A[i-1];
        }
        for(int i=1;i+L-1<=len;i++){
            int ans=dp[i+L-1]-dp[i-1];
            for(int j=i+L;j+M-1<=len;j++){
                mx=max(mx,ans+dp[j+M-1]-dp[j-1]);
            }
            for(int j=i-1;j-M+1>=1;j--){
                mx=max(mx,ans+dp[j]-dp[j-M]);
            }
        }
        return mx;
    }
};

1032. Stream of Characters
分析：把字符串逆序插入字典树内，然后倒着跑插入每个字符，看看能不能完整匹配完一个单词，完整匹配完trie树里面的一个单词，则需要End[p]为true。注意这题要传引用，不然会一直MLE

class StreamChecker {
int trie[80001][26],tot;
bool End[80001];
string res;
public:
    void init(){
        memset(trie,0,sizeof(trie));
        memset(End,false,sizeof(End));
        tot=1;
        res="";
    }
    void insert(string &str){
        int len=str.length(),p=1;
        for(int i=0;i<len;i++){
            int ch=str[i]-'a';
            if(trie[p][ch]==0) trie[p][ch]=++tot;
            p=trie[p][ch];
        }
        End[p]=true;
    }
    bool search(string &str){
        int len=str.length(),p=1;
        for(int i=len-1;i>=0;i--){
            int ch=str[i]-'a';
            p=trie[p][ch];
            if(p==0) return false;
            if(End[p]==true) return true;
        }
        return false;
    }
    StreamChecker(vector<string>& words) {
        init();
        for(auto v: words){
            reverse(v.begin(),v.end());
            insert(v);
        }
    }
    
    bool query(char letter) {
        res+=letter;
        return search(res);
    }
};