刷题日常之leetcode521，leetcode522，leetcode102，leetcode104，leetcode101

系列文章目录

暂无

---

---

前言

坚持刷题第43天
博客记录第一天

---

首先是今天的每日一题

521. 最长特殊序列 Ⅰ

思路

很怪的一个题，感觉像是脑筋急转弯

• 如果两个字符串一样：return -1
• 如果两个字符串不一样：较长的那个串本身就不可能是较短串的子序列，所以这个较长串就是我们可以得到的最长独有子序列

代码

class Solution {
public:
    int findLUSlength(string a, string b) {
        return a==b?-1:max(a.size(),b.size());
    }
};

由此进阶到下一题

522. 最长特殊序列 II

思路

核心思路和上一题一样，判断长字符串是否是子串
该题的难点在于怎么按照长度从大到小的顺序判断某个字符串是否是更长字符串的子串


首先我们可以先将字符串按照从长到短的顺序排列，方便之后的比较

sort(strs.begin(),strs.end(),[](string a,string b){return a.size()>b.size();});

之后就是从最长串向后遍历依次看是否是子串

for(int i=0;i<strs.size();i++){
	int flag=0;
	//注意这个j的遍历不能写成j<i，因为i之后仍然可能有与i等长的串
	for(int j=0;j<strs.size() && strs[i].size()<=strs[j].size();j++){
		if(i!=j && isSub(strs[i],strs[j])){
			flag=1;
            break;
		}
	}
	if(!flag) return strs[i].size();
}

代码

class Solution {
public:
    bool isSub(string a,string b){
        int i=0;
        for(auto c:b){
            if(i<a.size() && c==a[i]) i++;
        }
        return i==a.size();
    }
    int findLUSlength(vector<string>& strs) {
        sort(strs.begin(),strs.end(),[](string a,string b){return a.size()>b.size();});
        if(strs[1].size()<strs[0].size()) return strs[0].size();
        for(int i=0;i<strs.size();i++){
            int flag=0;
            for(int j=0;j<strs.size() && strs[i].size()<=strs[j].size();j++){
                if(i!=j && isSub(strs[i],strs[j])){
                    flag=1;
                    break;
                }
            }
            if(!flag) return strs[i].size();
        }
        return -1;
    }
};

每日一题刷完之后就开始刷自己的计划了，最近在刷数据结构基础

102. 二叉树的层序遍历

就是一个很普通的层次遍历，套一个队列就行，不明白为什么是中等
直接放代码吧

代码

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
        vector<vector<int>> ans;
        queue<pair<TreeNode*,int>>q;
        q.emplace(root,0);
        while(!q.empty()){
            auto [tmp,level]=q.front();
            q.pop();
            if(level<ans.size()) ans[level].emplace_back(tmp->val);
            else ans.push_back({tmp->val});
            if(tmp->left) q.emplace(tmp->left,level+1);
            if(tmp->right) q.emplace(tmp->right,level+1);
        }
        return ans;
    }
};

104. 二叉树的最大深度

这这这，，这个知识点竟然可以单独成一个题的吗
一个简单递归就能实现
直接放代码吧

代码

/**
 * 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 maxDepth(TreeNode* root) {
        if(!root) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

101. 对称二叉树

思路

对称着找就行，自己脑子里怎么找的，代码就怎么写

代码

递归

/**
 * 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:
    bool equal(TreeNode* left,TreeNode* right){
        if(!left && !right) return true;
        if(!left || !right) return false;
        return left->val==right->val && equal(left->left,right->right) && equal(left->right,right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(!root) return true;
        return equal(root->left,root->right);
    }
};

队列迭代

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(!root) return true;
        queue<pair<TreeNode*,TreeNode*>>q;
        q.emplace(root->left,root->right);
        while(!q.empty()){
            auto [left,right]=q.front();
            q.pop();
            if(!left && !right) continue;
            if(!left || !right || left->val!=right->val) return false;
            q.emplace(left->left,right->right);
            q.emplace(left->right,right->left);
        }
        return true;
    }
};

效率参考

总结

今天的刷题计划就到这了，三个简单，两个中等
当前进度