leetcode 第27场双周赛

通过翻转子数组使两个数组相等	检查一个字符串是否包含所有长度为K的二进制子串	课程安排Ⅳ	摘樱桃Ⅱ
3分 简单	4分 中等	5分 中等	6分 困难

1460 重新排列数组

解题思路：

翻译下题意，其实就是问我们两个数组是否相等，判断数组是否相等有很多方法，这边我直接排序，遍历一遍看是否有不一样的元素

复杂度:

数组排序的复杂度，故为O(nlogn)

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

---

1461 检查一个字符串是否包含所有长度为K的二进制子串

解题思路：

长度为k的二进制字符串都是s的子串，说明s中长度为k的不同子串有(1<<k)种，用长度为k的滑动窗口求出每个长度为k的子串的大小，用map记录每个数字是否出现过，最后不同子串数有(1<<k)种，就返回true

复杂度:

滑动窗口处理的复杂度为O(n)，另外用到了map，所以map的复杂度使O(mlog(m)),用unordered_map整体复杂度还是O(n)

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        map<int,int>mp;
        int a[25];
        a[0]=1;
        for(int i=1;i<=k;i++) a[i]=a[i-1]*2;
        int mx=1<<k;
        int n=s.length();
        if(n<k) return false;
        int ans=0;
        int sum=0;
        for(int i=0;i<k;i++){
            sum+=(s[i]-'0')*a[i];
        }
        if(sum<mx){
            if(mp[sum]==0){
                mp[sum]=1;
                ans++;
            }
        }
        for(int i=k;i<n;i++){
            sum-=(s[i-k]-'0');
            sum/=2;
            sum+=(s[i]-'0')*a[k-1];
            if(sum<mx&&mp[sum]==0){
                mp[sum]=1;
                ans++;
            }
        }
        return (ans==mx);
    }
};

 

---

1462 课程安排Ⅳ

解题思路：

对于先修课程数对列表prerequisites的每一对i，j；必须先修i，才能修j，i->j

根据传递条件

如果存在j->k,那么i->k;

如果存在k->i,那么k->j;

所以对于每一对关系，我们只要再枚举k，即其他所有课程，更新关系即可

复杂度:

O(N^2)

class Solution {
public:
    vector<bool> checkIfPrerequisite(int n, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
        int a[105][105];
        memset(a,0,sizeof(a));
        for(auto it:prerequisites){
            a[it[0]][it[1]]=1;
            for(int i=0;i<n;i++){
                if(a[i][it[0]]) a[i][it[1]]=1;
                if(a[it[1]][i]) a[it[0]][i]=1;
            }
        }
        vector<bool >ans;
        for(auto it:queries){
            if(a[it[0]][it[1]]) ans.push_back(true);
            else ans.push_back(false);
        }
        return ans;
    }
};

 

---

1463 摘樱桃Ⅱ

解题思路：

简单dp

dp[i][j][k]表示机器人都是在第i行，一号机器人在第j列，二号机器人在第k列的状态的最多樱桃数
状态转移:
dp[i][j][k]=max(dp[i][j][k],dp[i-1][ii][jj]+sum);
sum是当前状态，两个机器人当前位置能摘到的樱桃总数
ii!=jj:sum=grid[i][ii]+grid[i][jj];
ii==jj:sum=grid[i][ii];
​
当前状态由上一行的某一状态转移过来，某一状态一号机器人在第ii列，二号机器人在第jj列
只要枚举ii，jj即可
​

复杂度:

三层for循环，里面还套了两层for循环，但这个循环是有限制的，单层长度不超过3，所以这两层for训练复杂度最高为3*3

O(n^3*9)

 

class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        int dp[75][75][75];
        int row=grid.size();
        int col=grid[0].size();
        memset(dp,-1,sizeof(dp));
        dp[1][1][col]=grid[0][0]+grid[0][col-1];
        for(int i=2;i<=row;i++){
            for(int j=1;j<=col;j++){
                int sum1=grid[i-1][j-1];
                for(int k=1;k<=col;k++){
                    int sum=sum1;
                    if(k!=j) sum+=grid[i-1][k-1];
                    for(int ii=max(1,j-1);ii<=min(col,j+1);ii++){
                        for(int jj=max(1,k-1);jj<=min(col,k+1);jj++){
                            if(dp[i-1][ii][jj]==-1) continue;
                            dp[i][j][k]=max(dp[i][j][k],dp[i-1][ii][jj]+sum);
                        }
                    }
                }
            }
        }
        int ans=0;
        for(int i=1;i<=col;i++){
            for(int j=1;j<=col;j++){
                ans=max(ans,dp[row][i][j]);
            }
        }
        return ans;
    }
};