Markdown 语法
Markdown 基本语法一
1.标题
1 | # 一级标题 |
加载中...
Markdown 语法
数据库加载中
评论
1 | # 一级标题 |
Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.
+ })(window)Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.
1 | $ hexo new "My New Post" |
More info: Writing
1 | $ hexo server |
1 | $ hexo deploy |
More info: Deployment
-我想计算一个线性方程组方程组的解
+ })(window)我想计算一个线性方程组方程组的解
1 | from pickletools import optimize |
关于scipy.optimize.linprog
详细信息
给定一个整数数组 $nums$ 和一个整数目标值 $target$，请你在该数组中找出 和为目标值 $target$ 的那 两个 整数，并返回它们的数组下标。
+ })(window)给定一个整数数组 $nums$ 和一个整数目标值 $target$，请你在该数组中找出 和为目标值 $target$ 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
@@ -161,7 +161,7 @@ 定义两个指针i,j,
遍历数组求和，当其nums[i]+num[j]=target时，记录两个下标的值[i,j]，最后返回这个数组。
1 | class Solution { |
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
+ })(window)给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
@@ -179,7 +179,7 @@1 | /* |
给定一个字符串 $s$ ，请你找出其中不含有重复字符的 最长子串 的长度。
+ })(window)PV操作就是荷兰语Passeren（通过），Vrijgeven（释放）的简称。对应的就是wait等待，signal释放操作。
+ })(window)PV操作就是荷兰语Passeren（通过），Vrijgeven（释放）的简称。对应的就是wait等待，signal释放操作。
P操作就是，将进程从运行态转化为阻塞态，直到它被另一个进程唤醒
V操作就是，将一个处于阻塞态的进程唤醒。
1 | s=s-1 |
抢占式优先级调度算法可以使当前正在执行的进程被更高优先级的进程所打断，并立即切换到新的进程。这种调度算法通常会导致频繁的上下文切换，但是可以保证高优先级进程的响应时间，从而提高系统的实时性能。
而非抢占式优先级调度算法则不允许其他进程打断当前进程的执行，只有在当前进程自愿放弃CPU控制权时才会进行进程切换。这种调度算法相对稳定，但是可能会导致低优先级进程长时间等待，影响系统的响应速度和实时性能。
即抢占式优先级调度算法进行V操作时，唤醒的进程为优先级最高的进程，而非抢占式优先级调度算法的V操作则无作为，继续执行当前进程，完成后再执行其他进程。
-1 | ## Markdown 增加文献引用 |
1 | ## Markdown 增加文献引用 |
这边文章是介绍如何在 Markdown 中增加文献引用。1
1 | git config --global 协议.proxy 协议://ip地址:端口号 |
1 | git config --global 协议.proxy 协议://ip地址:端口号 |
1 | 只对github.com |
1 | git config --global --get http.proxy |
安装C/C++扩展
安装完成之后，直接在VsCode中按 ctrl+shift+p快捷键,选择C/C++编辑UI。
1 |
|
我们组完成的项目是远程温度检测系统设计。
+ })(window)我们组完成的项目是远程温度检测系统设计。
课设要做温度监视并且通过串口发送到PC和阿里云。主要功能是通过ds18b20传感器获取温度信息传给单片机，然后单片机通过串口给pc发送温度信息，同时给esp8266发送指令将温度信息上传到阿里云。
材料:
An unforgettable journey！！！
-1 | static void qsort(int[] a, int l,int r){ |
1 | static void qsort(int[] a, int l,int r){ |
它的思想很简单，但是它的边界处理真的很傻x，稍不留神就会无限递归或无线循环。
我曾如是写道:
1 | static void qsort(int[] arr, int begin, int end){ |
坑是真的多
1 | class Solution { |
当我用js的axios库向指定api发送请求获取数据时常常会遇到跨域请求问题
+ })(window)当我用js的axios库向指定api发送请求获取数据时常常会遇到跨域请求问题
1 | Access to XMLHttpRequest at 'https://www.**' from origin 'http://127.0.0.1:5501' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. |
我尝试使用springboot代理此次请求。
编写一个控制器
1 |
|
我用的是谷歌的 Chrome 浏览器，默认的 Google 搜索引擎，用的是 Google.com 的网址，可不知咋的，这两天所有的搜索结果都转到了 Google.com.hk 上去了。
+ })(window)我用的是谷歌的 Chrome 浏览器，默认的 Google 搜索引擎，用的是 Google.com 的网址，可不知咋的，这两天所有的搜索结果都转到了 Google.com.hk 上去了。
在 Google 首页及搜索设置中找了一圈，也没能把它改回为Google.com 的搜索结果。只好上网寻找解决办法，发现其实相当简单，不用其它类似文章写的那么复杂。
原理：只要告诉 Google.com 不要进行区域重定向（No Country Redirection，简称NCR）。
具体做法：在网址栏打入：1
http://www.google.com/ncr
然后回车即可。
还没有改过来？哦，你忘了最重要的一步，即在完成上步操作后，立即重启 Google Chrome 浏览器。
-四级没过,内心受到沉重打击，且临近毕业，碌碌无为，一事无成。因此发奋图强，以一雪前耻，以求无怨无悔。
+ })(window)四级没过,内心受到沉重打击，且临近毕业，碌碌无为，一事无成。因此发奋图强，以一雪前耻，以求无怨无悔。
背单词
编译原理
给你一个数组 $nums$ 和一个值 $val$，你需要 原地 移除所有数值等于 $val$ 的元素，并返回移除后数组的新长度。
+ })(window)给你一个数组 $nums$ 和一个值 $val$，你需要 原地 移除所有数值等于 $val$ 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 $O(1)$ 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
说明:
@@ -162,7 +162,7 @@1 | class Solution { |
这种类似的思路在283中也运用了。
-给定一个数组 $nums$，编写一个函数将所有 $0$ 移动到数组的末尾，同时保持非零元素的相对顺序。
+ })(window)给定一个数组 $nums$，编写一个函数将所有 $0$ 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
1 | 输入: nums = [0,1,0,3,12] |
第二次迭代
1 | class Solution { |
双指针:
-给定一个二进制数组 $nums$ ， 计算其中最大连续 $1$ 的个数。
示例 1：
1 | 输入：nums = [1,1,0,1,1,1] |
这里我遇到了一个问题，就是内循环的条件i<nums.length&&nums[i++]==1当我交换位置时，就会报数组越界的错误，我知道原因是因为i++的自增导致后面i<num.length的判断失误，但是当我改成nums[i++]==1&&i-1<nums.length还是会错。。。
直接写一个debug程序追踪一下这些变量打断点逐步观察这些变量，发现nums[i++]会越界。
结论就是条件表达式是自左而右依次进行的，第一个条件表达式的相关变量会影响后续表达式的值，对于&&，第一个表达式为false则后续条件表达式不会执行，这也正是题解所写那样写不会越界的原因。
给你一个链表的头节点 $head$ 和一个整数 $val$ ，请你删除链表中所有满足 $Node.val == val$ 的节点，并返回 新的头节点 。
+ })(window)给你一个链表的头节点 $head$ 和一个整数 $val$ ，请你删除链表中所有满足 $Node.val == val$ 的节点，并返回 新的头节点 。
示例 1：
1
2输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
@@ -164,7 +164,7 @@使用c++1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30/**
* 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:
ListNode* removeElements(ListNode* head, int val) {
ListNode* dummy = new ListNode();
dummy->next=head;
ListNode* cur = head;
ListNode* t = dummy;
while(cur!=NULL){
if(cur->val==val){
t->next=cur->next;
}
else{
t->next=cur;
t=t->next;
}
cur=cur->next;
}
return dummy->next;
}
};
这种方法使用了三个指针，dummy负责建立一个空头节点，cur负责遍历原链表，t负责随着cur的遍历而移动以建立新链表。这种方法是自然而然想到的。
还有一种方法，使用两个指针就可以，把t优化掉:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27/**
* 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:
ListNode* removeElements(ListNode* head, int val) {
ListNode* dummy = new ListNode();
dummy->next=head;
ListNode* cur=dummy;
while(cur->next!=NULL){
if(cur->next->val==val){
cur->next=cur->next->next;
}
else{
cur=cur->next;
}
}
return dummy->next;
}
};
为什么使用cur->next而不是cur?
我的理解是使用cur->next可以使cur节点在遍历的一开始可以有选择地回避一些不符合要求地节点，cur的作用是在遍历的同时穿起一个符合要求的链表。而dummy起到一个记录起点的作用。也是因为无法无脑落地的原因,所以使用它的dummy.next，
给你单链表的头节点 $head$ ，请你反转链表，并返回反转后的链表。
+ })(window)给你单链表的头节点 $head$ ，请你反转链表，并返回反转后的链表。
示例 1：
1
2输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
@@ -158,7 +158,7 @@进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
1 | /** |
这个我一开始没做出来，看了题解才会，呜呜呜。
-给定一个只包括 (，)，{，}，[，] 的字符串 $s$ ，判断字符串是否有效。
给定一个只包括 (，)，{，}，[，] 的字符串 $s$ ，判断字符串是否有效。
有效字符串需满足：
1 | class Solution { |
充分运用了if-else if的特性，随之而来的是代码可读性的下降，时空效率超过了50%玩家,满足了。。。
也就是说hashmap的取效率比if判断低，这个也是可以理解的，两者都是常数级$O(1)$的时间复杂度,但是hashmap是要计算hash值的，哈希冲突太多会退化到$O(N)$,而if判断只是简单的比较。
-$nums1$ 中数字 $x$ 的 下一个更大元素 是指 $x$ 在 $nums2$ 中对应位置 右侧 的 第一个 比 $x$ 大的元素。
+ })(window)$nums1$ 中数字 $x$ 的 下一个更大元素 是指 $x$ 在 $nums2$ 中对应位置 右侧 的 第一个 比 $x$ 大的元素。
给你两个 没有重复元素 的数组 $nums1$ 和 $nums2$ ，下标从 0 开始计数，其中$nums1$ 是 $nums2$ 的子集。
对于每个 $0 <= i < nums1.length$ ，找出满足 $nums1[i] == nums2[j]$ 的下标 $j$ ，并且在 $nums2$ 确定 $nums2[j]$ 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 $-1$ 。
返回一个长度为 $nums1.length$ 的数组 $ans$ 作为答案，满足 $ans[i]$ 是如上所述的 下一个更大元素 。
@@ -210,7 +210,7 @@1 | class Solution { |
这段代码也是调试了一个小时才通好吧。
-写一个 $RecentCounter$ 类来计算特定时间范围内最近的请求。
+ })(window)写一个 $RecentCounter$ 类来计算特定时间范围内最近的请求。
请你实现 $RecentCounter$ 类：
1 | class RecentCounter { |
题目第一次看，看不懂，后来看懂了，还是不会，看了讲解视频顿悟。因为ping t是递增的，所以过去3000ms的边界到队尾的元素肯定是<=3000ms的，我们只需要维护这段队列就可以了，ping请求发生时，我们让他入队，然后直接用当前时间减去队首，如果大于3000ms，就把队首元素出队，直到队首元素小于等于3000ms，然后返回队列的长度就可以了。
1 |
|
B - 识别浮点常量问题1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
using namespace std;
bool isNum(char c){
if(c>='0'&&c<='9')
return true;
return false;
}
int findP(int l, int r, string s){
for(int i=0;i<=r;i++){
if(s[i]=='.'){
return i;
}
}
return -1;
}
int countP(int l, int r, string s){
int cnt=0;
for(int i=l;i<=r;i++){
if(s[i]=='.'){
cnt++;
}
}
return cnt;
}
bool isSign(char c){
if(c=='+'||c=='-')
return true;
return false;
}
bool isSmallNum(int l, int r, string s){
int p_l=findP(l,r,s);
int flag=0;
//判断小数点个数
if(!(countP(l,r,s)==1)){
return false;
}
//判小数点左侧是否有数字
for(int i=0;i<p_l;i++){
if(isNum(s[i])){
flag=1;
break;
}
}
if(!flag) return false;
flag=0;
//判小数点右侧是否有数字
for(int i=p_l+1;i<=r;i++){
if(isNum(s[i])){
flag=1;
break;
}
}
if(!flag) return false;
for(int i=l;i<=r;i++){
if(i==l&&isSign(s[l])){
if(r-l+1==1) return false;
continue;
}
else if(s[i]=='.'){
continue;
}
else if(isNum(s[i])){
continue;
}
else{
return false;
}
}
return true;
}
int FindE(string s){
for(int i=0;i<s.size();i++){
if(s[i]=='e'||s[i]=='E'){
return i;
}
}
return -1;
}
bool isInt(int l, int r, string s){
for(int i=l;i<=r;i++){
if(i==l&&isSign(s[l])){
if(r-l+1==1) return false;
continue;
}
else if(isNum(s[i])){
continue;
}
else{
return false;;
}
}
return true;
}
int main(){
string s;
int flag=0;
getline(cin, s);
int l=0, r=s.size()-1;
while(s[l]==' ') l++;
while(s[r]==' ') r--;
int len=s.size();
//3e-.3
int res=FindE(s);
if(res==-1){
if(isSmallNum(l, r, s)){
cout<<"YES";
return 0;
}
else{
cout<<"NO";
return 0;
}
}
else{
if(res==l||res==r){
flag=1;
}
if(!isSmallNum(l, res-1, s)&&!isInt(l,res-1,s)){
flag=1;
}
if(isInt(res+1,r,s)){
;
}
else{
flag=1;
}
if(flag==0){
cout<<"YES";
return 0;
}
else{
cout<<"NO";
return 0;
}
return 0;
}
}
Description
给定含有$n$个元素的多重集合$S$，每个元素在$S$中出现的次数称为该元素的重数。多重集$S$中重数最大的元素称为众数。例如，$S={1,2,2,2,3,5}$。多重集S的众数是$2$，其重数为$3$。对于给定的由n 个自然数组成的多重集$S$，计算$S$的众数及其重数。如果出现多个众数，请输出最小的那个。
Description
给定含有$n$个元素的多重集合$S$，每个元素在$S$中出现的次数称为该元素的重数。多重集$S$中重数最大的元素称为众数。例如，$S={1,2,2,2,3,5}$。多重集S的众数是$2$，其重数为$3$。对于给定的由n 个自然数组成的多重集$S$，计算$S$的众数及其重数。如果出现多个众数，请输出最小的那个。
Input
输入数据的第1行是多重集$S$中元素个数$n\ (n<1300000)$；接下来的n行中，每行有一个最多含有5位数字的自然数，。
Output
输出数据的第1行给出众数，第2行是重数。
Samples
Sample #1
所以时间复杂度:$O(logN)$
综上时间复杂度是$O(N)$
-给你一个整数数组 $nums$ 。如果任一值在数组中出现 至少两次 ，返回 $true$ ；如果数组中每个元素互不相同，返回 $false$ 。
+ })(window)给你一个整数数组 $nums$ 。如果任一值在数组中出现 至少两次 ，返回 $true$ ；如果数组中每个元素互不相同，返回 $false$ 。
示例 1：
1 | 输入：nums = [1,2,3,1] |
示例 2：
@@ -157,7 +157,7 @@1 | // class Solution { |
HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。插入和搜索时间复杂度为 $O(1)$
-给定两个字符串 $s$ 和 $t$ ，它们只包含小写字母。
+ })(window)给定两个字符串 $s$ 和 $t$ ，它们只包含小写字母。
字符串 $t$ 由字符串 $s$ 随机重排，然后在随机位置添加一个字母。
请找出在 $t$ 中被添加的字母。
示例 1：
@@ -163,7 +163,7 @@1 | class Solution { |
依次遍历s和t,将s和t中每个字符进行异或，最后返回异或的结果。
因为两个相同的字符异或操作的结果是0，所以最后剩下的字符就是t中多出来的字符。
1 | class Solution { |
不使用任何内建的哈希表库设计一个哈希集合（HashSet）。
+ })(window)不使用任何内建的哈希表库设计一个哈希集合（HashSet）。
实现 $MyHashSet$ 类：
哈希表长度最好为素数，这样可以减少哈希冲突，这里取857，然后使用链地址法解决哈希冲突，即使用链表存储哈希冲突的元素。
1 | class MyHashSet { |
堆是一种具有特殊规则的树，而且是完全二叉树，存储完全二叉树，常见的方式就是数组。
+ })(window)堆是一种具有特殊规则的树，而且是完全二叉树，存储完全二叉树，常见的方式就是数组。
右孩子与父节点在数组索引的关系
$i{parent}=(i{right}-2)/2$
1 | public MaxHeap(int[] arr){ |
一运行超过16%的用户破防了
-给定整数数组 $nums$ 和整数 $k$，请返回数组中第 $k$ 个最大的元素。
+ })(window)给定整数数组 $nums$ 和整数 $k$，请返回数组中第 $k$ 个最大的元素。
请注意，你需要找的是数组排序后的第 $k$ 个最大的元素，而不是第 $k$ 个不同的元素。
你必须设计并实现时间复杂度为 $O(n)$ 的算法解决此问题。
示例 1:
@@ -156,7 +156,7 @@1 | class Solution { |
安装openssh msi
运行
1 | netsh advfirewall firewall add rule name=sshd dir=in action=allow protocol=TCP localport=22 |
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
@@ -164,7 +164,7 @@-5000 <= Node.val <= 5000进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
-
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
* 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:
ListNode* reverseList(ListNode* head) {
ListNode* dummy=new ListNode();
ListNode* p=head;
while(p!=NULL){
ListNode* t=p;
p=p->next;
t->next=dummy->next;
dummy->next=t;
}
return dummy->next;
}
};
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1：
@@ -241,7 +241,7 @@其中$(n-1)(b+c)$是周长的整数倍，因此位移是$0$
因此$X_{slowP}=X_P=a$，即相遇于入环点。
1 | /** |