Prince_H_23

算法通关之路的一些刷题笔记

算法通关之路

第2章数学之美

1. 两数之和

思路+解法

暴力 O(n^2)

排序+双指针 O(nlogn)

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        int size = nums.size();
        vector> vec(size, vector(2));
        for(int i = 0; i < size; i++){
            vec[i][0] = nums[i];
            vec[i][1] = i;
        }
        sort(vec.begin(), vec.end());
        int l = 0, r = size - 1;
        while(l < r){
            if(vec[l][0] + vec[r][0] == target){
                return vector{vec[l][1], vec[r][1]};
            }
            else if(vec[l][0] + vec[r][0] > target){
                r--;
            }
            else if(vec[l][0] + vec[r][0] < target){
                l++;
            }
        }
        return vector{};
    }
};

哈希表 O(n)

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        unordered_map m;
        vector ans;
        for(int i = 0; i < nums.size(); i++){
            if(m.find(target - nums[i]) != m.end()){
                return vector{m[target - nums[i]], i};
            }
            m[nums[i]] = i;
        }
        return ans;
    }
};

一点收获
1. find()找的是键，不是值

15. 三数之和

思路+解法

排序+双指针 O(n^2)

class Solution {
public:
    vector> threeSum(vector& nums) {
        int size = nums.size();
        sort(nums.begin(), nums.end());
        vector> ans;
        for(int i = 0; i < size; i++){
            //第一个元素大于0的剪枝很巧妙
            if(nums[i] > 0) return ans;
            //去重
            if(i > 0 && nums[i] == nums[i-1]) continue;
            int j = i + 1, k = size - 1;
            while(j < k){
                if(nums[j] + nums[k] == -nums[i]){
                    ans.push_back({nums[i], nums[j], nums[k]});
                    j++;
                    k--;
                    //去重
                    while(j < k && nums[j] == nums[j - 1]) j++;
                    while(j < k && nums[k] == nums[k + 1]) k--;
                }
                else if(nums[j] + nums[k] > -nums[i]){
                    k--;
                }
                else if(nums[j] + nums[k] < -nums[i]){
                    j++;
                }
            }
        }
        return ans;
    }
};

18. 四数之和

思路+解法

排序+双指针 O(n^3)

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        int size = nums.size();
        for(int i = 0; i < size; i++){
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for(int j = i + 1; j < size; j++){
                if(j > i + 1 && nums[j] == nums[j-1]) continue;
                int l = j + 1, r = size - 1;
                while(l < r){
                    //合超int范围
                    if((long long)nums[i] + nums[j] + nums[l] + nums[r] == target){
                        ans.push_back({nums[i], nums[j], nums[l], nums[r]});
                        l++;
                        r--;
                        while(l < r && nums[l] == nums[l - 1]) l++;
                        while(l < r && nums[r] == nums[r + 1]) r--;
                    }
                    else if((long long)nums[i] + nums[j] + nums[l] + nums[r] > target){
                        r--;
                    }
                    else if((long long)nums[i] + nums[j] + nums[l] + nums[r] < target){
                        l++;
                    }                
                }

            }
        }
        return ans;
    }
};

一点剪枝优化（140ms->8ms）

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        int size = nums.size();
        for(int i = 0; i < size - 3; i++){
            //剪枝
            if ((long long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break;
            if ((long long)nums[i] + nums[size - 3] + nums[size - 2] + nums[size - 1] < target) continue;
            //去重
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for(int j = i + 1; j < size - 2; j++){
                //剪枝
                if ((long long)nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) break;
                if ((long long)nums[i] + nums[j] + nums[size - 2] + nums[size - 1] < target) continue;
                //去重
                if(j > i + 1 && nums[j] == nums[j-1]) continue;
                int l = j + 1, r = size - 1;
                while(l < r){
                    //合超int范围
                    if((long long)nums[i] + nums[j] + nums[l] + nums[r] == target){
                        ans.push_back({nums[i], nums[j], nums[l], nums[r]});
                        l++;
                        r--;
                        while(l < r && nums[l] == nums[l - 1]) l++;
                        while(l < r && nums[r] == nums[r + 1]) r--;
                    }
                    else if((long long)nums[i] + nums[j] + nums[l] + nums[r] > target){
                        r--;
                    }
                    else if((long long)nums[i] + nums[j] + nums[l] + nums[r] < target){
                        l++;
                    }                
                }

            }
        }
        return ans;
    }
};

454. 四数相加 II

