├── Adversarial Perturbation论文精讲
    ├── DeepFool 对抗样本生成方法-更.md
    └── 对抗领域基础介绍-更.md
├── Competition Notes
    └── 华为人工智能2020语义分割大赛-更.md
├── LeetCode题解精讲
    ├── LeetCode 剑指offer
    │   ├── 剑指 Offer 03. 数组中重复的数字.md
    │   ├── 剑指 Offer 04. 二维数组中的查找.md
    │   ├── 剑指 Offer 06. 从尾到头打印链表.md
    │   └── 剑指0ffer 05. 替换空格.md
    ├── LeetCode 热题 HOT 100
    │   ├── 1. 两数之和.md
    │   └── 102. 二叉树的锯齿形层序遍历.md
    └── LeetCode每日一题
    │   ├── 103. 二叉树的锯齿形层序遍历 20-12-22.md
    │   ├── 1046. 最后一块石头的重量 20-12-30 -更.md
    │   ├── 135. 分发糖果 20-12-24.md
    │   ├── 188. 买卖股票的最佳时机 IV-更 20-12-28.md
    │   ├── 205. 同构字符串 20-12-27.md
    │   ├── 387. 字符串中的第一个唯一字符 20-12-23.md
    │   ├── 435. 无重叠区间 20-12-31 -更.md
    │   ├── 455. 分发饼干 20-12-25.md
    │   └── 746. 使用最小花费爬楼梯 20-12-21.md
├── Linux 指令与知识点汇总
    ├── Docker常用指令知识点汇总.md
    ├── Git 指令操作摘录.md
    ├── Linux shell常用知识点汇总.md
    ├── Linux 权限知识点摘录.md
    ├── Linux常用指令汇总贴.md
    ├── Linux软链接与硬链接知识点摘录.md
    ├── linux关于bashrc与profile的区别.md
    ├── 文件传输scp知识点总结.md
    └── 输入输出重定向与管道知识点.md
├── Python 知识点摘要
    └── 图像像素遍历加速.md
├── README.md
├── Semantic Segmentation 论文精讲
    └── README.md
├── vehicle tracking
    └── vehicle-tracking论文总结.md
├── 后端技术栈必备
    ├── README.md
    ├── c++ 知识点汇总.md
    ├── 事务四大特性.md
    ├── 单例模式饿汉版-懒汉版.html
    ├── 多目标跟踪网络.md
    ├── 数据库相关知识.md
    ├── 数据结构知识点汇总.md
    ├── 计算机组成原理.md
    ├── 语义分割网络.md
    └── 面试贴汇总.md
├── 常用工具记录
    ├── GitNote 笔记博客工具.md
    ├── Readme.md
    ├── Termius 服务器远程连接工具.md
    ├── Tmux 服务器后端运行神器.md
    └── 视频转rtsp流.md
└── 机器学习知识点摘要
    └── README.md


