算法入门基础99题

Table of Contents generated with DocToc

• 算法学习
  • 题目归纳
  • 题目总结
    • 第一题
    • 第二题
    • 第三题
    • 第四题
    • 第五题
    • 第六题
    • 第七题
    • 第八题
    • 第九题
    • 第十题
    • 第十一题
    • 第十二题
    • 第十三题
    • 第十四题
    • 第十五题
    • 第十六题
    • 第十七题
    • 第十八题
    • 第十九题
    • 第二十题
    • 第二十一题
    • 第二十二题 | 第二十三题
    • 第二十四题 | 第二十五题
    • 第二十六题
    • 第二十七题（可以直接使用循环，也可以使用堆）
    • 第二十八题
    • 第二十九题
    • 第三十题
    • 第三十一题
    • 第三十二题
    • 第三十三题
    • 第三十四题
    • 第三十五题
    • 第三十六题
    • 第三十七题
    • 第三十八题 | 第三十九题
    • 第四十题
    • 第四十一题 | 第四十二题
    • 第四十三题
    • 第四十四题
    • 第四十五题
    • 第四十六题
    • 第四十七题
    • 第四十八题
    • 第四十九题
    • 第五十题
    • 第五十一题
    • 第五十二题
    • 第五十三题
    • 第五十四题
    • 第五十五题
    • 第五十六题 | 第五十七题
    • 第五十八题
    • 第五十九题
    • 第六十题
    • 第六十一题
    • 第六十二题
    • 第六十三题
    • 第六十四题
    • 第六十五题
    • 第六十六题
    • 第六十七题
    • 第六十八题
    • 第六十九题 | 第七十题
    • 第七十一题
    • 第七十二题
    • 第七十三题
    • 第七十四题
    • 第七十五题
    • 第七十六题
    • 第七十七题
    • 第七十八题
    • 第七十九题
    • 第八十题
    • 第八十一题
    • 第八十二题
    • 第八十三题
    • 第八十四题
    • 第八十五题
    • 第八十六题
    • 第八十七题
    • 第八十八题
    • 第八十九题
    • 第九十题
    • 第九十一题
    • 第九十二题 | 第九十三题
    • 第九十四题 | 第九十五题
    • 第九十六题
    • 第九十七题
    • 第九十八题
    • 第九十九题

题目转自B站英雄哪里出来
《C++零基础99题》

算法学习

学而不思则罔，思而不学则殆。在算法学习这个栏目里，我计划将自己刷过的算法题进行整理归纳、反思总结，整理成解题报告的形式，将所学知识进行反复巩固加深印象。

题目归纳

点我进入刷题链接！

题目总结

在这里给出我的一个刷题思路：简单题尽快刷过；重复题直接点链接，做一道相当于做了两道题，会很爽；第一遍做选择你最熟悉的方法，过了就好，第二遍第三遍做的时候考虑更加简单的方法，会让你受益良多；不会做没关系，看过答案之后理解思路，不看答案写代码，或者如果你感到心烦意乱，可以先把这道题抄进答题框中，过了以后的几天反复观看记忆这道题，总有一天你会掌握这道题的！

第一题

return a + b;

第二题

第三题

第四题

第五题

第六题

第七题

第八题

第九题

第十题

第十一题

第十二题

第十三题

第十四题

第十五题

第十六题

第十七题

第十八题

第十九题

第二十题

第二十一题

第二十二题 | 第二十三题

法一：
int hammingWeight(uint32_t n) {
    int cnt = 0;
    while(n) {
        n = n & (n-1);
        cnt++;
    }
    return cnt;
}

法二：
int hammingWeight(uint32_t n) {
    int cnt = 0;
    while(n) {
        if(n & 1) {
        cnt++;
    }
        n = n >> 1;
    }
    return cnt;
}

第二十四题 | 第二十五题

1、异或两个数 可以得到一个数字x和y所有不同的位置
2、通过上一题计算不同位置的个数

第二十六题

第二十七题（可以直接使用循环，也可以使用堆）

第二十八题

第二十九题

第三十题

第三十一题

第三十二题

第三十三题

第三十四题

第三十五题

第三十六题

第三十七题

第三十八题 | 第三十九题

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        for(int i = 0 ; i < matrix.size() ; i ++) {
            int l = 0, r = matrix[0].size();
            while(l <= r) {
                int mid = l + (r l) / 2;
                if(matrix[i][mid] > target) {
                    r = mid 1;   
                } else if(matrix[i][mid] < target) {
                    l = mid + 1;
                } else {
                    return true;
                }
            }
        }
        return false;
    }
};

第四十题

第四十一题 | 第四十二题

class Solution {
public:
    bool isPalindrome(string s) {
        for(int i = 0 ; i < s.size() ; i ++) {
            if(s[i] >= 'a' && s[i] <= 'z') {
                s[i] = s[i] 'a' + 'A';
            }
        }

        int l = 0, r = s.size() 1;
        while(l < r) {
            if(!(s[l] >= 'a' && s[l] <= 'z' || s[l] >= '0' && s[l] <= '9')) {
                l++;
                continue;
            }

            if(!(s[r] >= 'a' && s[r] <= 'z' || s[r] >= '0' && s[r] <= '9')) {
                r--;
                continue;
            }

            if(s[l] != s[r]) {
                return false;
            }

            l++;
            r--;
        }
        return true;
    }
};

第四十三题

第四十四题

第四十五题

第四十六题

第四十七题

第四十八题

第四十九题

第五十题

第五十一题

第五十二题

class RecentCounter {
    queue<int> q;
public:
    RecentCounter() {

    }
    