思路+解法

哈希表 O(n^2)

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int ans = 0;
        unordered_map<int, int> m;
        for(auto x : nums1){
            for(auto y : nums2){
                m[x+y]++;
            }
        }
        for(auto x : nums3){
            for(auto y : nums4){
                if(m.find(-(x + y)) != m.end()) ans += m[-(x + y)];
            }
        }
        return ans;
    }
};

16. 最接近的三数之和

思路+解法

排序+双指针 O(n^2)

class Solution {
public:
    int threeSumClosest(vector& nums, int target) {
        sort(nums.begin(), nums.end());
        int size = nums.size();
        int ans = 100000;
        for(int i = 0; i < size; i++){
            //剪枝
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            int l = i + 1, r = size - 1;
            while(l < r){
                if(nums[i] + nums[l] + nums[r] == target){
                    return target;
                }
                else{
                    //计算当前值是否靠近
                    if(abs(nums[i] + nums[l] + nums[r] - target) < abs(ans - target)){
                        ans = nums[i] + nums[l] + nums[r];
                    }
                    //双指针移动
                    if(nums[i] + nums[l] + nums[r] > target) {
                        r--;
                        //剪枝
                        while(l < r && nums[r] == nums[r + 1]) r--;
                    }
                    else if(nums[i] + nums[l] + nums[r] < target){
                        l++;
                        //剪枝
                        while(l < r && nums[l] == nums[l-1]) l++;
                    } 
                }
            }
        }
        return ans;
    }
};

一点收获：
1. 和三数之和稍有不同，计算最小差值是在不等于target时计算，而不是括号外，不然会导致双指针移动不明

53. 最大子序和(*分治法)

思路+解法

双指针滑动窗口 O(n)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int ans = nums[0];
        int l = 0, r = 1;
        int now = nums[0];
        while(r < nums.size()){
            now += nums[r];
            
            while(l < r && now < nums[r]){
                now -= nums[l];
                l++;
            }
            r++;
            ans = max(now, ans);
        }
        return ans;
    }
};

动态规划 O(n)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int ans = nums[0];
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        for(int i = 1; i < nums.size(); i++){
            dp[i] = max(nums[i], dp[i - 1] + nums[i]);
            ans = max(dp[i], ans);
        }
        return ans;
    }
};

分治法 O(nlogn)

前缀和 O(n)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int ans = nums[0];
        int minPrefix = 0;
        int sum = 0;
        for(int i = 0; i < nums.size(); i++){
            sum += nums[i];
            ans = max(ans, sum - minPrefix);
            minPrefix = min(minPrefix, sum);
        }
        return ans;
    }
};

一点收获
1. 一题多解，多思考拓展思维

179. 最大数

思路+解法

排序 O*(*nlognlogm)

class Solution {
public:
    static bool cmp(string a, string b){
        return a + b > b + a;
        
    }
    string largestNumber(vector<int>& nums) {
        vector<string> strs;
        for(int i = 0; i < nums.size(); i++){
            strs.push_back(to_string(nums[i]));
        }
        sort(strs.begin(), strs.end(), cmp);
        string ans = "";
        for(string s : strs){
            ans += s;
        }
        if(ans[0] == '0') return "0";
        return ans;
    }
};

一点收获
1. 前导0

166. 分数到小数

思路+解法：

比较余数 O(l) l是答案的长度

class Solution {
public:
    string fractionToDecimal(int numerator, int denominator) {
        string ans ="";

        if((long long)numerator * denominator < 0) ans += '-';
        long long a = abs(numerator);
        long long b = abs(denominator);
        ans += to_string(a / b);
        
        a = a % b;
        if(a != 0) ans += "."; 

        unordered_map<long long, int> m;
        int loc = ans.size(); //小数的第几位
        m[a] = loc++;

        while(a > 0){
            a *= 10;
            //得到的数
            long long x = a / b;
            ans += to_string(x);
            //这一步的余数
            a -= x * b;
            if(m.find(a) != m.end()){
                ans.insert(ans.begin() + m[a], '(');
                ans += ')';
                return ans;
            }
            m[a] = loc++;
           
        }
        return ans;
    }
};

一点收获
1. 负数转绝对值越界问题

368. 最大整除子集

思路+解法

动态规划 O(n^2)

