【力扣打卡--day10】

187.字符串

class Solution {
public:
    vector<string> findRepeatedDnaSequences(string s) {
        map<string,int> st;
        vector<string> res;
        int num=s.size();
        for(int i=9;i<num;i++){
            if(st[s.substr(i-9,10)]==1){
                res.push_back(s.substr(i-9,10));
            }
            st[s.substr(i-9,10)]++;
        }
        return res;
    }
};

189.数组

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n=nums.size();
        k=k%n;
        reverse(nums.begin(),nums.end());
        reverse(nums.begin(),nums.begin()+k);
        reverse(nums.begin()+k,nums.end());
    }
};

198.dp

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
        vector<int> f(n+1),g(n+1);
        for(int i=1;i<=n;i++){
            f[i]=nums[i-1]+g[i-1];
            g[i]=max(g[i-1],f[i-1]);
        }
        return max(f[n],g[n]);
    }
};

199.层次遍历

/**
 * 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<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> Q;
        vector<int> res;
        if(!root) return res;
        Q.push(root);
        while(Q.size()){
            int len=Q.size();
            for(int i=0;i<len;i++){
                auto t=Q.front();
                Q.pop();
                if(t->left) Q.push(t->left);
                if(t->right) Q.push(t->right);
                if(i==len-1) res.push_back(t->val);
            }
        }
        return res;
    }
};

200.dfs

class Solution {
public:
    vector<vector<char>> g;
    int n,m;
    int numIslands(vector<vector<char>>& gr) {
        g=gr;
        n=g.size();
        m=g[0].size();
        int cnt=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(g[i][j]=='1'){
                    cnt++;
                    dfs(i,j);
                }
            }
        }
        return cnt;
    }

    int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
    void dfs(int x,int y){
        g[x][y]=0;
        for(int i=0;i<4;i++){
            int a=x+dx[i],b=y+dy[i];
            if(a>=0&&a<n&&b>=0&&b<m&&g[a][b]=='1'){
                dfs(a,b);
            }
        }
    }
};

201.位运算

class Solution {
public:
    int rangeBitwiseAnd(int left, int right) {
        int res=0;
        for(int i=30;i>=0;i--){
            if((left>>i&1)!=(right>>i&1)) break;
            if(left>>i&1) res+=1<<i;
        }
        return res;
    }
};

204.数论

class Solution {
public:
    int countPrimes(int n) {
        int st[5000010]={0};
        int res=0;
        for(int i=2;i*i<n;i++){
            if(st[i]==0){
                for(int j=i*i;j<n;j+=i){
                    st[j]=1;
                }
            }
        }
        for(int i=2;i<n;i++){
            if(st[i]==0) res++;
        }
        return res;
    }
};

207.拓扑排序

class Solution {
public:
    bool canFinish(int n, vector<vector<int>>& p) {
        vector<vector<int>> g(n);
        vector<int> d(n);
        for(auto& e:p){
            int a=e[0],b=e[1];
            g[a].push_back(b);
            d[b]++;
        }

        queue<int> q;
        for(int i=0;i<n;i++){
            if(!d[i]) q.push(i);
        }

        int cnt=0;
        while(q.size()){
            auto t=q.front();
            q.pop();
            cnt++;
            for(auto i:g[t]){
                if(--d[i]==0){
                    q.push(i);
                }
            }
        }
        return cnt==n;
    }
};

208.trie树

class Trie {
public:
    int son[32001][26],idx=0,cnt[32001]={0};
    Trie() {
        memset(son,0,sizeof son);
    }
    
    void insert(string word) {
        int a=0;
        for(int i=0;i<word.size();i++){
            int b=word[i]-'a';
            if(!son[a][b]){
                son[a][b]=++idx;
            }
            a=son[a][b];
        }
        cnt[a]++;
    }
    
    bool search(string word) {
        int a=0;
        for(int i=0;i<word.size();i++){
            int b=word[i]-'a';
            if(!son[a][b]) return false;
            a=son[a][b];
        }
        return cnt[a];
    }
    
    bool startsWith(string prefix) {
        int a=0;
        for(int i=0;i<prefix.size();i++){
            int b=prefix[i]-'a';
            if(son[a][b]){
                a=son[a][b];
            }else{
                return false;
            }
        }
        return true;
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

209.双指针

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int res=INT_MAX;
        for(int i=0,j=0,sum=0;i<nums.size();i++){
            sum+=nums[i];
            while(sum-nums[j]>=target) sum-=nums[j++];
            if(sum>=target) res=min(res,i-j+1);
        }
        if(res==INT_MAX) return 0;
        return res;
    }
};