/Adversarial Perturbation论文精讲/DeepFool 对抗样本生成方法-更.md:
--------------------------------------------------------------------------------
 1 | # DeepFool 对抗样本生成方法
 2 | ***
 3 | 论文全称：DeepFool: a simple and accurate method to fool deep neural networks
 4 | 年份：2016
 5 | 出版：CVPR
 6 | ***
 7 | ## 论文思想
 8 | ![](https://github.com/jinghehehe/pictures/blob/main/deepfool-1.png)
 9 | 
10 | Deepfool


--------------------------------------------------------------------------------
/Adversarial Perturbation论文精讲/对抗领域基础介绍-更.md:
--------------------------------------------------------------------------------
1 | # 对抗领域基础介绍
2 | ***
3 | [](https://chaoge123456.github.io/%E5%AF%B9%E6%8A%97%E6%A0%B7%E6%9C%AC%E7%94%9F%E6%88%90%E7%B3%BB%E5%88%97%EF%BC%9AFGSM%E5%92%8CDeepfool.html/)
4 | ***


--------------------------------------------------------------------------------
/Competition Notes/华为人工智能2020语义分割大赛-更.md:
--------------------------------------------------------------------------------
 1 | 华为人工智能2020语义分割大赛
 2 | ***
 3 | **记录第一次进行cv领域比赛，由于和实验室所作内容相似，因此想学习相关经验和技巧，最终排名80.本文对较好的做法进行记录和总结**
 4 | ***
 5 | [赛事介绍](https://competition.huaweicloud.com/information/1000041322/introduction)
 6 | 
 7 | ## 优胜方案思路汇总
 8 | ### 第二名方案分享
 9 | [代码思路分享](https://github.com/liaochengcsu/road_segmentation_pytorch)
10 | 
11 | ### 第四名方案分享
12 | [博客分享](https://blog.csdn.net/HX_Image/article/details/111740705)
13 | [代码分享](https://github.com/Hsomething/2020_huawei_road_segmetation)
14 | 
15 | ### 第六名方案分享
16 | [代码思路分享](https://github.com/InchSoup/HWCC2020_RS_segmentation)
17 | 
18 | 持续更新
19 | 
20 | ## 思路总结
21 | 
22 | 后续更新
23 | 
24 | ***
25 | ### **喜欢Programming-Cat的话，请Star吧**
26 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode 剑指offer/剑指 Offer 03. 数组中重复的数字.md:
--------------------------------------------------------------------------------
 1 | 解法一
 2 | class Solution {
 3 | public:
 4 |     int findRepeatNumber(vector<int>& nums) {
 5 |         int len = nums.size();
 6 |         unordered_map<int,int> mp;
 7 |         for(int i=0;i<len;i++){
 8 |             if(mp.find(nums[i])!=mp.end()){
 9 |                 return nums[i];
10 |             }
11 |             mp[nums[i]]++;
12 |         }
13 |         return -1;
14 |     }
15 | };
16 | 解法二
17 | class Solution {
18 | public:
19 |     int findRepeatNumber(vector<int>& nums) {
20 |         int len = nums.size();
21 |         for(int i=0;i<len;i++){
22 |             while(i!=nums[i]){
23 |                 if(nums[i] == nums[nums[i]]){
24 |                     return nums[i];
25 |                 }
26 |                 swap(nums[i],nums[nums[i]]);
27 |             }
28 |         }
29 |         return -1;
30 |     }
31 | };


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode 剑指offer/剑指 Offer 04. 二维数组中的查找.md:
--------------------------------------------------------------------------------
 1 | # 剑指 Offer 04. 二维数组中的查找
 2 | ***
 3 | 来源： LeetCode 剑指offer
 4 | 相关企业： 字节跳动
 5 | 相关标签： 数组，双指针
 6 | 难度： 中等
 7 | 相似题型： 同主站240题
 8 | ***
 9 | ## 题干内容
10 | 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
11 | 
12 |  
13 | 
14 | 示例:
15 | 
16 | 现有矩阵 matrix 如下：
17 | 
18 | 
19 | ![](https://github.com/jinghehehe/pictures/blob/main/%E5%89%91%E6%8C%874.png)
20 | 
21 | 
22 | 给定 target = 5，返回 true。
23 | 
24 | 给定 target = 20，返回 false。
25 | 
26 |  
27 | 
28 | 限制：
29 | 
30 | 0 <= n <= 1000
31 | 
32 | 0 <= m <= 1000
33 | 
34 | 
35 | 来源：力扣（LeetCode）
36 | 链接：https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof
37 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
38 | 
39 | ## 题眼题解
40 | ### 题眼:
41 | **本题是根据数组特性利用双指针来快速寻找目标数值**
42 | 
43 | - 首先从右上角开始寻找，小于target向下，大于target向左，如果出界则意味着false。
44 | - 注意判断数组为空特殊情况。
45 | 
46 | 
47 | ### 题解：
48 | #### c++版本一，时间复杂度 O(n+m), 空间复杂度 O(1)。
49 | ```language
50 | class Solution {
51 | public:
52 |     bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
53 |         int n = matrix.size();
54 |         if(n==0) return false;
55 |         int m = matrix[0].size();
56 |         int index = 0;
57 |         int i = 0, j = m-1;
58 |         while(i<n&&j>=0){
59 |             if(target==matrix[i][j])
60 |                 return true;
61 |             else if(target>matrix[i][j]){
62 |                 i++;
63 |             }else{
64 |                 j--;
65 |             }
66 |         }
67 |         return false;
68 |     }
69 | };
70 | ```
71 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(1)
72 | ```language
73 | # 与c++版本一相同。
74 | 待更
75 | ```
76 | ***
77 | 
78 | ### **喜欢Programming-Cat的话，请Star吧**
79 | 
80 | 
81 | 
82 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode 剑指offer/剑指 Offer 06. 从尾到头打印链表.md:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Definition for singly-linked list.
 3 |  * struct ListNode {
 4 |  *     int val;
 5 |  *     ListNode *next;
 6 |  *     ListNode(int x) : val(x), next(NULL) {}
 7 |  * };
 8 |  */
 9 | class Solution {
10 | public:
11 |     vector<int> reversePrint(ListNode* head) {
12 |         if(head == NULL) return {};
13 |         vector<int> res;
14 |         while(head!=NULL){
15 |             res.push_back(head->val);
16 |             head = head->next;
17 |         }
18 |         reverse(res.begin(),res.end());
19 |         return res;
20 |     }
21 |     
22 | };


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode 剑指offer/剑指0ffer 05. 替换空格.md:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     string replaceSpace(string s) {
 4 |         int pos;
 5 |         while((pos = s.find(" "))!=s.npos){
 6 |             s = s.replace(s.find(" "),1,"%20");
 7 |         }
 8 |         return s;
 9 |     }
10 | };


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode 热题 HOT 100/1. 两数之和.md:
--------------------------------------------------------------------------------
 1 | # 1. 两数之和
 2 | ***
 3 | 来源： LeetCode 热题Hot-100 
 4 | 相关企业： 字节跳动， 腾讯， 阿里巴巴， 美团点评
 5 | 相关标签： 数组， 哈希表
 6 | 难度： 简单
 7 | 相似题目： 两数之和II - 输入有序数组， 两数之和III - 数据结构设计，两数之和 IV - 输入 BST，三数之和，四数之和
 8 | ***
 9 | ## 题干内容
10 | 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
11 | 
12 | 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
13 | 
14 | ![](https://github.com/jinghehehe/pictures/blob/main/1-1.png)
15 | 
16 | 来源：力扣（LeetCode）
17 | 链接：https://leetcode-cn.com/problems/two-sum
18 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
19 | 
20 | 
21 | ## 题眼题解
22 | ### 题眼:
23 | **暴力不是本文考虑的解法，且返回数组下标，不能进行排序+双指针解法，因此本文采用哈希表方法求解**
24 | 
25 | - 题目中说数组中同一个元素不能使用两遍，但是会存在同一元素，因此两遍哈希（一遍存，一遍搜索）不能解决重复元素问题
26 | - 因此采用一遍哈希来解决问题，即一边遍历一边搜索。
27 | 
28 | 
29 | ```language
30 | //哈希表中已存在.
31 | mp.find(target-nums[i])!=mp.end()
32 | ```
33 | 
34 | ### 题解：
35 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(n)。
36 | ```language
37 | class Solution {
38 | public:
39 |     vector<int> twoSum(vector<int>& nums, int target) {
40 | 	//结果初始化.
41 |         vector<int> result(2,-1);
42 |         unordered_map<int, int> mp;
43 |         int len = nums.size();
44 |         for(int i=0; i<len; i++){
45 |             if(mp.find(target-nums[i])!=mp.end()){
46 |                 result[0] = mp[target-nums[i]];
47 |                 result[1] = i;
48 |                 break;
49 |             }
50 |             mp[nums[i]] = i;
51 |         }
52 |         return result;
53 |     }
54 | };
55 | ```
56 | 
57 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(n)
58 | ```language
59 | # 与c++版本一相同。
60 | class Solution:
61 |     def twoSum(self, nums: List[int], target: int) -> List[int]:
62 |         hashmap = {}
63 |         for i, num in enumerate(nums):
64 |             if hashmap.get(target - num) is not None:
65 |                 return [i,hashmap.get(target - num)]
66 |             hashmap[num] = i
67 | ```
68 | ***
69 | 
70 | ### **喜欢Programming-Cat的话，请Star吧**
71 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode 热题 HOT 100/102. 二叉树的锯齿形层序遍历.md:
--------------------------------------------------------------------------------
  1 | 103. 二叉树的层序遍历
  2 | ***
  3 | 来源： LeetCode 热题Hot-100
  4 | 相关企业： 亚马逊， 字节跳动， 微软
  5 | 相关标签： 树， 广度优先搜索
  6 | 难度： 中等
  7 | 相似题目：  二叉树的锯齿形层序遍历(同类型题)，二叉树的层序遍历 II
  8 | ***
  9 | ## 题干内容
 10 | 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）
 11 | 
 12 | 示例：
 13 | 二叉树：[3,9,20,null,null,15,7],
 14 | 
 15 | ![](https://github.com/jinghehehe/pictures/blob/main/103-1.png)
 16 | 
 17 | 返回其层序遍历结果：
 18 | 
 19 | ![](https://github.com/jinghehehe/pictures/blob/main/102-2.png)
 20 | 
 21 | 来源：力扣（LeetCode）
 22 | 链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 23 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 24 | 
 25 | ## 题眼题解
 26 | ### 题眼:
 27 | **本题是针对树的广度优先搜索进行考察，重点牢记广度优先搜索模板**
 28 | 
 29 | - 首先树根节点判空，然后队列添加根节点，队列不为空时，依次取出队首元素，将其放入题干所需数组中，并将队首元素的子节点添加到队列尾部，每一层元素均被放在一个数组中，即广度优先搜索思想。
 30 | 
 31 | 
 32 | ### 题解：
 33 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(n)。
 34 | ```language
 35 | /**
 36 |  * Definition for a binary tree node.
 37 |  * struct TreeNode {
 38 |  *     int val;
 39 |  *     TreeNode *left;
 40 |  *     TreeNode *right;
 41 |  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 42 |  * };
 43 |  */
 44 | class Solution {
 45 | public:
 46 |     vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
 47 |         vector<vector<int> > result;
 48 |         if(root == NULL)
 49 |             return result;
 50 |         queue<TreeNode*> q;
 51 |         q.push(root);
 52 |         while(!q.empty()){
 53 |             vector<int> levelList;
 54 |             int size = q.size();
 55 |             for(int i=0; i<size; i++){
 56 |                 auto p = q.front();
 57 |                 q.pop();
 58 |                 levelList.push_back(p->val);
 59 |                 if(p->left)
 60 |                     q.push(p->left);
 61 |                 if(p->right)
 62 |                     q.push(p->right);
 63 |             } 
 64 |             result.emplace_back(levelList.begin(), levelList.end());
 65 |         }
 66 |         return result;
 67 |     }
 68 | };
 69 | ```
 70 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(1)
 71 | ```language
 72 | # 与c++版本一相同。
 73 | # Definition for a binary tree node.
 74 | # class TreeNode:
 75 | #     def __init__(self, x):
 76 | #         self.val = x
 77 | #         self.left = None
 78 | #         self.right = None
 79 | 
 80 | class Solution:
 81 |     def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
 82 |         if not root:
 83 |             return []
 84 |         q = deque()
 85 |         q.append(root)
 86 |         result = []
 87 |         while q:
 88 |             levellist = deque()
 89 |             size = len(q)
 90 |             for _ in range(size):
 91 |                 node = q.popleft()
 92 |                 levellist.append(node.val)
 93 |                 if node.left:
 94 |                     q.append(node.left)
 95 |                 if node.right:
 96 |                     q.append(node.right)
 97 | 	    #队列转化为列表
 98 |             result.append(list(levellist))
 99 |         return result
100 | 
101 | ```
102 | ***
103 | 
104 | ### **喜欢Programming-Cat的话，请Star吧**
105 | 
106 | 
107 | 
108 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/103. 二叉树的锯齿形层序遍历 20-12-22.md:
--------------------------------------------------------------------------------
  1 | 103. 二叉树的锯齿形层序遍历
  2 | ***
  3 | 来源： LeetCode 每日一题 20/12/22
  4 | 相关企业： 亚马逊， 字节跳动， 微软
  5 | 相关标签： 栈， 树， 广度优先搜索
  6 | 难度： 中等
  7 | 相似题目： 二叉树的层序遍历(同类型题)
  8 | ***
  9 | ## 题干内容
 10 | 给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
 11 | 
 12 | 例如：
 13 | 给定二叉树 [3,9,20,null,null,15,7],
 14 | 
 15 | ![](https://github.com/jinghehehe/pictures/blob/main/103-1.png)
 16 | 
 17 | 返回锯齿形层序遍历如下：
 18 | 
 19 | ![](https://github.com/jinghehehe/pictures/blob/main/103-2.png)
 20 | 
 21 | 来源：力扣（LeetCode）
 22 | 链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal
 23 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 24 | 
 25 | ## 题眼题解
 26 | ### 题眼:
 27 | **本题是针对树的广度优先搜索的一个简单变形，可以先做102题二叉树的层序遍历，再做此题，重点牢记广度优先搜索模板**
 28 | 
 29 | - 首先树根节点判空，然后队列添加根节点，队列不为空时，依次取出队首元素，将其放入题干所需数组中，并将队首元素的子节点添加到队列尾部，每一层元素均被放在一个数组中，即广度优先搜索思想。
 30 | 
 31 | - 本题与102题不同之处在于，需要将偶数层树节点转置以符合题干要求，或者采用双端队列，将元素从队列头部插入。
 32 | ```language、
 33 | //vector转置
 34 | reverse(v1.begin(),v1.end());
 35 | //双端队列
 36 | deque: push_back, push_front;
 37 | ```
 38 | 
 39 | ### 题解：
 40 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(n)。
 41 | ```language
 42 | /**
 43 |  * Definition for a binary tree node.
 44 |  * struct TreeNode {
 45 |  *     int val;
 46 |  *     TreeNode *left;
 47 |  *     TreeNode *right;
 48 |  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 49 |  * };
 50 |  */
 51 | class Solution {
 52 | public:
 53 |     vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
 54 |         vector<vector<int> > result;
 55 |         if(root == NULL)
 56 |             return result;
 57 |         queue<TreeNode*> q;
 58 |         q.push(root);
 59 | 	// 奇偶层树判断
 60 |         bool flag = true;
 61 |         while(!q.empty()){
 62 |             deque<int> levelList;
 63 |             int size = q.size();
 64 |             for(int i=0; i<size; i++){
 65 |                 auto p = q.front();
 66 |                 q.pop();
 67 |                 if(flag) {
 68 |                     levelList.push_back(p->val);
 69 |                 }else {
 70 |                     levelList.push_front(p->val);
 71 |                 }
 72 |                 if(p->left)
 73 |                     q.push(p->left);
 74 |                 if(p->right)
 75 |                     q.push(p->right);
 76 |             } 
 77 |             result.emplace_back(levelList.begin(), levelList.end());
 78 |             flag = !flag;
 79 |             //result.emplace_back(vector<int>{levelList.begin(), levelList.end()});
 80 |         }
 81 |         return result;
 82 |     }
 83 | };
 84 | ```
 85 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(n)
 86 | ```language
 87 | # 与c++版本一相同。
 88 | # Definition for a binary tree node.
 89 | # class TreeNode:
 90 | #     def __init__(self, x):
 91 | #         self.val = x
 92 | #         self.left = None
 93 | #         self.right = None
 94 | 
 95 | class Solution:
 96 |     def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
 97 |         if not root:
 98 |             return []
 99 |         q = deque()
100 |         q.append(root)
101 |         flag = True
102 |         result = []
103 |         while q:
104 |             levellist = deque()
105 |             size = len(q)
106 |             for _ in range(size):
107 |                 node = q.popleft()
108 |                 if flag:
109 |                     levellist.append(node.val)
110 |                 else:
111 |                     levellist.appendleft(node.val)
112 |                 if node.left:
113 |                     q.append(node.left)
114 |                 if node.right:
115 |                     q.append(node.right)
116 | 	    #队列转化为列表
117 |             result.append(list(levellist))
118 |             flag = not flag
119 |         return result
120 | 
121 | ```
122 | ***
123 | 
124 | ### **喜欢Programming-Cat的话，请Star吧**
125 | 
126 | 
127 | 
128 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/1046. 最后一块石头的重量 20-12-30 -更.md:
--------------------------------------------------------------------------------
 1 | # 1046. 最后一块石头的重量
 2 | ***
 3 | 来源： LeetCode 每日一题 20/12/30
 4 | 相关企业： 亚马逊
 5 | 相关标签： 贪心算法，堆（优先队列）
 6 | 难度： 简单
 7 | ***
 8 | ## 题干内容
 9 | 有一堆石头，每块石头的重量都是正整数。
10 | 
11 | 每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
12 | 
13 | 如果 x == y，那么两块石头都会被完全粉碎；
14 | 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
15 | 最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。
16 | 
17 |  
18 | 
19 | 示例：
20 | 
21 | 
22 | ![](https://github.com/jinghehehe/pictures/blob/main/1046-1.png)
23 | 
24 | 提示：
25 | 
26 | 1 <= stones.length <= 30
27 | 1 <= stones[i] <= 1000
28 | 
29 | 来源：力扣（LeetCode）
30 | 链接：https://leetcode-cn.com/problems/last-stone-weight
31 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
32 | 
33 | ## 题眼题解
34 | ### 题眼:
35 | **贪心算法，待更**
36 | 
37 | ### 题解：
38 | #### c++版本一，时间复杂度 O(nlogn), 空间复杂度 O(n)。
39 | ```language
40 | class Solution {
41 | public:
42 |     int lastStoneWeight(vector<int>& stones) {
43 |         priority_queue<int> q;
44 |         for (int s: stones) {
45 |             q.push(s);
46 |         }
47 | 
48 |         while (q.size() > 1) {
49 |             int a = q.top();
50 |             q.pop();
51 |             int b = q.top();
52 |             q.pop();
53 |             if (a > b) {
54 |                 q.push(a - b);
55 |             }
56 |         }
57 |         return q.empty() ? 0 : q.top();
58 |     }
59 | };
60 | ```
61 | 
62 | #### python3版本一，时间复杂度 O(nlogn), 空间复杂度 O(n)。
63 | ```language
64 | # 与c++版本一相同。
65 | 待更
66 | ```
67 | ***
68 | 
69 | ### **喜欢Programming-Cat的话，请Star吧**
70 | 
71 | 
72 | 
73 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/135. 分发糖果 20-12-24.md:
--------------------------------------------------------------------------------
  1 | # 135. 分发糖果
  2 | ***
  3 | 来源： LeetCode 每日一题 20/12/24
  4 | 相关企业： 亚马逊， 字节跳动， 华为
  5 | 相关标签： 贪心算法
  6 | 难度： 困难
  7 | ***
  8 | ## 题干内容
  9 | 老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
 10 | 
 11 | 你需要按照以下要求，帮助老师给这些孩子分发糖果：
 12 | 
 13 | 每个孩子至少分配到 1 个糖果。
 14 | 相邻的孩子中，评分高的孩子必须获得更多的糖果。
 15 | 那么这样下来，老师至少需要准备多少颗糖果呢？
 16 | 
 17 | 示例 1:
 18 | 
 19 | 
 20 | ![](https://github.com/jinghehehe/pictures/blob/main/135-1.png)
 21 | 
 22 | 示例 2:
 23 | 
 24 | ![](https://github.com/jinghehehe/pictures/blob/main/135-2.png)
 25 | 
 26 | 来源：力扣（LeetCode）
 27 | 链接：https://leetcode-cn.com/problems/candy
 28 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 29 | 
 30 | ## 题眼题解
 31 | ### 题眼:
 32 | **通常题干有最少二字通常是贪心及动态规划思想，因为评分高会得到更多的糖果，先考虑从左到右，如果是1，2，3，4，则糖果数量依次为1，2，3，4；如果是1，2，3，2呢，糖果数为1，2，3，1，同理从右往左数也会得到1，1，1，1和1，1，2，1；上述两个条件均满足的糖果数量即为最少糖果数：**
 33 | 
 34 | - 从左到右：
 35 | ```language
 36 |             if (i > 0 && ratings[i] > ratings[i - 1]) {
 37 |                 left[i] = left[i - 1] + 1;
 38 |             } else {
 39 |                 left[i] = 1;
 40 |             }
 41 | ```
 42 | 
 43 | - 从右到左：
 44 | ```language
 45 | if (i < n - 1 && ratings[i] > ratings[i + 1]) {
 46 |                 right++;
 47 |             } else {
 48 |                 right = 1;
 49 |             }
 50 |             ret += max(left[i], right);
 51 | ```
 52 | 
 53 | ### 题解：
 54 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(n)。
 55 | ```language
 56 | class Solution {
 57 | public:
 58 |     int candy(vector<int>& ratings) {
 59 |         int n = ratings.size();
 60 |         vector<int> left(n);
 61 |         for (int i = 0; i < n; i++) {
 62 |             if (i > 0 && ratings[i] > ratings[i - 1]) {
 63 |                 left[i] = left[i - 1] + 1;
 64 |             } else {
 65 |                 left[i] = 1;
 66 |             }
 67 |         }
 68 |         int right = 0, ret = 0;
 69 |         for (int i = n - 1; i >= 0; i--) {
 70 |             if (i < n - 1 && ratings[i] > ratings[i + 1]) {
 71 |                 right++;
 72 |             } else {
 73 |                 right = 1;
 74 |             }
 75 |             ret += max(left[i], right);
 76 |         }
 77 |         return ret;
 78 |     }
 79 | };
 80 | ```
 81 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(n)
 82 | ```language
 83 | # 与c++版本一相同。
 84 | class Solution:
 85 |     def candy(self, ratings: List[int]) -> int:
 86 |         size = len(ratings)
 87 |         left = [0] * size
 88 |         right = 1
 89 |         count = 0
 90 |         for i in range(size):
 91 |             if i>0 and ratings[i]>ratings[i-1]:
 92 |                 left[i] = left[i-1]+1
 93 |             else:
 94 |                 left[i] = 1
 95 |         for i in range(size-1, -1, -1):
 96 |             if i<size-1 and ratings[i]>ratings[i+1]:
 97 |                 right = right + 1
 98 |             else:
 99 |                 right = 1
100 |             num = max(left[i], right)
101 |             count += num
102 |         return count
103 | ```
104 | ***
105 | 
106 | ### **喜欢Programming-Cat的话，请Star吧**
107 | 
108 | 
109 | 
110 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/188. 买卖股票的最佳时机 IV-更 20-12-28.md:
--------------------------------------------------------------------------------
 1 | # 188. 买卖股票的最佳时机 IV
 2 | ***
 3 | 来源： LeetCode 每日一题 20/12/28
 4 | 相关企业： 亚马逊，谷歌，字节跳动
 5 | 相关标签： 动态规划
 6 | 难度： 困难
 7 | ***
 8 | ## 题干内容
 9 | 给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
10 | 
11 | 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
12 | 
13 | 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
14 | 
15 |  
16 | 
17 | 示例 1：
18 | 
19 | 
20 | ![](https://github.com/jinghehehe/pictures/blob/main/188-1.png)
21 |  
22 | 示例 2:
23 | 
24 | 
25 | ![](https://github.com/jinghehehe/pictures/blob/main/188-2.png)
26 | 
27 | 提示：
28 | 
29 | 0 <= k <= 109
30 | 0 <= prices.length <= 1000
31 | 0 <= prices[i] <= 1000
32 | 
33 | 来源：力扣（LeetCode）
34 | 链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv
35 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
36 | 
37 | ## 题眼题解
38 | ### 题眼:
39 | **动态规划思想，待更**
40 | 
41 | ### 题解：
42 | #### c++版本一，时间复杂度 O(n2), 空间复杂度 O(n3)。
43 | ```language
44 | class Solution {
45 | public:
46 |     int maxkProfit(vector<int>& prices){
47 |         int n = prices.size();
48 |         vector<vector<int>> dp(n, vector<int>(2)); 
49 |         for(int i=0; i<n; i++){
50 |                 if(i==0){
51 |                     dp[0][0] = 0;
52 |                     dp[0][1] = -prices[0];
53 |                     continue;
54 |                 }
55 |                 dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i]);
56 |                 dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i]);
57 |         }
58 |         return dp[n-1][0];
59 |     }
60 |     int maxProfit(int k, vector<int>& prices) {
61 |         int n = prices.size();
62 |         if(n==0) return 0;
63 |         if(k>n/2){
64 |             return maxkProfit(prices);
65 |         }
66 |         vector<vector<vector<int>>> dp(n,vector<vector<int>>(k+1, vector<int>(2))); 
67 |         for(int i=0; i<n; i++){
68 |             dp[i][0][0] = 0;
69 |             dp[i][0][1] = INT_MIN;
70 |         }
71 |         for(int i=0; i<n; i++){
72 |             for(int j=k; j>=1; j--){
73 |                 if(i==0){
74 |                     dp[0][j][0] = 0;
75 |                     dp[0][j][1] = -prices[0]; 
76 |                     continue;
77 |                 }
78 |                 dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1]+prices[i]);
79 |                 dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0]-prices[i]);
80 |             }
81 |         }
82 |         return dp[n-1][k][0];
83 |     }
84 | };
85 | ```
86 | [神仙题解](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/solution/yi-chong-ji-yu-wqs-er-fen-de-you-xiu-zuo-x36r/)
87 | #### python3版本一，时间复杂度 O(n2), 空间复杂度 O(n3)。
88 | ```language
89 | # 与c++版本一相同。
90 | 
91 | ```
92 | ***
93 | 
94 | ### **喜欢Programming-Cat的话，请Star吧**
95 | 
96 | 
97 | 
98 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/205. 同构字符串 20-12-27.md:
--------------------------------------------------------------------------------
  1 | # 205. 同构字符串
  2 | ***
  3 | 来源： LeetCode 每日一题 20/12/27
  4 | 相关企业： 亚马逊，苹果
  5 | 相关标签： 哈希表
  6 | 难度： 简单
  7 | ***
  8 | ## 题干内容
  9 | 给定两个字符串 s 和 t，判断它们是否是同构的。
 10 | 
 11 | 如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
 12 | 
 13 | 所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
 14 | 
 15 | 示例 1:
 16 | 
 17 | ![](https://github.com/jinghehehe/pictures/blob/main/205-1.png)
 18 |  
 19 | 示例 2:
 20 | 
 21 | 
 22 | ![](https://github.com/jinghehehe/pictures/blob/main/205-2.png)
 23 | 
 24 | 示例 3:
 25 | 
 26 | ![](https://github.com/jinghehehe/pictures/blob/main/205-3.png)
 27 | 
 28 | 说明:
 29 | 你可以假设 s 和 t 具有相同的长度。
 30 | 
 31 | 来源：力扣（LeetCode）
 32 | 链接：https://leetcode-cn.com/problems/isomorphic-strings
 33 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 34 | 
 35 | ## 题眼题解
 36 | ### 题眼:
 37 | **可以看出本题可以采用哈希表来做，需要注意的是，因为两个字符不能映射到同一字符上，因此需要将两个字符串相互映射，即使用两个哈希表来求解**
 38 | 
 39 | ### 题解：
 40 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(26)。
 41 | ```language
 42 | class Solution {
 43 | public:
 44 |     bool isIsomorphic(string s, string t) {
 45 |         int len = s.size();
 46 |         if(len == 0)
 47 |             return true;
 48 |         unordered_map<char, char> mp,mp2;
 49 |         for(int i=0; i<len; i++){
 50 |             if(mp.find(s[i])!=mp.end()){
 51 |                 if(mp[s[i]] == t[i]){    
 52 |                     continue;
 53 |                 }   
 54 |                 else
 55 |                     return false;
 56 |             }
 57 |             mp[s[i]] = t[i];
 58 |         }
 59 |         for(int i=0; i<len; i++){
 60 |             if(mp2.find(t[i])!=mp2.end()){
 61 |                 if(mp2[t[i]] == s[i]){    
 62 |                     continue;
 63 |                 }   
 64 |                 else
 65 |                     return false;
 66 |             }
 67 |             mp2[t[i]] = s[i];
 68 |         }
 69 |         return true;
 70 |     }
 71 | };
 72 | ```
 73 | #### python3版本一，时间复杂度 O(n), 空间复杂度 O(26)。
 74 | ```language
 75 | # 与c++版本一相同。
 76 | class Solution:
 77 |     def isIsomorphic(self, s: str, t: str) -> bool:
 78 |         # size = len(s)
 79 |         # dict1 = {}
 80 |         # dict2 = {}
 81 |         # for i in range(size):
 82 |         #     if dict1.get(s[i]):
 83 |         #         if dict1[s[i]] != t[i]:
 84 |         #             return False
 85 |         #     dict1[s[i]] = t[i] 
 86 |         # for i in range(size):
 87 |         #     if dict2.get(t[i]):
 88 |         #         if dict2[t[i]] != s[i]:
 89 |         #             return False
 90 |         #     dict2[t[i]] = s[i] 
 91 |         # return True
 92 |         if not s:
 93 |             return True
 94 |         dic={}
 95 |         for i in range(len(s)):
 96 |             if s[i] not in dic:
 97 |                 if t[i] in dic.values():
 98 |                     return False
 99 |                 else:
100 |                     dic[s[i]]=t[i]
101 |             else:
102 |                 if dic[s[i]]!=t[i]:
103 |                     return False
104 |         return True
105 | ```
106 | ***
107 | 
108 | ### **喜欢Programming-Cat的话，请Star吧**
109 | 
110 | 
111 | 
112 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/387. 字符串中的第一个唯一字符 20-12-23.md:
--------------------------------------------------------------------------------
  1 | 387. 字符串中的第一个唯一字符
  2 | ***
  3 | 来源： LeetCode 每日一题 20/12/23
  4 | 相关企业： 亚马逊， Facebook， 苹果
  5 | 相关标签： 哈希表， 字符串
  6 | 难度： 简单
  7 | 相似题目：  根据字符出现频率排序
  8 | ***
  9 | ## 题干内容
 10 | 给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
 11 | 
 12 | 示例：
 13 | 
 14 | ![](https://github.com/jinghehehe/pictures/blob/main/387-1.png)
 15 | 
 16 | 提示：你可以假定该字符串只包含小写字母。
 17 | 
 18 | 来源：力扣（LeetCode）
 19 | 链接：https://leetcode-cn.com/problems/first-unique-character-in-a-string/
 20 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 21 | 
 22 | ## 题眼题解
 23 | ### 题眼:
 24 | **本题是针对哈希进行考察，利用哈希搜索来寻找所求字符**
 25 | 
 26 | - 本题除了采用Map思想，还可以使用数组，能够提升性能。
 27 | 
 28 | 
 29 | ### 题解：
 30 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(26)。
 31 | ```language
 32 | class Solution {
 33 | public:
 34 |     int firstUniqChar(string s) {
 35 |         unordered_map<char,int> mp;
 36 |         int len = s.size();
 37 |         for(int i=0; i<len; i++){
 38 |             mp[s[i]]++;   
 39 |         }
 40 |         for(int i=0; i<len; i++){
 41 |             if(mp[s[i]] == 1)
 42 |                 return i;
 43 |         }
 44 |         return -1;
 45 |     }
 46 | };
 47 | ```
 48 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(26)。
 49 | ```language
 50 | class Solution {
 51 | public:
 52 |     int firstUniqChar(string s) {
 53 |         unordered_map<char,int> mp;
 54 |         int len = s.size();
 55 |         for(int i=0; i<len; i++){
 56 |             mp[s[i]]++;   
 57 |         }
 58 |         for(int i=0; i<len; i++){
 59 |             if(mp[s[i]] == 1)
 60 |                 return i;
 61 |         }
 62 |         return -1;
 63 |     }
 64 | };
 65 | ```
 66 | #### c++版本二，时间复杂度 O(n), 空间复杂度 O(26)。
 67 | ```language
 68 | class Solution {
 69 | public:
 70 |     int firstUniqChar(string s) {
 71 |         int mp[26] = {0};
 72 |         //unordered_map<char,int> mp;
 73 |         int len = s.size();
 74 |         for(int i=0; i<len; i++){
 75 |             mp[s[i]-'a']++;   
 76 |         }
 77 |         for(int i=0; i<len; i++){
 78 |             if(mp[s[i]-'a'] == 1)
 79 |                 return i;
 80 |         }
 81 |         return -1;
 82 |     }
 83 | };
 84 | ```
 85 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(26)
 86 | ```language
 87 | # 与c++版本一相同。
 88 | class Solution:
 89 |     def firstUniqChar(self,s):
 90 |         dct = dict()
 91 |         for c in s:
 92 |             dct[c] = dct.get(c,0) +1     
 93 |             # dct.get(key,default= )： 判断key是否在哈希表dct里，如果未存在，则dct[key]等于default设置的值；存在则返回dct[key]的值  
 94 |         for i, c in enumerate(s):
 95 |             if dct[c] == 1:
 96 |                 return i
 97 |         return -1
 98 | 
 99 | ```
100 | #### python3版本二，时间复杂度 O(n),空间复杂度 O(26)
101 | ```language
102 | class Solution:
103 |     def firstUniqChar(self,s):
104 |         dct = collections.Counter(s)    
105 |         # collections.Counter() 快速设置哈希表，其中value的值是每个key出现的次数
106 |         for i, c in enumerate(s):
107 |             if dct[c] == 1:
108 |                 return i
109 |         return -1
110 | ```
111 | ***
112 | 
113 | ### **喜欢Programming-Cat的话，请Star吧**
114 | 
115 | 
116 | 
117 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/435. 无重叠区间 20-12-31 -更.md:
--------------------------------------------------------------------------------
 1 | # 435. 无重叠区间 
 2 | ***
 3 | 来源： LeetCode 每日一题 20/12/31
 4 | 相关企业： 亚马逊，谷歌，字节跳动，商汤
 5 | 相关标签： 贪心算法
 6 | 难度： 中等
 7 | ***
 8 | ## 题干内容
 9 | 给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。
10 | 
11 | 注意:
12 | 
13 | 可以认为区间的终点总是大于它的起点。
14 | 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
15 | 示例 1:
16 | 
17 | 
18 | 
19 | 
20 | ![](https://github.com/jinghehehe/pictures/blob/main/435-1.png)
21 |  
22 | 示例 2:
23 | 
24 | 
25 | ![](https://github.com/jinghehehe/pictures/blob/main/435-2.png)
26 | 
27 | 示例 3:
28 | 
29 | ![](https://github.com/jinghehehe/pictures/blob/main/435-3.png)
30 | 
31 | 来源：力扣（LeetCode）
32 | 链接：https://leetcode-cn.com/problems/non-overlapping-intervals
33 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
34 | 
35 | ## 题眼题解
36 | ### 题眼:
37 | **贪心算法，待更**
38 | 
39 | ### 题解：
40 | #### c++版本一，时间复杂度 O(nlogn), 空间复杂度 O(logn)。
41 | ```language
42 | class Solution {
43 | public:
44 |     int eraseOverlapIntervals(vector<vector<int>>& intervals) {
45 |         int len = intervals.size();
46 |         if(len == 0) return 0;
47 |         sort(intervals.begin(),intervals.end(),[](const vector<int> &a, const vector<int> &b) {return a[1] < b[1]; });
48 |         //cout<<intervals[0][0]       
49 |         int end = intervals[0][1];
50 |         int count = 0;
51 |         for(int i=1; i<len; i++){
52 |             if(intervals[i][0] < end){
53 |                 count++;
54 |             }
55 |             else{
56 |                 end = intervals[i][1];
57 |             }
58 |                 
59 |         }
60 |         return count;
61 |     }
62 | };
63 | ```
64 | 
65 | #### python3版本一，时间复杂度 O(nlogn), 空间复杂度 O(logn)。
66 | ```language
67 | # 与c++版本一相同。
68 | 待更
69 | ```
70 | ***
71 | 
72 | ### **喜欢Programming-Cat的话，请Star吧**
73 | 
74 | 
75 | 
76 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/455. 分发饼干 20-12-25.md:
--------------------------------------------------------------------------------
 1 | # 205. 同构字符串
 2 | ***
 3 | 来源： LeetCode 每日一题 20/12/25
 4 | 相关企业： 亚马逊
 5 | 相关标签： 贪心算法
 6 | 难度： 简单
 7 | ***
 8 | ## 题干内容
 9 | 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
10 | 
11 | 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
12 | 
13 |  
14 | 示例 1:
15 | 
16 | 
17 | ![](https://github.com/jinghehehe/pictures/blob/main/455-1.png)
18 | 
19 | 示例 2:
20 | 
21 | ![](https://github.com/jinghehehe/pictures/blob/main/455-2.png)
22 | 
23 | 提示：
24 | 
25 | 1 <= g.length <= 3 * 104
26 | 0 <= s.length <= 3 * 104
27 | 1 <= g[i], s[j] <= 231 - 1
28 | 
29 | 来源：力扣（LeetCode）
30 | 链接：https://leetcode-cn.com/problems/assign-cookies
31 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
32 | 
33 | ## 题眼题解
34 | ### 题眼:
35 | **题干出现最多满足，涉及到贪心思想，即让食量最小的孩子，分给满足要求的最小饼干，因此也需要先进行排序**
36 | 
37 | ### 题解：
38 | #### c++版本一，时间复杂度 O(nlogn), 空间复杂度 O(logn)。//排序开销
39 | ```language
40 | class Solution {
41 | public:
42 |     int findContentChildren(vector<int>& g, vector<int>& s) {
43 |         sort(g.begin(), g.end());
44 |         sort(s.begin(), s.end());
45 |         int glen = g.size();
46 |         int slen = s.size();
47 |         int i=0, j=0, count=0;
48 |         while(i<glen && j<slen){
49 |             if(g[i] <= s[j]){
50 |                 count++;
51 |                 i++;
52 |                 j++;
53 |             }
54 |             else {
55 |                 j++;
56 |             }
57 |         }
58 |         return count;
59 |     }
60 | };
61 | ```
62 | #### python3版本一，时间复杂度 O(nlogn), 空间复杂度 O(logn)。
63 | ```language
64 | # 与c++版本一相同。
65 | class Solution:
66 |     def findContentChildren(self, g: List[int], s: List[int]) -> int:
67 |         g.sort()
68 |         s.sort()
69 |         glen = len(g)
70 |         slen = len(s)
71 |         gi = si = count = 0
72 |         while gi<glen and si<slen:
73 |             if g[gi] <= s[si]:
74 |                 gi+=1
75 |                 si+=1
76 |                 count+=1
77 |             else:
78 |                 si+=1
79 |         return count
80 | ```
81 | ***
82 | 
83 | ### **喜欢Programming-Cat的话，请Star吧**
84 | 
85 | 
86 | 
87 | 


--------------------------------------------------------------------------------
/LeetCode题解精讲/LeetCode每日一题/746. 使用最小花费爬楼梯 20-12-21.md:
--------------------------------------------------------------------------------
 1 | # 746. 使用最小花费爬楼梯
 2 | ***
 3 | 来源： LeetCode 每日一题 20/12/21
 4 | 相关企业： 谷歌， 高盛
 5 | 相关标签： 数组， 动态规划
 6 | 难度： 简单
 7 | 相似题目： 爬楼梯
 8 | ***
 9 | ## 题干内容
10 | 数组的每个索引作为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost\[i\](索引从0开始)。
11 | 
12 | 每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。
13 | 
14 | 您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。
15 | 
16 | ![](https://github.com/jinghehehe/pictures/blob/main/746-1.png)
17 | 
18 | ![](https://github.com/jinghehehe/pictures/blob/main/746-2.png)
19 | 
20 | 注意：
21 | 
22 | cost 的长度将会在 [2, 1000]。
23 | 每一个 cost[i] 将会是一个Integer类型，范围为 [0, 999]。
24 | 
25 | 来源：力扣（LeetCode）
26 | 链接：https://leetcode-cn.com/problems/min-cost-climbing-stairs
27 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
28 | 
29 | ## 题眼题解
30 | ### 题眼:
31 | **本题涉及贪心及动态规划思想，动态规划需要设置dp，其含义可以有多种，本文采用其中一种含义，即dp[i]代表登上第i阶台阶所需体力花费。由于一次只能走一步或两步，即登上第i阶有两种情况：**
32 | 
33 | - 先踏上第i-2级台阶（最小总花费dp[i-2]），再直接迈两步踏上第i级台阶（花费cost[i]），最小总花费dp[i-2] + cost[i]；
34 | 
35 | - 先踏上第i-1级台阶（最小总花费dp[i-1]），再迈一步踏上第i级台阶（花费cost[i]），最小总花费dp[i-1] + cost[i]；
36 | 最后dp[i]为两种情况的最小值：
37 | ```language
38 | dp[i] = min(dp[i-2], dp[i-1]) + cost[i]
39 | //最后两位最小值即最小总花费。
40 | min(dp[len-1], dp[len-2]);
41 | ```
42 | ### 题解：
43 | #### c++版本一，时间复杂度 O(n), 空间复杂度 O(n)。
44 | ```language
45 | class Solution {
46 | public:
47 |     int minCostClimbingStairs(vector<int>& cost) {
48 |         int len = cost.size();
49 |         vector<int> dp(len);
50 | 	// 初始化.
51 |         dp[0] = cost[0];
52 |         dp[1] = cost[1];
53 |         for(int i=2; i<len; i++){        
54 |             dp[i] = min(dp[i-2], dp[i-1])+cost[i];
55 |         }
56 |         return min(dp[len-1], dp[len-2]);
57 |     }
58 | };
59 | ```
60 | #### c++版本二，时间复杂度 O(n), 空间复杂度 O(1)。
61 | ```language
62 | //由公式可知，当前状态仅跟其前两个状态相关,于是采用两个常量来替代。又由于 dp[0] = cost[0]，dp[1] = cost[1]，可直接采用cost数组来进行计算。
63 | class Solution {
64 | public:
65 |     int minCostClimbingStairs(vector<int>& cost) {
66 |         int len = cost.size();
67 |         for(int i=2; i<len; i++){
68 |             cost[i] = min(cost[i-1], cost[i-2]) + cost[i];
69 |         }
70 |         return min(cost[len-1], cost[len-2]);
71 |     }
72 | };
73 | ```
74 | #### python3版本一，时间复杂度 O(n),空间复杂度 O(1)
75 | ```language
76 | # 与c++版本二相同。
77 | class Solution:
78 |     def minCostClimbingStairs(self, cost: List[int]) -> int:
79 |         n = len(cost)
80 |         for i in range(2,n):
81 |             cost[i] = min(cost[i-1], cost[i-2]) + cost[i]
82 |         return min(cost[-1], cost[-2])
83 | ```
84 | ***
85 | 
86 | ### **喜欢Programming-Cat的话，请Star吧**
87 | 
88 | 
89 | 
90 | 


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/Docker常用指令知识点汇总.md:
--------------------------------------------------------------------------------
  1 | # Docker常用指令知识点汇总
  2 | **软件开发最大的麻烦事之一，就是环境配置。为了保证在不同机器上可以顺利运行应用，将软件放在虚拟机和容器是最常用的方法。** 
  3 | - 虚拟机虽然可以解决环境的问题，但其由于资源占用多，冗余步骤多，启动慢等特点不再适用。
  4 | - 由于虚拟机存在这些缺点，linux发展了另一种虚拟技术：容器。相应地，其具备启动快，资源占用少，体积小等特点。
  5 | - Docker属于linux容器的一种封装，提供简单易用的容器使用接口。它是目前最流行的 Linux 容器解决方案。
  6 | - Docker的用途
  7 | 1. 提供一次性的环境。比如，本地测试他人的软件、持续集成的时候提供单元测试和构建的环境。
  8 | 
  9 | 2. 提供弹性的云服务。因为 Docker 容器可以随开随关，很适合动态扩容和缩容。
 10 | 
 11 | 3. 组建微服务架构。通过多个容器，一台机器可以跑多个服务，因此在本机就可以模拟出微服务架构。
 12 | 
 13 | 
 14 | ### Docker常用指令汇总
 15 | - 从网络上拉取基础镜像
 16 | ```language
 17 | docker pull xxxxx    
 18 | ```
 19 | 
 20 | - 查看已有镜像
 21 | ```language
 22 | docker images   
 23 | ```
 24 | 
 25 | -创建容器并使用gpu
 26 | ```language
 27 | docker run -itd --gpus all --name CONTAINER_NAME IMAGE_NAME:TAG  /bin/bash
 28 | ```
 29 | 
 30 | - 启动容器
 31 | ```language
 32 | docker start CONTAINER_NAME
 33 | ```
 34 | 
 35 | -连接至容器
 36 | ```language
 37 | docker attach CONTAINER_NAME    
 38 | ```
 39 | 
 40 | ***
 41 | - 进入容器后安装所需要的环境pip，conda虚拟环境直接移植（未成功，理论可行）
 42 | - 将项目拷贝至容器内
 43 | ```language
 44 | docker cp PROJECT_NAME CONTAINER_NAME:/xxxx(容器内的路径)
 45 | ```
 46 | ***
 47 | - 将运行的容器保存为镜像
 48 | ```language
 49 | docker commit CONTAINER_NAME IMAGE_NAME   
 50 | ```
 51 | 
 52 | - 将镜像压缩为压缩包
 53 | ```language
 54 | docker save IMAGE_NAME -o ZIP_NAME.tar   
 55 | ```
 56 | 
 57 | - 镜像载入
 58 | ```language
 59 | docker load -i xxx.tar   
 60 | ```
 61 | 
 62 | ***
 63 | 其他指令：
 64 | - 删除镜像
 65 | ```language
 66 | docker rmi IMAGEID/REPOSITORY:TAG   
 67 | ```
 68 | 
 69 | - 删除容器
 70 | ```language
 71 | docker rm CONTAINER_NAME   
 72 | ```
 73 | 
 74 | - 查看已有容器（-a表示正在运行的）
 75 | ```language
 76 | docker ps (-a)   
 77 | ```
 78 | 
 79 | - 重命名镜像
 80 | ```language
 81 | docker tag IMAGE REPOSITOY:TAG   
 82 | ```
 83 | 
 84 | - 重命名容器名
 85 | ```language
 86 | docker old_CONTAINER_NAME new_CONTAINER_NAME   
 87 | ```
 88 | 
 89 | - 打包压缩镜像
 90 | ```language
 91 | docker save image_name -o xx.tar 
 92 | ```
 93 | 
 94 | - 容器保存镜像
 95 | ```language
 96 | docker commit container_name image_name 
 97 | ```
 98 | 
 99 | ***
100 | ### **喜欢Programming-Cat的话，请Star吧**
101 | 
102 | 
103 | 
104 | 


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/Git 指令操作摘录.md:
--------------------------------------------------------------------------------
 1 | # Git 指令摘录
 2 | ***
 3 | **Git是常用的版本控制工具，本文将摘录一些常用指令。**
 4 | ***
 5 | ### Git 版本初始化
 6 | ```language
 7 | 克隆远程库
 8 | git clone xxx.git localpath
 9 | //输入账号密码
10 | ```
11 | ```language
12 | //在本地创建目录初始化，git会对该目录下的文件进行版本控制。
13 | git init 
14 | //利用'git remote add'命令来增加一个远程服务器端
15 | git remote add origin xxx.git
16 | git remote add [name] [url]
17 | ```
18 | 
19 | ### Git 推送分支与下拉分支
20 | ```language
21 | //推送分支
22 | git push <远程主机名> <本地分支名>:<远程分支名>
23 | git push origin master
24 | //下拉分支
25 | git pull <远程主机> <远程分支>:<本地分支>
26 | git pull origin master:my_test
27 | ```
28 | 
29 | ### Git多人协作
30 | ```language
31 | commit-pull-push
32 | [好文分享](http://itrain.top/2020/06/git_tutorials_workflow/)
33 | ```
34 | 
35 | ### Git 开源代码其他用户示例
36 | ```language
37 | // fork开源项目
38 | git clone <远程Arepository> #克隆你fork出来的分支
39 |  
40 | git remote add <远程Brepository标签> git@github.com:XXXX/ceph.git #添加远程Brepository标签
41 |  
42 | git pull <远程B厂库标签> master:master  #从远程Brepository的master分支拉取最新objects合并到本地master分支
43 | 
44 | git checkout YYYY #切换到要修改的分支上
45 |  
46 | git branch develop; git checkout develop #在当前分支的基础上创建一个开发分支，并切换到该分支上，你将在该分支上coding
47 |  
48 | coding...... #在工作区coding
49 |  
50 | git add .#将修改保存到索引区
51 |  
52 | git commit -a #将修改提交到本地分区
53 |  
54 | git push origin my_test:my_test #将本地分支my_test提交到远程A repository的my_test分支上
55 | 
56 | //提交，等待审核。
57 | ```
58 | 
59 | ***
60 | ### **喜欢Programming-Cat的话，请Star吧**
61 | 


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/Linux shell常用知识点汇总.md:
--------------------------------------------------------------------------------
 1 | # Linux shell常用知识点汇总
 2 | ***
 3 | **脚本操作主要包括运行脚本，脚本权限设置，windows转linux脚本格式不兼容问题。**
 4 | ***
 5 | 
 6 | ### shell脚本从windows转到linux易出现权限和文件格式转换问题
 7 | 其中文件转换
 8 | ```language
 9 | vi xxx.sh
10 | set ff=unix
11 | :wq
12 | ```
13 | 
14 | ### shell脚本首行指令，使用指定解释器执行
15 | - 脚本使用/bin/bash来解释执行
16 | ```language
17 | #！/bin/bash 
18 | ```
19 | 
20 | ### shell脚本执行方式
21 | - 利用./来执行
22 | ```language
23 | ./script.sh  
24 | ```
25 | - 利用bash(sh)来执行脚本
26 | ```language
27 | sh script.sh 或 bash script.sh 
28 | ```
29 | - 利用source或. 来执行
30 | ```language
31 | source script.sh 
32 | . script.sh 
33 | ```
34 | - 上面第三种方式不启用新的shell，在当前shell中执行，设定的局部变量在执行完命令后仍然有效。bash 或 sh 或 shell script 执行时，另起一个子shell，其继承父shell的环境变量，其子shelll的变量执行完后不影响父shell。
35 | 
36 | 
37 | ### shell脚本中的 exec 命令
38 | - exec 是 bash 的内置命令，shell 的内件命令exec执行命令时，不启用新的shell进程。
39 | - exec是用被执行的命令行替换掉当前的shell进程，且exec命令后的其他命令将不再执行。例如在当前shell中执行 exec ls  表示执行ls这条命令来替换当前的shell ，即为执行完后会退出当前shell。为了避免这个结果的影响，一般将exec命令放到一个shell脚本中，用主脚本调用这个脚本，调用处可以用bash  xx.sh(xx.sh为存放exec命令的脚本)，这样会为xx.sh建立一个子shell去执行，当执行exec后该子脚本进程就被替换成相应的exec的命令。其中有一个例外：当exec命令对文件描述符操作的时候，就不会替换shell，而是操作完成后还会继续执行后面的命令！
40 | 
41 | [参考链接：](https://www.jianshu.com/p/ca012415cd5f)
42 | - exec与system的区别
43 | 1. exec是直接用新的进程去代替原来的程序运行，运行完毕之后不回到原先的程序中去。
44 | 2. system是调用shell执行你的命令，system=fork+exec+waitpid,执行完毕之后，回到原先的程序中去。继续执行下面的部分。
45 | 3. system 是在单独的进程中执行命令，完了还会回到你的程序中。而exec函数是直接在你的进程中执行新的程序，新的程序会把你的程序覆盖，除非调用出错，否则你再也回不到exec后面的代码，就是说你的程序就变成了exec调用的那个程序了。
46 | ***
47 | ### **喜欢Programming-Cat的话，请Star吧**
48 | 


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/Linux 权限知识点摘录.md:
--------------------------------------------------------------------------------
 1 | # Linux 权限知识点摘录
 2 | ***
 3 | Linux 下通常对文件操作需要有相应的权限，本文将重点介绍权限相关知识点。
 4 | ***
 5 | ## Linux下文件的权限类型一般包括读，写，执行。对应字母r，w，x。
 6 | - Linux下权限的粒度有 拥有者 、群组 、其它组 三种。每个文件都可以针对三个粒度，设置不同的rwx(读写执行)权限。通常情况下，一个文件只能归属于一个用户和组， 如果其它的用户想有这个文件的权限，则可以将该用户加入具备权限的群组，一个用户可以同时归属于多个组。
 7 | - Linux上通常使用chmod命令对文件的权限进行设置和更改。
 8 | 
 9 | - 常用chmod指令
10 | - 设置所有用户可读取文件 a.conf
11 | ```language
12 | chmod ugo+r a.conf 
13 | 或 
14 | chmod a+r  a.conf
15 | ```
16 | 
17 | - 数字权限使用格式
18 | - 我们规定 数字 4 、2 和 1表示读、写、执行权限（具体原因可见下节权限详解内容），即 r=4，w=2，x=1 。此时其他的权限组合也可以用其他的八进制数字表示出来，
19 | 
20 | 如：
21 | 
22 | rwx = 4 + 2 + 1 = 7
23 | 
24 | rw = 4 + 2 = 6
25 | 
26 | rx = 4 +1 = 5
27 | 
28 | 即
29 | 
30 | 若要同时设置 rwx (可读写运行） 权限则将该权限位 设置 为 4 + 2 + 1 = 7
31 | 
32 | 若要同时设置 rw- （可读写不可运行）权限则将该权限位 设置 为 4 + 2 = 6
33 | 
34 | 若要同时设置 r-x （可读可运行不可写）权限则将该权限位 设置 为 4 +1 = 5
35 | 
36 | 上面我们提到，每个文件都可以针对三个粒度，设置不同的rwx(读写执行)权限。即我们可以用用三个8进制数字分别表示 拥有者 、群组 、其它组( u、 g 、o)的权限详情，并用chmod直接加三个8进制数字的方式直接改变文件权限。语法格式为 ：
37 | ***
38 | - 设置所有人可以读写及执行
39 | ```language
40 | chmod 777 file  (等价于  chmod u=rwx,g=rwx,o=rwx file 或  chmod a=rwx file)
41 | ```
42 | - 设置拥有者可读写，其他人不可读写执行
43 | ```language
44 | chmod 600 file (等价于  chmod u=rw,g=---,o=--- file 或 chmod u=rw,go-rwx file )
45 | ```
46 | 
47 | [参考链接](https://blog.csdn.net/u013197629/article/details/73608613)
48 | 
49 | ***
50 | ### **喜欢Programming-Cat的话，请Star吧**
51 | 
52 | 
53 | 
54 | 
55 | 


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/Linux常用指令汇总贴.md:
--------------------------------------------------------------------------------
  1 | # Linux常用指令汇总贴
  2 | ***
  3 | **汇集Linux系统下所需常用命令，定期更新**
  4 | ***
  5 | ## 类别一
  6 | ### 查看系统文件夹占用大小
  7 | ```language
  8 | #当前目录下文件占用大小
  9 | du -h --max-depth=1 .
 10 | ```
 11 | 
 12 | ### 查看显存
 13 | ```language
 14 | #查看显存
 15 | nvidia-smi
 16 | ```
 17 | 
 18 | ### 查看cuda版本和cudnn版本
 19 | ```language
 20 | #查看cuda版本
 21 | 1. nvcc 安装
 22 | nvcc --version 
 23 | nvcc -V
 24 | 2. nvcc 未安装
 25 | cat /usr/local/cuda/version.txt
 26 | 
 27 | #查看cudnn版本
 28 | cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2
 29 | ```
 30 | 
 31 | ### 输出日志
 32 | ```language
 33 | # 输出日志
 34 | nohup python -u xxxx.py >xxxx.log 2>&1 &
 35 | ```
 36 | 
 37 | ### 环境依赖包生成与安装
 38 | ```language
 39 | #生成requirements.txt文件
 40 | pip freeze > requirements.txt
 41 | ```
 42 | ```language
 43 | #安装requirements.txt依赖
 44 | pip install -r requirements.txt
 45 | ```
 46 | 
 47 | ### python添加祖父目录文件，使用配置文件方式（sys.path.append有时会出问题）
 48 | ```language
 49 | #类似于windows的环境变量，可以保证import成功。
 50 | vi ~/.bashrc
 51 | export PYTHONPATH=~/xx/pysot-toolkit/pysot:$PYTHONPATH
 52 | source ~/.bashrc
 53 | ```
 54 | ### Anaconda创建虚拟环境，删除环境，激活环境以及退出环境
 55 | 通常为了保证不同程序之间的环境依赖不冲突，可以为每一个程序设置一个单独的虚拟环境
 56 | - 创建环境
 57 | ```language
 58 | conda create -n name python=3.6 
 59 | ```
 60 | - 删除环境（不太常用）
 61 | ```language
 62 | conda remove -n name --all
 63 | ```
 64 | - 激活环境
 65 | ```language
 66 | source activate name  (conda4的是：conda activate name)
 67 | ```
 68 | - 退出环境
 69 | ```language
 70 | source deactivate (conda4的是：conda deactivate)
 71 | ```
 72 | - 查看已有环境
 73 | ```language
 74 | conda info --env
 75 | ```
 76 | 
 77 | ### Python多版本切换
 78 | - 本人遇到的是操作失误导致anaconda环境中的python版本被切换，进而导致conda启动失败，报错：No module named 'conda'
 79 | - 解决方案：指定python版本路径
 80 | - 当前终端改变python版本（终端关闭，python版本不变）
 81 | 适用于调试，或者在一个用户下同时操作两个不同版本的python。
 82 | ```language
 83 | export PATH="/home/xx/2020/miniconda3/bin:$PATH"
 84 | ```
 85 | 代码中的路径是你想改变的python版本路径
 86 | - 永久改变python版本
 87 | 1. 修改用户配置环境变量
 88 | ```language
 89 | sudo vi ~/.bash_profile
 90 | export PATH="/home/xx/2020/miniconda3/bin:$PATH"
 91 | ```
 92 | 2. 使修改后的文件立即生效
 93 | ```language
 94 | source ~/.bash_profile
 95 | ```
 96 | 3. （可选）当shell类型为zshell时需要修改vi ~/.zshrc，不然重新开启命令终端时会无效
 97 | 在最后写入source ~/.bash_profile（未实验）
 98 | 
 99 | ***
100 | ### **喜欢Programming-Cat的话，请Star吧**


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/Linux软链接与硬链接知识点摘录.md:
--------------------------------------------------------------------------------
 1 | # Linux软链接/硬链接知识点摘录
 2 | ***
 3 | **通常SSD空间不够，需要将数据集放在私人文件夹下，需要软链接操作，本文对Linux软链接/硬链接知识点进行摘录讲解。**
 4 | ***
 5 | 
 6 | ### 硬连接指通过索引节点来进行连接
 7 | - 在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连接就是硬连接。硬连接的作用是允许一个文件拥有多个有效路径名，这样用户就可以建立硬连接到重要文件，以防止“误删”的功能。只有当最后一个连接被删除后，文件的数据块及目录的连接才会被释放。也就是说，文件真正删除的条件是与之相关的所有硬连接文件均被删除。如果我们删除硬链接文件的源文件，硬链接文件仍然存在，而且保留了愿有的内容。这时，系统就“忘记”了它曾经是硬链接文件。而把他当成一个普通文件。
 8 | - 其有两个条件：不允许给目录创建硬链接；只有在同一文件系统中的文件之间才能创建链接，而且只有超级用户才有建立硬链接权限。
 9 | 
10 | ### 软链接文件有类似于Windows的快捷方式。它实际上是一个特殊的文件。在符号连接中，文件实际上是一个文本文件，其中包含的有另一文件的位置信息。
11 | - 添加软链接
12 | ```language
13 | ln -s /sbin/ifconfig /usr/bin （a源文件， b目标文件）//绝对路径
14 | ```
15 | - 删除软链接
16 | ```language
17 | rm –rf test（软链接名称）
18 | ```
19 | - 修改软链接
20 | ```language
21 | ln –snf  [新的源文件或目录]  [目标文件或目录]
22 | ```
23 | 
24 | - 查看某文件的node值
25 | ```language
26 | ls -i a（查看a文件的node值）
27 | ```
28 | 样例查看：软链接指向的文件的名称，它是以文件名来指向的。硬链接则指向的是文件的inode值。
29 | [参考链接](http://ivo-wang.github.io/2018/09/21/%E4%B8%80%E6%96%87%E7%9C%8B%E6%87%82linux%E8%BD%AF%E9%93%BE%E6%8E%A5%E4%B8%8E%E7%A1%AC%E9%93%BE%E6%8E%A5/)
30 | 
31 | 
32 | - 软链接没有硬链接以上的两个限制，因而现在更为广泛使用，它具有更大的灵活性，甚至可以跨越不同机器、不同网络对文件进行链接。但是软链接的缺点在于：因为链接文件包含有原文件的路径信息，所以当原文件从一个目录下移到其他目录中，再访问链接文件，系统就找不到了，而硬链接就没有这个缺陷，你想怎么移就怎么移；还有它要系统分配额外的空间用于建立新的索引节点和保存原文件的路径。
33 | 
34 | ***
35 | ### **喜欢Programming-Cat的话，请Star吧**


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/linux关于bashrc与profile的区别.md:
--------------------------------------------------------------------------------
 1 | # profile和bashrc的区别
 2 | ***
 3 | **Linux下通常修改环境需要修改这两个配置文件中的一个，本文简单讲解下这两个配置文件的区别。**
 4 | ***
 5 | ## 概念
 6 | ![](https://github.com/jinghehehe/pictures/blob/main/profile%E5%92%8Cbashrc%E7%9A%84%E5%8C%BA%E5%88%AB.png)
 7 | - /etc/profile： 此文件为系统的每个用户设置环境信息,当用户第一次登录时,该文件被执行。是系统全局针对终端环境的设置，它是login时最先被系统加载的，是它调用了/etc/bashrc，以及/etc/profile.d目录下的*.sh文件，如果有一个软件包，系统上只安装一份，供所有开发者使用，建议在/etc/profile.d下创建一个新的xxx.sh，配置环境变量。
 8 | - ~/.bashrc:是用户相关的终端（shell）的环境设置，通常打开一个新终端时，默认会load里面的设置，在这里的设置不影响其它人。如果一个服务器多个开发者使用，大家都需要有自己的sdk安装和设置，那么最好就是设置它。
 9 | ## 总结
10 | **/etc/profile，/etc/bashrc 是系统全局环境变量设定**
11 | **~/.profile，~/.bashrc用户家目录下的私有环境变量设定**
12 | **当登入系统时候获得一个shell进程时，其读取环境设定档有三步:**
13 | 1. 首先读入的是全局环境变量设定档/etc/profile，然后根据其内容读取额外的设定的文档，如/etc/profile.d和/etc/inputrc
14 | 2. 然后根据不同使用者帐号，去其家目录读取~/.bash_profile，如果这读取不了就读取~/.bash_login，这个也读取不了才会读取~/.profile，这三个文档设定基本上是一样的, 读取有优先关系.
15 | 3. 然后在根据用户帐号读取~/.bashrc
16 | 4. ~/.profile与~/.bashrc,它们都具有个性化定制功能.
17 | 5. ~/.profile可以设定本用户专有的路径，环境变量，等，它只能登入的时候执行一次. ~/.bashrc也是某用户专有设定文档，可以设定路径，命令别名，每次shell script的执行都会使用它一次
18 | 
19 | [参考资料](https://blog.csdn.net/ZoeYen_/article/details/78560905)
20 | [参考资料](https://www.jianshu.com/p/9d95e5e736da)
21 | ***
22 | ### **喜欢Programming-Cat的话，请Star吧**
23 | 
24 | 


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/文件传输scp知识点总结.md:
--------------------------------------------------------------------------------
 1 | # 文件传输scp知识点总结
 2 | ***
 3 | **将数据上传到服务器，或者服务器之间传输数据时，常用指令汇总**
 4 | ***
 5 | ##
 6 | ### scp传输文件和目录指令（有一个更强大的传输工具rsync，可以查询使用）
 7 | - 从服务器下载整个目录（文件只需要不加参数-r）（-v 输出具体传输信息）
 8 | ```language
 9 | scp -r username@servername:remote_dir/ /tmp/local_dir 
10 | ```
11 | - 上传目录到服务器
12 | ```language
13 | scp  -r /tmp/local_dir username@servername:remote_dir
14 | ```
15 | - 以上指令限于linux->linux,windows可采用WinScP，termius等SFTP客户端进行拉取文件，大文件需要在服务器上安装工具来传送。
16 | - lrzsz（Linux服务器和window互传文件工具）
17 | 安装 sudo apt-get install lrzsz，传输文件大小限制为4G
18 | - 将选定的文件发送（send）到本地机器
19 | ```language
20 | sz file
21 | ```
22 | - 从本地选择文件上传到服务器(receive)
23 | ```language
24 | rz
25 | ```
26 | - 在两个远程主机之间复制文件
27 | ```language
28 | scp user1@remotehost1:/some/remote/dir/foobar.txt user2@remotehost2:/some/remote/dir/
29 | ```
30 | 
31 | ***
32 | ### **喜欢Programming-Cat的话，请Star吧**


--------------------------------------------------------------------------------
/Linux 指令与知识点汇总/输入输出重定向与管道知识点.md:
--------------------------------------------------------------------------------
 1 | # 输入输出重定向与管道知识点
 2 | ***
 3 | Linux中管道操作知识点摘录
 4 | ***
 5 | ## 输出日志
 6 | 
 7 | ```language
 8 | nohup python -u xxxx.py >xxxx.log 2>&1 &
 9 | ```
10 | 
11 | 
12 | ### Shell 输入/输出重定向
13 | - 输出重定向是大于号(>)，输入重定向是小于号(<)。默认键盘获取输入，屏幕输出。
14 | - 如果不希望文件内容被覆盖，可以使用 >> 追加到文件末尾
15 | |命令|说明|
16 | |-|-|
17 | |command > file	| 将输出重定向到 file。|
18 | |command < file	|将输入重定向到 file。|
19 | |command >> file |将输出以追加的方式重定向到 file。|
20 | |n > file	|将文件描述符为 n 的文件重定向到 file。|
21 | |n >> file	|将文件描述符为 n 的文件以追加的方式重定向到 file。|
22 | |n >& m	|将输出文件 m 和 n 合并。|
23 | |n <& m	|将输入文件 m 和 n 合并。|
24 | |<< tag	|将开始标记 tag 和结束标记 tag 之间的内容作为输入。|
25 | 
26 | #### 重定向深入讲解
27 | 一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：
28 | - 标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。
29 | - 标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。
30 | - 标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。
31 | 其他 3-9 都是空白描述符。默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。
32 | 
33 | - 如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：
34 | ```language
35 | $ command > /dev/null
36 | ```
37 | /dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到"禁止输出"的效果。如果希望屏蔽 stdout 和 stderr，可以这样写：
38 | ```language
39 | $ command > /dev/null 2>&1
40 | ```
41 | 
42 | ### 管道
43 | - 管道是一种通信机制，通常用于进程间的通信（也可通过socket进行网络通信），它表现出来的形式将前面每一个进程的输出（stdout）直接作为下一个进程的输入（stdin）。
44 | - 管道命令使用|作为界定符号，仅能处理standard output,对于standard error output会予以忽略。
45 | - less,more,head,tail...都是可以接受standard input的命令，所以他们是管道命令
46 | - ls,cp,mv并不会接受standard input的命令，所以他们就不是管道命令了。
47 | 
48 | 管道本身并不占用磁盘或者其他外部存储的空间。在Linux的实现上，它占用的是内存空间。所以，Linux上的管道就是一个操作方式为文件的内存缓冲区。
49 | 1. 匿名管道
50 | 最常见的就是 | ，系统调用是pipe()
51 | 2. 命名管道
52 | 使用mkfifo或mknod命令来创建一个命名管道，这跟创建一个文件没有什么区别
53 | ```language
54 | mkfifo pipe
55 | echo xxxxxxxxxxxxxx > pipe 
56 | cat pipe 
57 | ```
58 | ***
59 | ### **喜欢Programming-Cat的话，请Star吧**


--------------------------------------------------------------------------------
/Python 知识点摘要/图像像素遍历加速.md:
--------------------------------------------------------------------------------
 1 | # 图像像素遍历加速
 2 | ***
 3 | **处理图像像素时，采用for循环赋值较慢，常见的有np.where和直接赋值方法，现实验如下：**
 4 | ***
 5 | - 由实验结果可知，直接赋值更快。
 6 | ```language
 7 | import cv2
 8 | import numpy as np
 9 | import datetime
10 | img=cv2.imread("./xx.jpg",0) #第二个参数为0代表以灰度图的方式读入
11 | 
12 | height = len(img)
13 | width = len(img[0])
14 | img = np.array(img, dtype=np.uint8)
15 | n=16
16 | starttime = datetime.datetime.now()
17 | print(img)
18 | # 11m39s 每1000张
19 | # for k in range(0,height):
20 | #     for j in range(0,width):
21 | #         if img[k,j]==n:
22 | #             img[k,j] = 1
23 | #         else:
24 | #             img[k, j] = 0
25 | # 7s - 8s 每1000张
26 | # img[np.where(img != n)] = 0
27 | # img[np.where(img == n)] = 1
28 | # 0.99s - 1.99s 每1000张
29 | img[img != n] = 0
30 | img[img == n] = 1
31 | 
32 | print(img)
33 | endtime = datetime.datetime.now()
34 | 
35 | print ((endtime - starttime)*1000)
36 | ```
37 | ***
38 | ### **喜欢Programming-Cat的话，请Star吧**


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | README
2 | ***
3 | A Blog of  Programming.
4 | 个人博客，记录面试常用知识点，工具分享，项目经验等，欢迎Star！
5 | ***
6 | ![](https://github.com/jinghehehe/pictures/blob/main/cat-1.jpg)


--------------------------------------------------------------------------------
/Semantic Segmentation 论文精讲/README.md:
--------------------------------------------------------------------------------
1 | # 语义分割论文精讲
2 | ***
3 | 


--------------------------------------------------------------------------------
/vehicle tracking/vehicle-tracking论文总结.md:
--------------------------------------------------------------------------------
 1 | # vehicle-tracking论文总结
 2 | ***
 3 | SCI 三区 三作，提出一种多车辆跟踪算法，主要在目标检测，多目标跟踪及对漏检车辆采取单目标跟踪的方式这三个方面来平衡多车辆跟踪算法的准确率及实时性。
 4 | ***
 5 | ## 算法框架
 6 | ![](https://github.com/jinghehehe/pictures/blob/main/Figure_2_DPI500.jpg)
 7 | ### 目标检测改进点
 8 | 目标检测算法采用的是无锚框的基于关键点检测的CenterNet算法，同时针对多车辆跟踪首先采用优化后的Non-local Neural Networks，cv领域即自注意力操作，一方面提升检测指标，但是保证了参数量。
 9 | 
10 | ### 多目标跟踪改进点
11 | 多目标跟踪采用的是在线跟踪匈牙利算法DeepSort来实现。
12 | 这里介绍两个知识点：1 匈牙利算法可以告诉我们当前帧的某个目标，是否与前一帧的某个目标相同。
13 | 2 卡尔曼滤波可以基于目标前一时刻的位置，来预测当前时刻的位置，并且可以比传感器（在目标跟踪中即目标检测器，比如Yolo等）更准确的估计目标的位置。
14 | #### deepsort工作流程
15 | DeepSORT对每一帧的处理流程如下：
16 | 
17 | 检测器得到bbox → 生成detections → 卡尔曼滤波预测→ 使用匈牙利算法将预测后的tracks和当前帧中的detecions进行匹配（级联匹配和IOU匹配） → 卡尔曼滤波更新
18 | 
19 | Frame 0：检测器检测到了3个detections，当前没有任何tracks，将这3个detections初始化为tracks
20 | Frame 1：检测器又检测到了3个detections，对于Frame 0中的tracks，先进行预测得到新的tracks，然后使用匈牙利算法将新的tracks与detections进行匹配，得到(track, detection)匹配对，最后用每对中的detection更新对应的track。
21 | 
22 | [deepsort参考](https://zhuanlan.zhihu.com/p/202993073)
23 | [deepsort参考](https://zhuanlan.zhihu.com/p/90835266)
24 | 车辆关联时采用多维信息融合来进行匹配，分别是车辆外部特征信息，空间位置信息和运动轨迹信息，其中车速较快时权重更大为运动轨迹信息，车速较慢时权重更大为空间位置信息。
25 | 
26 | ### 针对漏检目标采取单目标跟踪方式的改进
27 | 单目标跟踪采用的是siamrpn，但为了保证整体架构的速度，此模块还对模块进行不对称卷积和深度可分离卷积来提升性能。
28 | 
29 | ***
30 | ### **喜欢Programming-Cat的话，请Star吧**
31 | 


--------------------------------------------------------------------------------
/后端技术栈必备/README.md:
--------------------------------------------------------------------------------
1 | # 后端技术栈必备
2 | ***
3 | 本章节将汇总后端技术学习所需知识点，从面试基本的计算机基础到后端技术的实际应用。
4 | ***
5 | ### 计算机基础
6 | **计算机基础主要包含计算机组成原理，计算机网络，操作系统，数据结构，(编译原理)。**
7 | 


--------------------------------------------------------------------------------
/后端技术栈必备/c++ 知识点汇总.md:
--------------------------------------------------------------------------------
  1 | # c++ 知识点汇总
  2 | ***
  3 | 
  4 | ***
  5 | ### c++四种cast转换
  6 | static_cast 转换
  7 | 用于非多态类型转换，安全性不如dynamic转换，父类转子类不安全。
  8 | 最常用转换，是c++传统强制转换替代品，但不会转换掉const、volitale、或者__unaligned属性。
  9 | 
 10 | dynamic_cast转换
 11 | 只能用于带有虚函数的类，T必须是类的指针，类的引用或者void*，通常应用于上行转换（子类-子类/基类）和下行转换（基类-子类）具备类型检查功能，更加安全。对不明确的指针的转换将失败（返回 nullptr），但不引发异常
 12 | 
 13 | reinterpret_cast重述转换
 14 | 为数据的二进制形式重新解释，但是不改变其值。
 15 | T必须是一个指针、引用、算术类型、函数指针或者成员指针。
 16 | 一般将整型转为一个指针或把指针转为整型，较危险，一般不用。
 17 | 
 18 | const_cast 转换
 19 | T需为指针和引用，通常用于去掉const，volatile 和 __unaligned 属性。
 20 | ***
 21 | ### volatile 关键字，多线程用同一个变量需要使用volatile，防止优化编译器将变量从内存装入cpu寄存器，从而引发错误使用。
 22 | ### const的指针与引用
 23 | 指针：指向常量的指针和自身是常量的指针
 24 | 引用：指向常量的引用
 25 | 修饰普通变量，使变量存储在静态区
 26 | 修饰普通函数，仅在定义该函数的作用范围
 27 | 修饰成员变量，使所有对象只保存一个该变量
 28 | 修饰成员函数，在static函数不能访问非静态成员。
 29 | ###this指针， 隐含于每一个非静态成员函数的特殊指针，指向函数对象。
 30 | ###inline内联函数
 31 | 在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数。
 32 | 类外定义，需要显式内联
 33 | class A {
 34 |     int doA();
 35 | }
 36 | inline int A::doA() { return 0; }   // 需要显式内联
 37 | 
 38 | 优点：提升运行速度，相比宏会做安全检查和类型转换，内联函数可以访问类的成员变量，在运行时可调试，宏不行。
 39 | 缺点：消耗更多内存空间，是否内联取决于编译器。
 40 | 通常十行以下，不包含循环和switch
 41 | ###结构体大小
 42 | 指针按照32/64区分，数组算一个，嵌套结构体按照嵌套结构体内部算大小
 43 | ###new对象与不new区别
 44 | [](https://blog.csdn.net/tham_/article/details/44906571)
 45 | ###
 46 | c++有三种继承public，protected，private，其中有两点没变：
 47 | 1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
 48 | 
 49 | 2.protected 成员可以被派生类访问。
 50 | ###封装继承多态
 51 | 
 52 | 面向对象的三个基本特征是：封装、继承、多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！
 53 | 
 54 | 继承分为实现继承，接口继承，可视继承。
 55 | 《Effective C++》条款三十四：区分接口继承和实现继承中介绍的比较啰嗦，概括地说需要理解三点：
 56 | （1）纯虚函数只提供接口继承，但可以被实现；
 57 | （2）虚函数既提供接口继承，也提供了一份默认实现，即也提供实现继承；
 58 | （3）普通函数既提供接口继承，也提供实现继承。
 59 | 
 60 | 重载只是一种语言特性，与多态无关，与面向对象也无关！
 61 | 多态是以封装和继承为基础的。
 62 | 
 63 | C++ 多态分类及实现：
 64 | 重载多态（Ad-hoc Polymorphism，编译期）：函数重载、运算符重载
 65 | 子类型多态（Subtype Polymorphism，运行期）：虚函数
 66 | 参数多态性（Parametric Polymorphism，编译期）：类模板、函数模板
 67 | 强制多态（Coercion Polymorphism，编译期/运行期）：基本类型转换、自定义类型转换
 68 | 
 69 | 普通函数（非类成员函数）不能是虚函数
 70 | 静态函数（static）不能是虚函数
 71 | 构造函数不能是虚函数（因为在调用构造函数时，虚表指针并没有在对象的内存空间中，必须要构造函数调用完成后才会形成虚表指针）
 72 | 内联函数不能是表现多态性时的虚函数，
 73 | 
 74 | 虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。
 75 | 
 76 | 纯虚函数是一种特殊的虚函数，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。
 77 | 
 78 | ###
 79 | 
 80 | 
 81 | xxx
 82 | 
 83 | ***
 84 | ### explicit（显式）关键字
 85 | explicit 修饰构造函数时，可以防止隐式转换和复制初始化
 86 | explicit 修饰转换函数时，可以防止隐式转换，但 按语境转换 除外
 87 | ###左右值引用
 88 | 在C++11中可以取地址的、有名字的就是左值，反之，不能取地址的、没有名字的就是右值。
 89 | 左值引用通常也不能绑定到右值，但常量左值引用是个“万能”的引用类型。它可以接受非常量左值、常量左值、右值对其进行初始化。不过常量左值所引用的右值在它的“余生”中只能是只读的。相对地，非常量左值只能接受非常量左值对其进行初始化。
 90 | int &a = 2;       # 左值引用绑定到右值，编译失败
 91 |  
 92 | int b = 2;        # 非常量左值
 93 | const int &c = b; # 常量左值引用绑定到非常量左值，编译通过
 94 | const int d = 2;  # 常量左值
 95 | const int &e = c; # 常量左值引用绑定到常量左值，编译通过
 96 | const int &b =2;  # 常量左值引用绑定到右值，编程通过
 97 | 链接[](https://blog.csdn.net/qianyayun19921028/article/details/80875002)
 98 | 
 99 | ###如何定义一个只能在堆上（栈上）生成对象的类？
100 | 
101 | 只能在堆上
102 | 方法：将析构函数设置为私有
103 | 
104 | 原因：C++ 是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。
105 | 
106 | 只能在栈上
107 | 方法：将 new 和 delete 重载为私有
108 | 
109 | 原因：在堆上生成对象，使用 new 关键词操作，其过程分为两阶段：第一阶段，使用 new 在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。将 new 操作设置为私有，那么第一阶段就无法完成，就不能够在堆上生成对象。
110 | 
111 | ###
112 | 指针和引用区别：一个是取地址，一个是变量别名
113 | 编译过程：预处理，编译，汇编，链接
114 | define，const，static区别：define没有数据类型，可定义小函数。static作用在文件范围内。
115 | 内存模型问题：1 内存可见性，用缓存一致性协议解决
116 | 2 乱序 内存屏障防止重排
117 | 堆：new
118 | 栈:编译器自动处理，局部变量，函数参数
119 | 自由存储区：malloc
120 | 全局/静态存储区：
121 | 常量存储区


--------------------------------------------------------------------------------
/后端技术栈必备/事务四大特性.md:
--------------------------------------------------------------------------------
 1 | 事务是并发控制的基本单位。
 2 | 原子性，隔离性，持久性，一致性
 3 | 四种隔离级别
 4 | 读未提交，其隔离级别最低，允许脏读。换句话说就是，如果一个事务正在处理某一数据，并对其进行了更新，但是同时没有提交事务，允许另一个事务也可以访问
 5 | 读已提交，和读未提交的区别就是。读未提交可以读取到别人没有提交的数据，但是读已提交只能读取到别人提交后的值，事务进行的中间值不会读取到
 6 | 可重复读，简单来说就是事务处理过程中多次读取同一个数据的时候，这个值不会发生改变，其值都和第一次查询到的数据是一致的
 7 | 可串行化，是最严格的隔离级别，他要求所有的事务都被串行执行，既事务只能一个接一个的进行处理，不能并发执行
 8 | 
 9 | 并发操作带来的数据不一致性包括
10 | 1丢失修改 t1，t2同时修改，其中一个被修改了
11 | 2不可重复读 
12 | 3读脏数据 t1撤回，t2读脏数据
13 | 
14 | 解决方法
15 | 多版本并发控制 时间戳，解决读写问题
16 | 写写，锁，乐观
17 | 
18 | 


--------------------------------------------------------------------------------
/后端技术栈必备/单例模式饿汉版-懒汉版.html:
--------------------------------------------------------------------------------
 1 | <attachment contenteditable="false" data-atts="%5B%5D" data-aid=".atts-681daf6e-8a87-4c92-8c31-146f53bc9d83"></attachment><pre class="ql-syntax" spellcheck="false">// version 1.0
 2 | class Singleton
 3 | {
 4 | private:
 5 | 	static Singleton* instance;
 6 | private:
 7 | 	Singleton() {};
 8 | 	~Singleton() {};
 9 | 	Singleton(const Singleton&amp;);
10 | 	Singleton&amp; operator=(const Singleton&amp;);
11 | public:
12 | 	static Singleton* getInstance() 
13 |         {
14 | 		if(instance == NULL) {
15 | 		Lock lock;  // 基于作用域的加锁，超出作用域，自动调用析构函数解锁
16 |         if(instance == NULL) {
17 |         	instance = new Singleton();
18 |         }
19 | 	}
20 | 
21 | 		return instance;
22 | 	}
23 | };
24 | 
25 | // init static member
26 | Singleton* Singleton::instance = NULL;
27 | </pre><p><br></p><p>饿汉</p><pre class="ql-syntax" spellcheck="false">// version 1.3
28 | class Singleton
29 | {
30 | private:
31 | 	static Singleton instance;
32 | private:
33 | 	Singleton();
34 | 	~Singleton();
35 | 	Singleton(const Singleton&amp;);
36 | 	Singleton&amp; operator=(const Singleton&amp;);
37 | public:
38 | 	static Singleton&amp; getInstance() {
39 | 		return instance;
40 | 	}
41 | }
42 | 
43 | // initialize defaultly
44 | Singleton Singleton::instance;
45 | </pre><p><br></p><p>简单工厂模式，工厂方法模式，抽象工厂模式</p><p>https://www.jianshu.com/p/807bc228dbc2 六大原则</p><p><br></p>


--------------------------------------------------------------------------------
/后端技术栈必备/多目标跟踪网络.md:
--------------------------------------------------------------------------------
1 | # 多目标跟踪网络
2 | 
3 | ### 


--------------------------------------------------------------------------------
/后端技术栈必备/数据库相关知识.md:
--------------------------------------------------------------------------------
 1 | mysql 
 2 | crud： 索引部分操作无效
 3 | 三范式：1 有主键，且字段原子不可分
 4 | 	2 非主键字段完全依赖主键
 5 | 	3 非主键和主键之间不出现传递依赖
 6 | 存储引擎：innodb，MyISAM，tukodb
 7 | 不存在就更新
 8 | insert into t_emp_ip(id, empno, ip)
 9 | values (5, 8004, '192.168.99.44'),
10 |        (6, 8005, '192.168.99.45'),
11 |        (7, 8006, '192.168.99.46'),
12 |        (8, 8001, '192.168.99.47')
13 | on duplicate key update ip=values(ip);
14 | 
15 | 5种日志：错误日志、查询日志、慢查询日志、事务日志、二进制日志几大类，其中undo和redo和事务相关，undo拷贝数据，redo记录修改并同步数据
16 | 
17 | binlog：记录sql语句。
18 | 使用场景 主从复制， 数据恢复（mysqlbinlog）
19 | 格式：statement row，mixed
20 | 
21 | 主从复制作用
22 | 后备数据库，业务拓展io性能，读写分离。
23 | 
24 | 事务acid：原子，一致，隔离，持久
25 | 读未提交，读已提交，可重复读，序列化
26 | 脏读，不可重复读，幻读。
27 | 
28 | 乐观锁：乐观锁在操作数据时非常乐观，认为别人不会同时修改数据。因此乐观锁不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据：如果别人修改了数据则放弃操作，否则执行操作。
29 | 悲观锁：悲观锁在操作数据时比较悲观，认为别人会同时修改数据。因此操作数据时直接把数据锁住，直到操作完成后才会释放锁；上锁期间其他人不能修改数据。
30 | 
31 | innodb中mvcc属于乐观锁。
32 | 
33 | 数据库中间件mycat，可以实现全局连续主键值。
34 | 
35 | 单节点采用存储过程，函数，触发器，集群无法实现。
36 | 
37 | 数据库集群能支持 更大规模的并发访问，并且 存放更多的数据
38 | 高并发解决redis 每秒读写10w，为了避免超售，引入事务机制（避免其他客户端插队）
39 | redis数据类型：字符串，哈希，链表，集合，有序集合
40 | redis持久化：快照rdb，追加式文件aof
41 | redis架构模式：单机，主从，哨兵，集群
42 | 
43 | pxc集群分片和replication集群分片
44 | 
45 | 


--------------------------------------------------------------------------------
/后端技术栈必备/数据结构知识点汇总.md:
--------------------------------------------------------------------------------
 1 | # 数据结构知识点汇总
 2 | ***
 3 | 
 4 | ***
 5 | ###哈希构造方法和冲突处理方法
 6 | 构造方法：直接定址法，除留余数法，数字分析法，平方取中法，折叠法
 7 | 冲突处理：链地址法，开放定址法：线性探测法，二次探测法，随机探测法
 8 | ### 递归与分治与迭代
 9 | 递归算法：直接或间接地调用自身的算法。
10 | 分治法：将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同，然后递归地解这些子问题，最后将各个子问题的解合并得到原问题的解。
11 | 迭代:利用变量的原值推算出变量的一个新值。
12 | 
13 | ###平衡二叉树讲解
14 | [](https://www.cnblogs.com/suimeng/p/4560056.html)
15 | 
16 | ###红黑树特征
17 | 1节点红或黑
18 | 2根黑色
19 | 3叶子是黑色
20 | 4插入为红色节点，红色节点必有两个黑色子节点，不会有两个连续红色节点
21 | 5从任一节点到叶子路径包含相同数目黑色节点
22 | 
23 | 调整：变色，左旋，右旋
24 | 插入：三种情况
25 | 1 新节点没有父节点
26 | 添加为根节点，涂成黑色就可以了
27 | 2 新节点的父节点是黑色
28 | 同不需调整
29 | 3 新节点的父节点是红色
30 | [红黑树相关](https://www.zhihu.com/question/312327402)
31 | 红黑树相比于BST和AVL树有什么优点？
32 | 红黑树是牺牲了严格的高度平衡的优越条件为代价，它只要求部分地达到平衡要求，降低了对旋转的要求，从而提高了性能。对于他的设计，任何不平衡可以在三步之内解决。
33 | 相比于BST，因为红黑树可以能确保树的最长路径不大于两倍的最短路径的长度，所以可以看出它的查找效果是有最低保证的。在最坏的情况下也可以保证O(logN)的，这是要好于二叉查找树的。
34 | 红黑树的算法时间复杂度和AVL相同，但统计性能比AVL树更高
35 | 
36 | [B，B+树](https://blog.csdn.net/xlgen157387/article/details/79450295)


--------------------------------------------------------------------------------
/后端技术栈必备/计算机组成原理.md:
--------------------------------------------------------------------------------
 1 | # 计算机组成原理
 2 | ***
 3 | **相关知识点汇总**
 4 | ***
 5 | ### 数据在计算机中的表示和运算
 6 | 计算机本质上是处理信息的工具，要了解计算机的工作原理，首先要明白计算机中信息的表示和存储方法。计算机中的信息类型很多，总体上可分为两大类：一类是计算机处理的对象，即数据信息；一类是用于控制计算机工作的信息，即指令。
 7 | 数据信息可以分为数值型数据和非数值型数据两类。数值型数据表示具体的数量，有正负大小之分。非数值数据主要包括字符、声音、图像等，这类数据在计算机中存储和处理前需要以特定的编码方式转换为二进制表示形式。在计算机中，我们使用二进制方式实现了不同类型的数值数据的存储和处理。使用二进制来编码和处理计算机中不同类型的数据。
 8 | 数值数据包含定点型运算和浮点型运算：
 9 | 1. 定点数指的是小数点固定在特定的位置，分为无符号数和有符号数的表示：
10 | - 无符号数：用全部二进制代码表示数字，没有符号位，8位二进制无符号数范围（00000000~11111111）0~2的8次方-1（0-255） 共256个数
11 | - 有符号数：第一位为符号位，0为正数，1为负数。纯小数的范围是0<=|x|<=1-2的负n次方，纯整数的表示范围是-（2的n次方-1）<x<2的n次方-1。
12 | - 带符号数采用原码、反码、补码和移码等编码方式，这种编码方式称为码制。正数的原码、反码、补码是相同的，负数则不同。
13 | 	1. 原码
14 | 将最高位用作符号位（0表示正数，1表示负数），其余各位代表数值本身的绝对值的表示形式。
15 | 例如：
16 | +1的原码0000 0001，-1的原码是1000 0001
17 | 	2. 反码
18 | 负数的反码则是将除了符号位的其他位全部取反。
19 | 	3. 补码
20 | 负数的补码是在反码加1得到，补码指的是加1的意思。
21 | 	- 补码左移：符号位不变，数值部分左移，最低位移除的空位填0
22 | 	- 补码右移：符号位不变，数值部分右移，最高位移出的位填符号位
23 | 	4. 移码
24 | 移码是对补码符号位取反得到的一种编码，它只用于表示浮点数的解码，所以只用于正数。
25 | 例如，-1的补码是0111 1111
26 | 2. 浮点数运算
27 | 数学中表示一个很大的数，常用科学技术法：
28 | N=M*R^e
29 | 其中M称为尾数，e是指数，R为基数
30 | 
31 | - 浮点数就是用这种方法来表示大范围的数。浮点数表示的精度取决于尾数的宽度，范围取决于基数的大小和指数的宽度。
32 | 浮点数的运算主要有三个步骤：对阶、尾数计数、结果格式化。
33 | ***
34 | ### 存储系统
35 | 数据和程序都需要存储，计算机的存储层次包括内存，外存，高速缓存、虚拟存储技术等。
36 | 
37 | 


--------------------------------------------------------------------------------
/后端技术栈必备/语义分割网络.md:
--------------------------------------------------------------------------------
 1 | # 语义分割网络
 2 | ***
 3 | ## 图像的语义分割是将输入图像中的每个像素分配一个语义类别，以得到像素化的密集分类。
 4 | ***
 5 | fcn 开山之作，全卷积神经网络，解码器反卷积
 6 | segnet 15年，反池化
 7 | unet concatenate到对应上采样层
 8 | 
 9 | hrnetv2，在一的基础上，
10 | 通过高分辨率卷积保持高分辨率表示，并通过并行低分辨率卷积加强表示。
11 | 天空项目：
12 | 天空项目是导师与xx公司商谈与小米魔法天空对标的相关项目，即能够对所拍照片进行天空部分进行变换，同时针对相应变换，进行照片风格相应的转换。
13 | 我们当时的目标是实现与小米魔法天空相同的算法设计。
14 | 我担任前期负责人，前期首先调研小米魔法天空的实现方式，开始我们以为魔法天空用到风格迁移，但后发现通过风格迁移转换后的图像通常会失真，后理解了实现方式应该是采用语义分割+采用图像叠加实现滤镜效果。
15 | 在实现时，我们采用了hrnetv2这个语义分割网络中较为先进的网络当做主干网络，选用带天空的图像作为数据集，开始训练，结果得到可以区分天空和非天空的图像模型，然后将提前选好的替换天空替换到天空部分，但是这样处理后通常天空与图像整体风格并不一致，于是需要对图像进行调色，加一层滤镜。从而实现基本的魔法天空。
16 | 当时有个难点在于语义分割的精度，会影响整体的变换效果，由于小米的数据集据说使用了10w+数据，我们人工标注数据最终是1w量级，所以在两个方面进行了改进，一个是数据增强，采用旋转，加噪声，改变亮度对比度来对数据进行增强。另一个是使用20年提出的resnest中的主要网络替换hrnet中resnet主要网络bottleneck来提升语义分割精度，最终指标提升了一个点。
17 | 同时借助语义分割相关知识，参加了天池全国数字创新大赛-智能算法赛，该比赛旨在解决遥感图像多类型语义分割问题，期间主要采用数据增强，余弦退火，快照集成等技巧来提升指标。
18 | 
19 | 
20 | 


--------------------------------------------------------------------------------
/后端技术栈必备/面试贴汇总.md:
--------------------------------------------------------------------------------
 1 | # 面试贴汇总
 2 | ***
 3 | 
 4 | ***
 5 | 常见问题：
 6 | 自我介绍一分钟
 7 | 你的一个缺点
 8 | 为什么选你，不好需要举例展示自己好学一面
 9 | 
10 | 项目问题：
11 | 场景化提问：
12 | 细节，团队多少人，担任角色，困难，如何解决，学到什么，从来一遍如何改善
13 | 
14 | 三个项目总结
15 | 
16 | 面试面经总结
17 | 
18 | 岗位相关面试总结
19 | 
20 | 数据库开始
21 | 
22 | 哈希冲突
23 | 
24 | 


--------------------------------------------------------------------------------
/常用工具记录/GitNote 笔记博客工具.md:
--------------------------------------------------------------------------------
 1 | # GitNote 笔记博客工具
 2 | ***
 3 | 工欲善其事，必先利其器。本文将介绍一个直连github的笔记工具，不需要本地依赖git环境，方便进行对知识点进行摘录。
 4 | ***
 5 | ## GitNote 介绍
 6 | GitNote 是一款基于 Git 的云笔记工具，支持 Windows、macOS、Linux，使用 Git 仓库作为数据保存，如 GitHub、GitLab 等，内置 git 支持，依托 Git 仓库的特性，拥有历史版本、私密笔记、无限空间等特点。
 7 | [GitNote官网](https://gitnoteapp.com/)
 8 | ![](https://github.com/jinghehehe/pictures/blob/main/gitnote.png)
 9 | 下载好后，只需要复制github仓库连接xxx.git映射到本地目录即可，用户名，密码为github账户名，密码。
10 | 在GitNote可以使用md方式记录笔记，按钮式简化了markdown写法，易上手，同步更新。
11 | ### GitNote排坑
12 | 由于BLM运动，github master分支改为main分支，而GitNote配置需要master分支，因此需建立master分支即可实现克隆。
13 | 
14 | ***
15 | ### **喜欢Programming-Cat的话，请Star吧**
16 | 
17 | 


--------------------------------------------------------------------------------
/常用工具记录/Readme.md:
--------------------------------------------------------------------------------
1 | 常用工具记录
2 | ***
3 | - [GitNote 笔记博客工具](https://github.com/jinghehehe/-Programming-Cat/blob/main/%E5%B8%B8%E7%94%A8%E5%B7%A5%E5%85%B7%E8%AE%B0%E5%BD%95/GitNote%20%E7%AC%94%E8%AE%B0%E5%8D%9A%E5%AE%A2%E5%B7%A5%E5%85%B7.md)
4 | 
5 | - [Termius 服务器远程连接工具](https://github.com/jinghehehe/-Programming-Cat/blob/main/%E5%B8%B8%E7%94%A8%E5%B7%A5%E5%85%B7%E8%AE%B0%E5%BD%95/Termius%20%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E8%BF%9E%E6%8E%A5%E5%B7%A5%E5%85%B7.md)
6 | 
7 | - [Tmux 服务器后端运行神器](https://github.com/jinghehehe/-Programming-Cat/blob/main/%E5%B8%B8%E7%94%A8%E5%B7%A5%E5%85%B7%E8%AE%B0%E5%BD%95/Tmux%20%E6%9C%8D%E5%8A%A1%E5%99%A8%E5%90%8E%E7%AB%AF%E8%BF%90%E8%A1%8C%E7%A5%9E%E5%99%A8.md)
8 | 
9 | 


--------------------------------------------------------------------------------
/常用工具记录/Termius 服务器远程连接工具.md:
--------------------------------------------------------------------------------
 1 | # Termius 服务器远程连接工具
 2 | ***
 3 | 工欲善其事，必先利其器。本文将介绍一个服务器远程连接工具，图像化界面较为舒服，学生可以申请github pro包来免费使用。
 4 | ***
 5 | ## Termius 介绍
 6 | Termius是一款支持WINDOWS,MAC,和IOS平台的远程SSH工具，功能强大，且和teamviewer一样注册一个账号就可以在多个平台共享主机列表，一次配置后就可以跨平台使用等特点。
 7 | [Termius官网](https://termius.com/)
 8 | ![](https://github.com/jinghehehe/pictures/blob/main/termius.png)
 9 | termius操作方式与xshell，putty，MobaXterm等ssh工具相同，主要优点在于界面清爽，颜值党比较喜欢，同时多平台共享账号，使用起来较为方便。
10 | 
11 | ### GitNote缺点
12 | 目前使用下来有2个缺点：
13 | 1. 无法分屏
14 | 2. 传输大文件时较慢，可以使用MobaXterm等工具传输文件，可以图形化操作，不需要lrzsz方式命令行传输。
15 | 
16 | ***
17 | ### **喜欢Programming-Cat的话，请Star吧**
18 | 
19 | 


--------------------------------------------------------------------------------
/常用工具记录/Tmux 服务器后端运行神器.md:
--------------------------------------------------------------------------------
 1 | # Tmux 服务器后端运行神器
 2 | ***
 3 | **在终端运行程序时，终端断掉，程序也会自动断掉，nohup有时也存在问题。**
 4 | ***
 5 | ### tmux安装
 6 | ```language
 7 | # Ubuntu 或 Debian
 8 | sudo apt-get install tmux
 9 | 
10 | # CentOS 或 Fedora
11 | sudo yum install tmux
12 | ```
13 | ### tmux新建窗口
14 | ```language
15 | # tmux新建窗口
16 | tmux new -s <session-name>
17 | ```
18 | ### tmux连接和分离窗口
19 | ```language
20 | # tmux连接窗口
21 | tmux attach -t <session-name>
22 | # tmux分离窗口
23 | tmux detach
24 | ```
25 | ### tmux 显示会话
26 | ```language
27 | tmux ls
28 | ```
29 | ### tmux 杀死会话
30 | ```language
31 | tmux kill-session -t <session-name>
32 | ```
33 | 
34 | ***
35 | ### **喜欢Programming-Cat的话，请Star吧**
36 | 
37 | 
38 | 


--------------------------------------------------------------------------------
/常用工具记录/视频转rtsp流.md:
--------------------------------------------------------------------------------
 1 | # 视频转rtsp流
 2 | ***
 3 | **视觉领域有时需要测试rtsp流，本文介绍视频转rtsp流的方法。**
 4 | ***
 5 | 1. 从http://ffbinaries.com/downloads下载ffserver，网站里有多个版本及多个系统平台，本文用3.4版本ffserver。
 6 | 2. 解压到自定义目录
 7 | ```language
 8 | ~/rtsp$sudo unzip ffserver-3.4-linux-64.zip
 9 | 
10 | ~/rtsp$ ls
11 | 
12 | ffserver  ffserver-3.4-linux-64-1.zip   __MACOSX
13 | ```
14 | 
15 | 3. 在ffserver-3.4-linux-64.zip 解压的同级目录，新建ffserver.cfg文件，并写入如下内容：
16 | ```language
17 | RTSPPort 5454
18 | BindAddress 0.0.0.0
19 | RTSPBindAddress 0.0.0.0
20 | MaxHTTPConnections 2000
21 | MaxClients 1000
22 | MaxBandwidth 30000
23 | CustomLog -
24 | NoDaemon
25 | #NoDefaults
26 |  
27 | <Stream test.mp4>
28 | File "/home/sdb/work/stream/test.mp4"
29 | Format rtp
30 | </Stream>
31 | ```
32 | 
33 | 4. 命令行运行
34 | ```language
35 | ./ffserver -f server.cfg
36 | ```
37 | 5. vlc播放
38 | ```language
39 | rtsp://ip/test.mp4
40 | ```
41 | 
42 | ***
43 | ### **喜欢Programming-Cat的话，请Star吧**
44 | 
45 | 
46 | 
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/机器学习知识点摘要/README.md:
--------------------------------------------------------------------------------
1 | # 机器学习知识点摘要
2 | ***


--------------------------------------------------------------------------------