class Solution {
public:
    vector<int> largestDivisibleSubset(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int size = nums.size();
        vector<int> ans;
        vector<int> dp(size, 1);
        //当前位置的前一个元素
        vector<int> pre(size, -1);
        //整除子集的最大长度
        int maxlen = 1;
        int maxloc = 0;
        for(int i = 0; i < nums.size(); i++){
            for(int j = 0; j < i; j++){
                if(nums[i] % nums[j] == 0){
                    if(dp[j] + 1 > dp[i]){
                        dp[i] = dp[j] + 1;
                        pre[i] = j;
                    }
                }
            }
            if(dp[i] > maxlen){
                maxlen = dp[i];
                maxloc = i;
            }
        }
        ans.push_back(nums[maxloc]);
        int loc = pre[maxloc];
        //回溯找答案
        while(loc != -1){
            ans.push_back(nums[loc]);
            loc = pre[loc];
        }
        return ans;
    }
};

1175. 质数排列

思路+解法

埃氏筛法 O(nloglogn)

class Solution {
private:
    vector<int> is_prime = vector<int>(101, true);
public:
    
    int sieve(int n){
        int p = 0;
        is_prime[0] = is_prime[1] = false;
        for(int i = 2; i <= n; i++){
            if(is_prime[i]){
                p++;
                for(int j = i * 2; j <= n; j += i){
                    is_prime[j] = false;
                }
            }
        }
        return p;
    }
    int numPrimeArrangements(int n) {
        int k1 = sieve(n);
        int k2 = n - k1;
        long ans = 1;
        for(int i = 2; i <= k1; i++){
            ans = (ans * i) % 1000000007;
        }
        for(int i = 2; i <= k2; i++){
            ans = (ans * i) % 1000000007;
        }
        return ans;
    }
};

第3章回文的艺术

680. 验证回文字符串 Ⅱ

思路+解法：

双指针 O(n)

class Solution {
public:
    bool isPalindrome(string & s, int l, int r){
        while(l < r){
            if(s[l] != s[r]) return false;
            l++ ,r--;
        };
        return true;
    }
    bool validPalindrome(string s) {
        int size = s.size();
        int l = 0, r = size - 1;
        int cnt = 0;
        while(l < r){
            if(s[l] != s[r]){
                return isPalindrome(s, l + 1, r) || isPalindrome(s, l, r - 1);
            }
            l++ ,r--;
        }
        return true;
    }
};

一点收获：
1. 认真思考时间复杂度

234. 回文链表(*)

思路+解法：

快慢指针翻转后半部分后比较 O(n)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head->next == nullptr) return true;

        //快慢指针找到前半部分的结尾
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast->next != nullptr && fast->next->next != nullptr){
            fast = fast->next->next;
            slow = slow->next;
        }
        
        //翻转后半部分
        ListNode* pre = slow->next;
        ListNode* cur = slow->next->next;
        pre->next = nullptr; //！
        while(cur != nullptr){
            ListNode* temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }

        //回文比较
        ListNode* firstHalfHead = head;
        ListNode* secondHalfHead = pre;
        while(secondHalfHead != nullptr){
            if(firstHalfHead->val != secondHalfHead->val) return false;
            firstHalfHead = firstHalfHead->next;
            secondHalfHead = secondHalfHead->next;
        }
        return true;
    }
};

翻转前半部分* O(n)

一点收获：
1. 链表操作

9. 回文数

思路+解法：

只翻转一半数字 O(logn)

class Solution {
public:
    bool isPalindrome(int x) {
        if(x < 0) return false;
        if(x == 0) return true;
        if(x % 10 == 0) return false;

        int rev_num = 0;
        while(x > rev_num){
            rev_num = rev_num * 10 + x % 10;
            x /= 10; 
        }
        return x == rev_num || x == rev_num / 10;
    }
};

5. 最长回文子串(*)

思路+解法

动态规划 O(n^2)

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        //dp数组含义：从i到j的字符串是否为回文子串
        vector<vector<bool>> dp(n, vector<bool>(n, false));
        for(int i = 0; i < n; i++){
            dp[i][i] = 0;
        }
        int max_len = 1;
        int begin = 0;
        //画表看遍历顺序
        for(int i = n - 2; i >= 0; i--){
            for(int j = i + 1; j < n; j++){
                if(s[i] == s[j]){
                    if(j - i <= 2){
                        dp[i][j] = true;
                    }
                    else{
                        if(dp[i + 1][j - 1]) dp[i][j] = true;
                    }
                }
                if(dp[i][j]){
                    if(j - i + 1 > max_len){
                        max_len = j - i + 1;
                        begin = i;
                    }
                }
            }
        }
        return s.substr(begin, max_len);
    }
};

