第 190 场力扣周赛

2020-05-24

5416. 检查单词是否为句中其他单词的前缀

注意这里的前缀是指单词的开始，我们首先找到单词的开始，然后判断其长度为searchword的子串是否等于searchword即可。

class Solution {
public:
    int isPrefixOfWord(string sentence, string searchWord) {
        int l1=sentence.length();
        int l2=searchWord.length();
        if (!l1||!l2) return 0; // 特殊情况判断
        int word=1;
        for (int i=0;i<=l1-l2;i++){
            if ((i==0&&sentence[i]!=' ')||(i-1>0&&sentence[i-1]==' '&&sentence[i]!=' ')){
                // 找到单词的开始
                if (sentence.substr(i,l2)==searchWord){
                    return word;
                }
                word++;
            }
        }
        return -1;
    }
};

5417. 定长子串中元音的最大数目

1.暴力判断，时间复杂度为O(s.length()*k)，超时
2.使用滑动窗口即可

class Solution {
public:
    int maxVowels(string s, int k) {
        int l=s.length();
        if (!l) return 0;
        int res=0;
        int cnt=0;
        vector<bool>vec(l,false); // 存放是不是元音字母
        for (int i=0;i<l;i++){
            if (s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u'){   
                vec[i]=true;
            }
        }
        queue<int> myque;
        for (int i=0;i<k;i++){
            if (vec[i]) cnt++;
        }
        if (cnt==k) return k;
        res=cnt;
        for (int i=k;i<l;i++){
            if (vec[i]) cnt++;
            if (vec[i-k]) cnt--;
            res=max(res,cnt);
            if (res>=k) return k;
        }
        if (res>=k) return k;
        return res;
    }
};

5418. 二叉树中的伪回文路径

使用深度优先搜索即可，到叶子节点的时候判断是否是伪回文路径，由于数字范围是0-9，
1. 可以使用vector存放当前路径上的数值，到叶子节点时判断vector中是否最多只有一个数值出现一次，可以用 map存放其出现的次数。
2. 使用异或操作，异或操作就是相同为0，不同为1，且n&(n-1)可以消除n二进制表示的最后一个1，由于数字范围为0-9，我们可以将当前数表示为第几个二进制位上值为1，比如3：1000，如果所有的数出现的次数是偶数次，那么其异或的结果为0，如果只有一个数出现的次数为奇数次，那么其异或的结果*(其结果-1)就表示把其中的一个1消除了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int res=0;
    int pseudoPalindromicPaths (TreeNode* root) {
        if (!root) return 0;
        dfs(root,0);
        return res;
    }

    void dfs(TreeNode* t,int value){
        value^=(1<<t->val);
        if (!t->left&&!t->right){ // 如果是叶子节点
            if (!value||!(value&(value-1))) res++;
        }
        if (t->left) dfs(t->left,value);
        if (t->right) dfs(t->right,value);
    }
};

5419. 两个子序列的最大点积

使用动态规划即可，太久没有写，都快生疏了...

class Solution {
public:
    int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
        int l1=nums1.size();
        int l2=nums2.size();
        vector<vector<int>> dp(l1+1,vector<int>(l2+1,-100000*500));
        for (int i=1;i<=l1;i++){
            for (int j=1;j<=l2;j++){
                int a=nums1[i-1];
                int b=nums2[j-1];
                dp[i][j]=a*b;
                dp[i][j]=max(dp[i][j],dp[i-1][j-1]+a*b);
                dp[i][j]=max(dp[i][j],dp[i-1][j-1]);
                dp[i][j]=max(dp[i][j],dp[i-1][j]);
                dp[i][j]=max(dp[i][j],dp[i][j-1]);
            }
        }
        return dp[l1][l2];
    }
};