    int ping(int t) {
        while(!q.empty()) {
            if(t - q.front() > 3000) {
                q.pop();
            } else {
                break;
            }
        }
        q.push(t);
        return q.size();
    }
};

第五十三题

class MovingAverage {
    int s;
    queue<int> q;
    double sum;
public:
    /** Initialize your data structure here. */
    MovingAverage(int size) {
        s = size;
    }
    
    double next(int val) {
        if(q.size() >= s) {
            sum -= q.front();
            q.pop();
        }
        sum += val;
        q.push(val);
        return sum / q.size();

    }
};

第五十四题

第五十五题

第五十六题 | 第五十七题

这两道题完全一样，和五十五题有所不同
这两道题求的是平方值，mid的最终值应当是这样的mid * mid <= target，
而第五十五题找的ans应当是一个大于等于nums[mid]的值，
两道题在条件判断处的语句是有所不同的

第五十八题

第五十九题

第六十题

第六十一题

class Solution {
public:
    int uniquePaths(int m, int n) {
        int a[110][110];
        int i, j;
        for(i = 1 ; i <= m ; i ++) {
            for(j = 1 ; j <= n ; j ++) {
                if(i == 1 && j == 1) {
                    a[i][j] = 1;
                } else if(i == 1) {
                    a[i][j] = a[i][j-1];
                } else if(j == 1) {
                    a[i][j] = a[i-1][j];
                } else {
                    a[i][j] = a[i-1][j] + a[i][j-1];
                }
            }
        }
        return a[m][n];
    }
};

第六十二题

第六十三题

第六十四题

第六十五题

第六十六题

第六十七题

第六十八题

第六十九题 | 第七十题

class Solution {
    int f[1010];
public:
    int minCostClimbingStairs(vector<int>& cost) {
        f[0] = 0;
        f[1] = 0;        
        for(int i = 2 ; i <= cost.size() ; i ++) {
            f[i] = min(f[i-1]+cost[i-1], f[i-2]+cost[i-2]);
        }
        return f[cost.size()];
    }
};

第七十一题

第七十二题

第七十三题

int f[110];
int sum = 0;
for(int j = 0 ; j < nums.size() ; j ++) {
    sum += f[nums[j]];
    f[nums[m]]++;
}
return sum;

第七十四题

第七十五题

第七十六题

int hash[101];
int ans = 0;
memset(hash, 0, sizeof(hash));
for(int i = 0 ; i < nums.size() ; i ++) {
    int x = nums[i] + k;
    if(x >= 1 && x <= 100) {
        ans += hash[nums[i]];
    }

    x = nums[i] - k;
    if(x >= 1 && x <= 100) {
        ans += hash[nums[i]];
    }
    hash[nums[i]]++;
}
return ans;

第七十七题

class Solution {
public:
    int numSubarraysWithSum(vector<int>& nums, int goal) {
        int hash[60010];
        int i;
        int ans = 0;
        for(i = 1 ; i < nums.size() ; i ++) {
            nums[i] += nums[i-1];
        }
        memset(hash, 0, sizeof(hash));
        hash[goal] = 1;
        for(i = 0 ; i < nums.size() ; i ++) {
            ans += hash[nums[i]];
            hash[nums[i] + goal]++;
        }
        return ans;
    }
};

第七十八题

第七十九题

第八十题

第八十一题

第八十二题

第八十三题

第八十四题

第八十五题

第八十六题

class Solution {
public:
    int rangeSumBST(TreeNode* root, int low, int high) {
        if(!root) {
            return 0;
        }
        int sum = rangeSumBST(root->left, low, high) + rangeSumBST(root->right, low, high);
        if(root->val >= low && root->val <= high) {
            sum += root->val;
        }
        return sum;
    }
};

第八十七题

第八十八题

第八十九题

第九十题

第九十一题

第九十二题 | 第九十三题

class BSTIterator {
    vector<int> ret;
    int idx;

    void dfs(TreeNode* root) {
        if(!root) {
            return ;
        }

        dfs(root->left);
        ret.push_back(root->val);
        dfs(root->right);
    }
public:
    BSTIterator(TreeNode* root) {
        dfs(root);
        idx = -1;
    }
    
    int next() {
        return ret[++idx];
    }
    
    bool hasNext() {
        return idx < (int)ret.size() - 1;
    }
};

第九十四题 | 第九十五题

第九十六题

class MyCalendarThree {
    map<int, int> cnt;
public:
    MyCalendarThree() {
        cnt.clear();
    }
    
    int book(int startTime, int endTime) {
        cnt[startTime]++;
        cnt[endTime]--;
        int sum = 0, maxv = 0;
        for(auto iter = cnt.begin() ; iter != cnt.end() ; iter++) {
            sum += iter->second;
            maxv = max(maxv, sum);
        }
        return maxv;
    }
};

第九十七题

// unordered_set 集合，
// find(element)方法可以查找集合中是否存在该变量
class Solution {
    unordered_set<ListNode*> headSet;
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        while(headA) {
            headSet.insert(headA);
            headA = headA->next;
        }
        while(headB) {
            if(headSet.find(headB) != headSet.end()) {
                return headB;
            }
            headB = headB->next;
        }
        return NULL;
    }
};

第九十八题

class KthLargest {
    priority_queue<int, vector<int>, greater<>> q;
    int K;
public:
    KthLargest(int k, vector<int>& nums) {
        K = k;
        for(int i = 0 ; i < nums.size() ; i ++) {
            add(nums[i]);
        }
    }
    
    int add(int val) {
        q.push(val);
        while(q.size() > K) {
            q.pop();
        }
        return q.top();
    }
};

第九十九题

若[0,0]==[1,0] || [0,0]==[1,1] return [0,0]
else return [0,1]