中心扩展 O(n^2)

class Solution {
public:
    int n = 0;
    int extend(string& s, int left, int right){
        while(right < n && left >= 0 && s[left] == s[right]){
            left--;
            right++;
        }
        return right - left - 1;
    }
    string longestPalindrome(string s) {
        n = s.size();
        int max_len = 1;
        int start = 0;
        for(int i = 0; i < n; i++){
            int len1 ;
            len1 = extend(s, i, i);
            int len2;
            len2 = extend(s, i, i + 1);
            int len = max(len1, len2);
            if(len > max_len){
                max_len = len;
                start = i - (len - 1) / 2;
            }
        }
        return s.substr(start, max_len);
    }
};

马拉车

516. 最长回文子序列

思路+解法

动态规划 O(n^2)

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        int ans = 1;
        vector<vector<int>> dp(n, vector<int>(n, 0));
        for(int i = 0; i < n; i++) dp[i][i] = 1;
        for(int i = n - 2; i >= 0; i--){
            for(int j = i + 1; j < n; j++){
                if(s[i] == s[j]){
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }
                else{
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][n - 1];
    }
};

906. 超级回文数

思路+解法

构造回文数 O(W1/4∗logW)

class Solution {
public:
    bool isPalindrome(long long x){
        if(x % 10 == 0) return false;
        long long rev_num = 0;

        while(x > rev_num){
            rev_num = rev_num * 10 + x % 10;
            x /= 10;
        }
        return x == rev_num || x == rev_num / 10;
    }
    int superpalindromesInRange(string left, string right) {
        int ans = 0;
        long long l = stol(left);
        long long r = stol(right);
        //ABBA
        for(int i = 1; i < 100000; i++){
            string s1 = to_string(i);
            string s2 = s1;
            reverse(s2.begin(), s2.end());
            string s = s1 + s2;
            long m = stol(s);
            m *= m;
            if(m > r) break;

            if(m >= l && isPalindrome(m)){
                ans++;
            }

        }
        //ABA
        for(int i = 1; i < 100000; i++){
            string s1 = to_string(i);
            string s2 = s1;
            reverse(s2.begin(), s2.end());
            string s = s1.append(s2.begin() + 1, s2.end());
            long m = stol(s);
            m *= m;
            if(m > r) break;

            if(m >= l && isPalindrome(m)){
                ans++;
            }
        }
        return ans;
    }
};

第5章深度优先遍历和广度优先遍历

112. 路径总和

思路+解法：

DFS递归 O(n)

/**
 * 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 dfs(TreeNode* node, int sum, int tar){
         if(!node) return false;

         sum += node->val;
         if(!node->left && !node->right){
             if(sum == tar) return true;
             else return false; 
         }

        return dfs(node->left, sum, tar) || dfs(node->right, sum, tar);
     }
    bool hasPathSum(TreeNode* root, int targetSum) {
        return dfs(root, 0, targetSum);
    }
};

113. 路径总和 II

思路+解法：

DFS O(n)

/**
 * 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 target;
    vector<vector<int>> ans;
    vector<int> path;

    void dfs(TreeNode* node, int sum){
        if(!node->left && !node->right && sum == target){
            ans.push_back(path);
            return;
        }
        
        if(node->left){
            path.push_back(node->left->val);
            dfs(node->left, sum + node->left->val);
            path.pop_back();
        }
        
        if(node->right){
            path.push_back(node->right->val);
            dfs(node->right, sum + node->right->val);
            path.pop_back();
        }
        
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(!root) return ans;
        target = targetSum;
        ans.clear();
        path.clear();
        path.push_back(root->val);
        dfs(root, root->val);
        return ans;
    }
};

124. 二叉树中的最大路径和

思路+解法：

DFS后序遍历 O(n)

/**
 * 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 ans = INT_MIN;
    //后序遍历
    //每个节点拥有自己的最大值，可以同时拥有左右节点
    //但是给父节点返回的只能为一条路径
    int dfs(TreeNode* node){
        if(!node) return 0;

        int left_sum = dfs(node->left);
        int right_sum = dfs(node->right);

        int node_max = node->val;
        node_max += left_sum > 0? left_sum : 0;
        node_max += right_sum > 0? right_sum : 0;
        ans = max(node_max, ans);
        return max(node->val, max(node->val + left_sum, node->val + right_sum));
    }
    int maxPathSum(TreeNode* root) {
        dfs(root);
        return ans;
    }
};

岛屿问题

第6章二分法

704. 二分查找

思路+解法：

二分模板 O(logn)

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            if(nums[mid] == target) return mid;
            else if(nums[mid] > target){
                r = mid - 1;
            }else if(nums[mid] < target){
                l = mid + 1;
            }
        }
        return -1;
    }
};

153. 寻找旋转排序数组中的最小值

解法+思路：

二分查找 O(logn)

class Solution {
public:
    int findMin(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            if((mid == 0 || nums[mid] < nums[mid - 1]) &&(mid == nums.size() - 1 || nums[mid] < nums[mid + 1])) return nums[mid];
            else if(nums[mid] > nums[r]){
                l = mid + 1;
            }
            else {
                r = mid - 1;
            }
        }
        return -1;
    }
};

875. 爱吃香蕉的珂珂

思路+解法：

二分答案 O(logn)

class Solution {
public:
    int minEatingSpeed(vector<int>& piles, int h) {
        int l = 1, r = pow(10 ,9);
        int ans = 1;
        while(l <= r){
            int mid = (r - l)/2 + l;
            int sum = 0;
            for(int i = 0; i < piles.size(); i++){
                sum += piles[i] / mid;
                if(piles[i] % mid != 0) sum++;
            }
            if(sum > h){
                l = mid + 1;
                
            }
            else if(sum <= h){
                ans = mid;
                r = mid  - 1;
            }
        }
        return ans;
    }
};

69. Sqrt(x)

思路+解法：

二分答案 O(logn)

class Solution {
public:
    int mySqrt(int x) {
        int l = 0, r = x;
        int ans = 0;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            if((long long)mid * mid <= x){
                l = mid + 1;
                ans = mid;
            }
            else{
                r = mid - 1;
            }
        }
        return ans;
    }
};

162. 寻找峰值

思路+解法：

二分查找 O(logn)

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            if((mid == 0 || nums[mid] > nums[mid - 1]) &&(mid == nums.size() - 1 || nums[mid] > nums[mid + 1])) return mid;
            if(mid == 0 || nums[mid] > nums[mid - 1] ){
                l = mid + 1;
            }
            else if(nums[mid] < nums[mid - 1]){
                r = mid - 1;
            }
        }
        return -1;
    }
};

410. 分割数组的最大值

思路+解法

二分答案 O(nlog(sum - max_num))

class Solution {
public:
    bool cal(vector<int>& nums, int max_sum, int m){
        int _m = 0;
        int temp_sum = 0;
        for(int x : nums){
            if(temp_sum + x > max_sum){
                _m++;
                temp_sum = x;
            }
            else temp_sum += x;
        }
        if(temp_sum > 0) _m++;
        return _m <= m;
    }
    int splitArray(vector<int>& nums, int m) {
        int sum = 0;
        int max_num = INT_MIN;
        for(int x : nums) {
            sum += x;
            max_num = max(max_num, x);
        }
        //二分区间为最大的元素到所有元素的和
        int l = max_num, r = sum;
        int ans = 0;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            if(cal(nums, mid, m)){
                ans = mid;
                r = mid - 1;
            }
            else{
                l = mid + 1;
            }
        }
        return ans;
    }
};

第7章位运算

191. 位1的个数

思路+解法：
1. O()

371. 两整数之和

思路+解法：
1. O()

397. 整数替换

思路+解法：
1. O()

136. 只出现一次的数字

思路+解法：

异或 O(n)

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans = 0;
        for(int& x : nums) ans ^= x;
        return ans;
    }
};

第8章设计

155. 最小栈

思路+解法：

辅助栈 O(1) O(n)

class MinStack {
public:
    stack<int> s;
    stack<int> assist_s;
    MinStack() {

    }
    
    void push(int val) {
        s.push(val);
        if(assist_s.empty() || assist_s.top() > val) assist_s.push(val);
        else if(assist_s.top() <= val) assist_s.push(assist_s.top());
    }
    
    void pop() {
        s.pop();
        assist_s.pop();
    }
    
    int top() {
        return s.top();
    }
    
    int getMin() {
        return assist_s.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

数组中存的是差值 O(1)空间复杂度

class MinStack {
public:
    stack<long long> s;
    long long min_value;
    MinStack() {

    }
    
    void push(int val) {
        if(s.empty()){
            min_value = val;
            s.push(0);
        }else{
            s.push(val - min_value);
            if(val - min_value < 0){
                min_value = val;
            }
        }
    }
    
    void pop() {
        if(s.top() > 0){
            s.pop();
        }else{
            min_value = min_value - s.top();
            s.pop();
        }
    }
    
    int top() {
        if(s.top() > 0){
            return min_value + s.top();
        }else{
            return min_value;
        }
    }
    
    int getMin() {
        return min_value;
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

208. 实现 Trie (前缀树)

思路+解法：

Trie树

const int N = 1e5+50;
bool isEnd[N];
int son[N][26];
int idx = 0;
class Trie {
public:
    /** Initialize your data structure here. */
    Trie() {
        memset(isEnd,false, sizeof(isEnd));
        memset(son, 0, sizeof(son));
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        int p = 0;
        for(auto x: word){
            int u = x - 'a';
            if(!son[p][u]){
                son[p][u] = ++idx; //默认节点是0，所以前置++
            }
            p = son[p][u]; //移动到下一个节点编号
        }
        isEnd[p] = true; //标记结尾
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        int p = 0;
        for(auto x: word){
            int u = x - 'a';
            if(!son[p][u]){
                return false;
            }
            p = son[p][u];
        }
        return isEnd[p];
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        int p = 0;
        for(auto x : prefix){
            int u = x - 'a';
            if(!son[p][u]){
                return false;
            }
            p = son[p][u];
        }
        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);
 */

亿点收获：
1. 非静态私有数据成员不能初始化

146. LRU 缓存机制

思路+解法：

哈希表 + 链表：O(1)

struct Node{
    int key, val;
    Node* pre;
    Node* next;
    Node(int k, int v): key(k), val(v), pre(nullptr), next(nullptr) {}
    Node(): key(0), val(0), pre(nullptr), next(nullptr) {}
};
class LRUCache {
private:
    unordered_map<int ,Node*> m;
    int size, capacity;
    Node* drummyHead;
    Node* drummyTail;

public:
    LRUCache(int capacity) {
        size = 0;
        this -> capacity = capacity;
        drummyHead = new Node();
        drummyTail = new Node();
        drummyHead->pre = nullptr;
        drummyHead->next = drummyTail;
        drummyTail->pre = drummyHead;
        drummyTail->next = nullptr;
    }
    
    int get(int key) {
        //cout << "get："<< key << endl;
        if(m.find(key) != m.end()){
            Node* node = m[key];

            move_to_head(node);

            return node->val;
        }
        
        return -1;
    }
    
    void put(int key, int value) {
        //cout << "put:"<< key;
        
        if(m.find(key) != m.end()){
            Node* node = m[key];

            move_to_head(node);

            node->val = value;
        }
        else{
            Node* node = new Node(key, value);
            m[key] = node;
            if(size == capacity){

                delete_tail();
                add_to_head(node);

            }else{
                add_to_head(node);
                size++;
            }
        }
        /*for(Node* b = drummyHead->next; b != drummyTail; b = b->next) cout << b->val << " ";
        cout << m.size();
        cout << endl;*/
    }
    void move_to_head(Node* node){
        Node* prenode = node->pre;
        Node* nextnode = node->next;

        prenode->next = nextnode;
        nextnode->pre = prenode;

        Node* headnextnode = drummyHead->next;

        drummyHead->next = node;
        node->pre = drummyHead;
        node->next = headnextnode;
        headnextnode->pre = node;
    }
    void add_to_head(Node* node){
        Node* headnextnode = drummyHead->next;

        drummyHead->next = node;
        node->pre = drummyHead;
        node->next = headnextnode;
        headnextnode->pre = node;
    }
    void delete_tail(){
        Node* tailpreprenode = drummyTail->pre->pre;
        Node* tailprenode = drummyTail->pre;

        tailpreprenode->next = drummyTail;
        drummyTail->pre = tailpreprenode;
        
        m.erase(tailprenode->key);
        delete tailprenode;
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

460. LFU 缓存

思路+解法：
1. https://leetcode-cn.com/problems/lfu-cache/solution/ha-xi-biao-shuang-xiang-lian-biao-c-by-l-e5e0/

1206. 设计跳表

第13章股票问题

121. 买卖股票的最佳时机

思路+解法：

贪心 O(n)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int buy = prices[0];
        int ans = 0;
        int n = prices.size();
        for(int i = 1; i < n; ++i){
            if(prices[i] > buy) ans = max(ans, prices[i] - buy);
            buy = min(buy, prices[i]);
        }
        return ans;
    }
};

动态规划 O(n)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        //持有股票、不持有股票时手中的现金量
        vector<vector<int>> dp(n, vector<int>(2));

        dp[0][0] = -prices[0];
        dp[0][1] = 0; 
        for(int i = 1; i < n; i++){
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
        }
        
        return dp[n - 1][1];
    }
};

122. 买卖股票的最佳时机 II

思路+解法：

动态规划 O(n)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector(2, 0));
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1; i < n; i++){
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
        }
        return dp[n - 1][1];
    }
};

贪心 O(n)

123. 买卖股票的最佳时机 III

思路+解法：

动态规划 O(n)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(5, 0));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;
        for(int i = 1; i < n; i++){
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[n - 1][4];
    }
};

188. 买卖股票的最佳时机 IV

思路+解法：

动态规划 O(n * k)

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() == 0) return 0;
        
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2 * k + 1, 0));
        dp[0][0] = 0;
        for(int i = 1; i < 2 * k + 1; i += 2){
            dp[0][i] = -prices[0];
            dp[0][i + 1] = 0;
        }
        for(int i = 1; i < n; i++){
            dp[i][0] = dp[i - 1][0];
            for(int j = 1; j < 2 * k + 1; j += 2){
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]);
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] + prices[i]);
            }
        }
        return dp[n - 1][2 * k];
    }
};

309. 最佳买卖股票时机含冷冻期

714. 买卖股票的最佳时机含手续费

思路+解法：

动态规划 O(n)

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] = -prices[0] - fee;
        dp[0][1] = 0;
        for(int i = 1; i < n; i++){
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i] - fee);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]); 
        }
        return dp[n - 1][1];
    }
};

你可能感兴趣的:(一些笔记,算法,数据结构)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘李虓酒评论
文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）编程经验分享开发工具服务器 ssh linux
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
蘩漪：新女性？利己主义者赮_红雨
蘩漪是曹禺《雷雨》笔下的女性形象。对于她的喜爱，曹禺在之前的访谈中，就已经表达得很清楚了，蘩漪是他所倾心的女子的“代替者”。在这个女性身上有着曹禺最精心的描写，但同时她的身上又存在着一些时代的问题。图片发自App首先，繁漪是追求自由和幸福的新女性形象。她是精神悲剧的核心人物，她对周朴园的反抗，具有典型意义。她是位资产阶级家庭出身的小姐，受过五四新思潮的影响，她任性、傲慢，追求人格独立、个性自由和爱
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
从0到500+，我是如何利用自媒体赚钱？一列脚印
运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
有舍才有得 _清净_
为什么经常讲放下？放下就是让你要舍得、舍去。喜舍心就是把自己喜欢的，用慈悲心喜舍出去。这就锻炼了你们在人间，学会放下原本不舍得的东西或一些事物，学会舍出去，学会帮助别人，学会多付出。你今天付出了慈悲心、喜舍心，以后会得到更多的缘助力。缘助力是什么？——贵人缘啊。今天没有付出，不懂得付出，什么都只会想到自己，那你也得不到缘助力。慈悲喜舍就是用慈悲心去帮助别人，用喜舍心去付出，最后也会得到别人回报。别
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
ARM中断处理过程落汤老狗嵌入式linux
一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
似乎，发生了很多事情阿皮Ponder
似乎，有很多事情正在发生。今天，我跟夫人陪着孩子走进来幼儿园，人生头一回以孩子家长的身份参加了小小的班级家长会。在幼儿园，遇见老同学。从2017年开始失联，因为对方遇到了一些事情，跟大家都失去了联系，今日再见面，分外激动，他拉着我一直聊，一直聊。感谢我们的孩子。孩子有点咳嗽，去医院做了检查。叔叔家的两个妹妹开始了高中生活，新的开始。过去看望，遇到一位老师，很是面熟。咨询之下，果然，曾经初中母校的老
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
冬天短期的暴利小生意有哪些？那些小生意适合新手做？一起高省
短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
如何成为段子手欣雅阅读
我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
java类加载顺序 3213213333332132 java
package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
Hibernate与mybitas的比较 BlueSkator sql Hibernate 框架 ibatis orm
第一章 Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
php多维数组排序以及实际工作中的应用 dcj3sjt126com PHP usort uasort
自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
DOM改变字体大小周华华前端
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
c3p0的配置 g21121 c3p0
c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。以在spring中配置dataSource为例：  <bean name="prope
Java获取工程路径的几种方法 510888780 java
第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
在类Unix系统下实现SSH免密码登录服务器 Harry642 免密 ssh
1.客户机 (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址 (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址 (3)执行cat
Java新手入门的30个基本概念一 aijuans java java 入门新手
在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
Memcached for windows 简单介绍 antlove java Web windows cache memcached
1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
数据库对象的视图和索引百合不是茶索引 oeacle数据库视图
视图视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图为什么oracle需要视图; &
Mockito(一) --入门篇 bijian1013 持续集成 mockito 单元测试
Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。 &nb
精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle 数据库 plsql
/* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
【Log4j一】Log4j总体介绍 bit1129 log4j
Log4j组件：Logger、Appender、Layout Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能：日志的输出目标日志的输出格式日志的输出级别(是否抑制日志的输出) logger继承特性 A logger is said to be an ancestor of anothe
Java IO笔记白糖_ java
public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
Docker 监控 ronin47 docker监控
目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容监控宿主机本身监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。额外的，因为是docker的
java-顺时针打印图形 bylijinnan java
一个画图程序要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下：在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。 # ${HOME} will be replaced by user home directory accordin
[并行计算]论宇宙的可计算性 comsci 并行计算
现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识...... 那么,这种概念让我们推论出一个结论 &nb
用OpenGL实现无限循环的coverflow dai_lm android coverflow
网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
JAVA数据计算的几个解决方案1 datamachine java Hibernate 计算
老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线------------------------------------- 数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J &nbs
简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
怎么创建一个简单的(非 RBAC)用户授权系统通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。数据库首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限扩展 CWebUser 类在配置文件(一般为 protecte
未选之路 dcj3sjt126com 诗
作者:罗伯特*费罗斯特黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处. 但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹. 那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
Java处理15位身份证变18位蕃薯耀 18位身份证变15位 15位身份证变18位身份证转换
15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。 Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml <!-- 激活自动代理功能参看：
Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScript html android 脚本
在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序要在webview中,调用addJavascriptInterface(OBJ,int
8个最佳Web开发资源推荐 lampcy 编程 Web 程序员
Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。这里列出10个最佳Web开发资源，它们都是受
架构师之面试------jdk的hashMap实现 nannan408 HashMap
1.前言。如题。 2.详述。 (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
html禁止清除input文本输入缓存 Rainbow702 html 缓存 input 输入框 change
多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。如果不想让浏览器缓存input的值，有2种方法：方法一：在不想使用缓存的input中添加 autocomplete="off"; <input type="text" autocomplete="off" n
POJO和JavaBean的区别和联系 tjmljw POJO java beans
POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
java中单例的五种写法 liuxiaoling java 单例
/** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri

算法通关之路的一些刷题笔记

算法通关之路

第2章 数学之美

1. 两数之和

15. 三数之和

18. 四数之和

454. 四数相加 II

16. 最接近的三数之和

53. 最大子序和(*分治法)

179. 最大数

166. 分数到小数

368. 最大整除子集

1175. 质数排列

第3章 回文的艺术

680. 验证回文字符串 Ⅱ

234. 回文链表(*)

9. 回文数

5. 最长回文子串(*)

516. 最长回文子序列

906. 超级回文数

第5章 深度优先遍历和广度优先遍历

112. 路径总和

113. 路径总和 II

124. 二叉树中的最大路径和

岛屿问题

第6章 二分法

704. 二分查找

153. 寻找旋转排序数组中的最小值

875. 爱吃香蕉的珂珂

69. Sqrt(x)

162. 寻找峰值

410. 分割数组的最大值

第7章 位运算

191. 位1的个数

371. 两整数之和

397. 整数替换

136. 只出现一次的数字

第8章 设计

155. 最小栈

208. 实现 Trie (前缀树)

146. LRU 缓存机制

460. LFU 缓存

1206. 设计跳表

第13章 股票问题

121. 买卖股票的最佳时机

122. 买卖股票的最佳时机 II

123. 买卖股票的最佳时机 III

188. 买卖股票的最佳时机 IV

309. 最佳买卖股票时机含冷冻期

714. 买卖股票的最佳时机含手续费

你可能感兴趣的:(一些笔记,算法,数据结构)

第2章数学之美

第3章回文的艺术

第5章深度优先遍历和广度优先遍历

第6章二分法

第7章位运算

第8章设计

第13章股票问题