lemonaaaaa's blog A blog recording my life 2020-12-30T06:17:25.047Z http://lemonaaaaa.com/ Lemon Hexo 《玫瑰海岸》 摘抄 http://lemonaaaaa.com/2020/12/lqxsw-meiguihaian/ 2020-12-30T06:11:06.000Z 2020-12-30T06:17:25.047Z

海岸小品

谛听那涛声

有时候在海边的黄昏，看海鸥以优雅闲淡的姿势飞过，很容易忘记它们飞行是为了觅食；因为在我们的想象里，觅食是一种紧张的行为，应该是匆忙而混乱的。

静静看海鸥划过晚霞，我感觉它们像我们一样，是来欣赏最后的日落。或者竟以一种澄明贞静的心情谛听着海潮的声音，让浪一波一波地冲刷着心的礁石。

当看到海鸥敛翅，用极快的速度飞身入海，然后从海中捞起一条鱼时，我惊得呆了；原来，它不只听潮，还在觅食，随时得留意海面的动静。但它谋生的动作并未减少我对优雅的估价，反而深刻地启示了我。

我们不可避免地要去求生，有时甚至要下海，不过，我们在紧张匆忙的生活里，可以让自己有较优雅的姿势，或者在为生活盘桓时，还可以谛听远方与心灵的潮声。

享受白云

我带一个朋友跑了几百里路。我说：“我带你去看一件美丽的东西。”

我们到了种满马鞍藤的海岸，我说：“到了，我带你来看南台湾的云。”

他甚至无法在海岸上坐十分钟，说：“云，有什么好看呢？”然后就催促我离开了。

我们跑到小镇上唯一的咖啡厅过了一个无聊的午后。喝着质劣的咖啡时，我心中想着的都是海岸上奔跑的白云。我想，下次要看云，最好独自到海边。

这是我年轻时代的一段往事了，越近中年越让我知道，在这苦乐人间，我们很容易找到一起享用金钱的朋友，但想找到能一起喝咖啡的朋友已经难了，想找到能坐一个下午共同享受白云的朋友，就更难了。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 第二十次CCF计算机软件能力认证 (CCF CSP 202009) 题解 http://lemonaaaaa.com/2020/09/ccf-csp-202009/ 2020-09-15T11:53:57.000Z 2020-09-15T11:58:51.550Z

第一题

题目大意

给出一个参考点，再给出nn个点，求这nn个点中距参考点欧几里得最近的33个点的编号。如果距离相同，则按照编号升序排序。

解法

直接求出每个点距离参考点的距离，再排序即可。

如果不会排序，则扫三遍距离，每次找不同并且最小的即可。

代码

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
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=2005;
int x,n,y;
struct node
{
int id;
double dis;
} pos[maxn];
double get(double x,double y,double xx,double yy)
{
return (x-xx)*(x-xx)+(y-yy)*(y-yy);
}
bool cmp(node a,node b) {return a.dis==b.dis?a.id<b.id:a.dis<b.dis;}
int main()
{
scanf("%d%d%d",&n,&x,&y);
for(int i=1,tx,ty;i<=n;i++)
{
scanf("%d%d",&tx,&ty);
pos[i].id=i;
pos[i].dis=get(tx,ty,x,y);
}
sort(pos+1,pos+n,cmp);
for(int i=1;i<=3;i++) printf("%d\n",pos[i].id);
return 0;
}

第二题

题目大意

给出一个疫区，再给出nn个人各tt个时刻的行踪。如果某人某时刻在疫区内，则算经过；如果某人连续tt时刻都在疫区内，则算停留。求这nn个人中经过和停留疫区的各多少人。

解法

直接模拟即可，注意要连续tt时刻才算停留。

代码

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
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

int n,k,t,xl,yd,xr,yu,x,y;
bool check()
{
if(x>=xl&&x<=xr&&y>=yd&&y<=yu) return true;
return false;
}
int main()
{
scanf("%d%d%d%d%d%d%d",&n,&k,&t,&xl,&yd,&xr,&yu);
int ans1=0,ans2=0;
for(int i=1;i<=n;i++)
{
int temp=0,t2=0;
bool flag=false;
for(int j=1;j<=t;j++)
{
scanf("%d%d",&x,&y);
if(check())
{
temp++;
t2++;
if(t2>=k) flag=true;
}
else t2=0;
}
if(temp) ans1++;
if(flag) ans2++;
}
printf("%d\n%d",ans1,ans2);
return 0;
}

第三题

题目大意

给出许多逻辑器件，告诉每一个逻辑器件的输入，再给出外输入，求给定器件最后的输出。只考虑时序电路，即如果产生了循环，则输出"LOOP"。

题解

一眼看过去就是拓扑排序，先跑一遍求出拓扑序，然后就可以直接根据拓扑序进行处理。正好拓扑排序也可以判环，跑完拓扑排序后看是否还有点有入度，如果有，即有环。

代码

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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<string>
#include<vector>
using namespace std;
const int maxn=10005;
map<string,int> mp;
int T,type[maxn],in[maxn],que[maxn],head[maxn];
int sta[maxn],cnt=0,s,n,m,degree[maxn];
struct node
{
int to,next;
} edge[maxn<<1];
inline void add(int u,int v)
{
edge[++cnt].to=v;
edge[cnt].next=head[u];
head[u]=cnt;
}
void clear()
{
memset(type,0,sizeof(type));
memset(head,0,sizeof(head));
memset(degree,0,sizeof(degree));
memset(sta,0,sizeof(sta));
cnt=0;
}
inline int getnum(string str)
{
int x=0,len=str.length()-1;
for(int i=1;i<=len;i++) x=(x<<1)+(x<<3)+str[i]-48;
return x;
}
int main()
{
#ifdef lemon
freopen("C.txt","r",stdin);
#endif
mp["NOT"]=1;mp["AND"]=2;mp["OR"]=3;
mp["XOR"]=4;mp["NAND"]=5;mp["NOR"]=6;
scanf("%d",&T);
while(T--)
{
clear();
scanf("%d%d",&m,&n);
for(int i=1,k;i<=n;i++)
{
string opt,str;
cin>>opt;
type[i]=mp[opt];
//printf("%d\n",type[i]);
scanf("%d",&k);
while(k--)
{
cin>>str;
//cout<<str<<endl;
int id=getnum(str);
//printf("%d\n",id);
if(str[0]=='I')
{
add(id+n,i);
degree[i]++;
}
else
{
add(id,i);
degree[i]++;
}
}
}
//printf("%d %d\n",m,n);
scanf("%d",&s);
vector<int> in[maxn],que[maxn];
for(int i=1,x;i<=s;i++)
{
for(int j=1;j<=m;j++)
{
scanf("%d",&x);
in[i].push_back(x);
}
}
for(int i=1,x,ss;i<=s;i++)
{
scanf("%d",&ss);
while(ss--)
{
scanf("%d",&x);
que[i].push_back(x);
}
}
queue<int> q;
vector<int> vec[maxn],ord;
bool loop=false;
for(int i=1;i<=n+m;i++)
{
if(!degree[i])
{
q.push(i);
}
}
while(!q.empty())
{
int x=q.front();q.pop();
ord.push_back(x);
for(int i=head[x];i;i=edge[i].next)
{
if(!(--degree[edge[i].to]))
{
q.push(edge[i].to);
}
vec[edge[i].to].push_back(x);
}
}
for(int i=1;i<=n+m;i++) if(degree[i]) loop=true;
if(loop) printf("LOOP\n");
else
{
//printf("%d\n",ord.size());
//for(int i=0;i<ord.size();i++) printf("%d ",ord[i]);printf("\n");
for(int t=1;t<=s;t++)
{
for(int i=1;i<=m;i++) sta[i+n]=in[t][i-1];
//for(int i=0;i<(int)ord.size();i++) printf("#%d %d\n",ord[i],vec[ord[i]].size());
for(int i=0;i<(int)ord.size();i++)
{
if(ord[i]>n) continue;
if(type[ord[i]]==1)
{
sta[ord[i]]=!sta[vec[ord[i]][0]];
}
else if(type[ord[i]]==2)
{
sta[ord[i]]=sta[vec[ord[i]][0]];
for(int j=1;j<vec[ord[i]].size();j++)
{
sta[ord[i]]&=sta[vec[ord[i]][j]];
}
}
else if(type[ord[i]]==3)
{
sta[ord[i]]=sta[vec[ord[i]][0]];
for(int j=1;j<vec[ord[i]].size();j++)
{
sta[ord[i]]|=sta[vec[ord[i]][j]];
}
}
else if(type[ord[i]]==4)
{
sta[ord[i]]=sta[vec[ord[i]][0]];
for(int j=1;j<vec[ord[i]].size();j++)
{
sta[ord[i]]^=sta[vec[ord[i]][j]];
}
}
else if(type[ord[i]]==5)
{
sta[ord[i]]=sta[vec[ord[i]][0]];
for(int j=1;j<vec[ord[i]].size();j++)
{
sta[ord[i]]&=sta[vec[ord[i]][j]];
}
sta[ord[i]]=!sta[ord[i]];
}
else if(type[ord[i]]==6)
{
sta[ord[i]]=sta[vec[ord[i]][0]];
for(int j=1;j<vec[ord[i]].size();j++)
{
sta[ord[i]]|=sta[vec[ord[i]][j]];
}
sta[ord[i]]=!sta[ord[i]];
}
}
for(int i=0;i<que[t].size();i++) printf("%d ",sta[que[t][i]]);
printf("\n");
}
}
}
return 0;
}

第四题（仅作参考）

题目大意

给出nn个点，再给出一个半径为rr的圆/球/超球体（这里记为CIRCLE）。对于每个点，需要求出这个点与其他点的最短距离之和，不能经过CIRCLE。

解法

对于两个点连线不经过CIRCLE的一对点，最近距离就是直接连线。

对于两个点连线经过CIRCLE的一对点，最近距离就是切线+圆弧+切线。

但是这道题调了3个小时也不对，不知道是写挂了还是思路有问题。
最后只过了40分的所有点都在圆上的情况。

代码（40分）

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
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const double pi=acos(-1.0);
const int maxn=105;
int n,m,r,c[maxn],p[2005][maxn];
inline double getdis(int x,int y)
{
return 0;
}
void work15()
{
for(int i=1;i<=m;i++)
{
double temp=0;
for(int j=1;j<=m;j++)
{
if(i==j) continue;
double dis=sqrt((double)(p[i][1]-p[j][1])*(p[i][1]-p[j][1])+(double)(p[i][2]-p[j][2])*(p[i][2]-p[j][2]));
double tdis=dis/2.0;
double sinv=tdis/(double)r;
//printf("@%lf\n",sinv);
double ta=asin(sinv)*2;
//printf("#%lf\n",ta/pi);
temp+=ta*r;
}
printf("%.14lf\n",temp);
}
}
int main()
{
#ifdef lemon
freopen("D.txt","r",stdin);
#endif
scanf("%d%d%d",&n,&m,&r);
for(int i=1;i<=n;i++) scanf("%d",&c[i]);
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++) scanf("%d",&p[i][j]);
if(m<=50) work15();
else
{
for(int i=1;i<=m;i++)
{
double temp=0;
for(int j=1;j<=m;j++)
{
if(i==j) continue;
double tt=0;
for(int k=1;k<=n;k++) tt+=(double)(p[i][k]-p[j][k])*(p[i][k]-p[j][k]);
double dis=sqrt(tt);
double tdis=dis/2.0;
double sinv=tdis/(double)r;
//printf("@%lf\n",sinv);
double ta=asin(sinv)*2;
//printf("#%lf\n",ta/pi);
temp+=ta*r;
}
printf("%.14lf\n",temp);
}
}
return 0;
}
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 洛谷 P4015 运输问题 题解 http://lemonaaaaa.com/2020/08/luogu-4015/ 2020-08-28T08:06:31.000Z 2020-08-28T08:06:31.863Z

题目链接

题目大意

WW 公司有 mm 个仓库和 nn 个零售商店。第 ii 个仓库有 aia_i​ 个单位的货物；第 jj 个零售商店需要 bjb_j 个单位的货物。

货物供需平衡.

从第 ii 个仓库运送每单位货物到第 jj 个零售商店的费用为 cijc_{ij}​​ 。

试设计一个将仓库中所有货物运送到零售商店的运输方案，使总运输费用最少。

题解

费用流模板题。

建源点和汇点连边。

源点向每个仓库ii连边，流量为仓库ii的货物数量，费用为00.
每个商店jj向汇点连边，流量为商店jj的需求量，费用为00.

以上两种边的目的都是限制流量，同时因为货物供需平衡，最后一定能全部满足。

最后每个仓库ii向商店jj连边，流量为infinf，费用为cijc_{ij}. 如果这种边通过流量，那么就说明仓库ii运送了货物到商店jj.

最后跑费用流就好了。

代码

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
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int maxn=105;
const int maxm=1000005;
const int inf=0x7f7f7f7f;
const long long linf=1e18;

struct node
{
int to,next,flow;
long long cost;
} edge[maxm<<1];

bool vis[maxn<<2];
int head[maxn<<2],k,s,t;
long long dist[maxn<<2],tot_cost;

void add(int u,int v,int w,long long c)
{
edge[++k].to=v;
edge[k].next=head[u];
head[u]=k;
edge[k].flow=w;
edge[k].cost=c;
swap(u,v);
edge[++k].to=v;
edge[k].next=head[u];
head[u]=k;
edge[k].flow=0;
edge[k].cost=-c;
}
bool spfa()
{
for(int i=0;i<=t;i++) dist[i]=linf;
memset(vis,false,sizeof(vis));
queue<int> q;dist[t]=0;q.push(t);
while(!q.empty())
{
int x=q.front();q.pop();vis[x]=false;
for(int i=head[x];i;i=edge[i].next)
{
if(dist[edge[i].to]>dist[x]-edge[i].cost&&edge[i^1].flow)
{
dist[edge[i].to]=dist[x]-edge[i].cost;
if(!vis[edge[i].to])
{
vis[edge[i].to]=true;
q.push(edge[i].to);
}
}
}
}
return dist[s]!=linf;
}
int dfs(int x,int f)
{
vis[x]=true;
if(x==t||!f) return f;
int flow=0;
for(int i=head[x];i;i=edge[i].next)
{
if(vis[edge[i].to]) continue;
if(dist[edge[i].to]==dist[x]-edge[i].cost&&edge[i].flow)
{
int temp=dfs(edge[i].to,min(f-flow,edge[i].flow));
edge[i].flow-=temp;
edge[i^1].flow+=temp;
flow+=temp;
tot_cost+=(long long)temp*edge[i].cost;
if(f==flow) break;
}
}
return flow;
}
void zkw()
{
tot_cost=0;
while(spfa())
{
vis[t]=true;
while(vis[t])
{
memset(vis,false,sizeof(vis));
dfs(s,inf);
}
}
if(tot_cost>=0) printf("%lld\n",tot_cost);
else printf("%lld\n",-tot_cost);
}
int n,m,a[maxn],b[maxn],cost[maxn][maxn];

int main()
{
#ifdef lemon
freopen("4015.txt","r",stdin);
#endif
scanf("%d%d",&m,&n);s=0;t=m+n+1;k=1;
for(int i=1;i<=m;i++) scanf("%d",&a[i]);
for(int i=1;i<=n;i++) scanf("%d",&b[i]);
//1-n store
//n+1-m repo
//0 source
//n+m+1
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
scanf("%d",&cost[i][j]);
for(int i=1;i<=n;i++) add(i,t,b[i],0);
for(int i=1;i<=m;i++) add(s,i+n,a[i],0);
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
add(i+n,j,inf,cost[i][j]);
zkw();
memset(head,0,sizeof(head));k=1;
for(int i=1;i<=n;i++) add(i,t,b[i],0);
for(int i=1;i<=m;i++) add(s,i+n,a[i],0);
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
add(i+n,j,inf,-cost[i][j]);
zkw();
return 0;
}
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 洛谷 P2596 [ZJOI2006]书架 题解 http://lemonaaaaa.com/2020/08/luogu-2596/ 2020-08-27T12:48:14.000Z 2020-08-27T12:48:14.752Z

题目链接

题目原文

小 T 有一个很大的书柜。这个书柜的构造有些独特，即书柜里的书是从上至下堆放成一列。她用 11 到 nn 的正整数给每本书都编了号。

小 T 在看书的时候，每次取出一本书，看完后放回书柜然后再拿下一本。由于这些书太有吸引力了，所以她看完后常常会忘记原来是放在书柜的什么位置。不过小 T 的记忆力是非常好的，所以每次放书的时候至少能够将那本书放在拿出来时的位置附近，比如说她拿的时候这本书上面有 xx 本书，那么放回去时这本书上面就只可能有 x−1x-1 、 xx 或 x+1x+1 本书。

当然也有特殊情况，比如在看书的时候突然电话响了或者有朋友来访。这时候粗心的小 T 会随手把书放在书柜里所有书的最上面或者最下面，然后转身离开。

久而久之，小 T 的书柜里的书的顺序就会越来越乱，找到特定的编号的书就变得越来越困难。于是她想请你帮她编写一个图书管理程序，处理她看书时的一些操作，以及回答她的两个提问：

  • 编号为 xx 的书在书柜的什么位置。
  • 从上到下第 ii 本书的编号是多少。

题解

一道splay的模板题，拿来熟悉splay的模板和理解splay的结构是很不错的。

Top 操作

首先将给的点旋转到根。

先判断其有没有左儿子，如果没有，那么这个点就已经是在top，不用进行任何操作。

再判断其有没有右儿子，如果没有，说明这个点在bottom，直接交换左右儿子即可。

如果既有左儿子又有右儿子，那么我们只需要将它的左儿子接到它的后继上，这样既满足了平衡树的规则，也满足了根节点没有左儿子，即该点是top的要求。

Bottom 操作

与Top操作同理。

Insert 操作

首先将给的点旋转到根。

如果t=1t=1，那么就直接将根节点与后继交换。
如果t=0t=0，相当于位置没有改变，直接忽略本次操作。
如果t=−1t=-1，那么就直接将根节点与前驱交换。

Ask 操作

就是求比根节点小的数的个数。

将根节点旋转到根，答案就是根节点左儿子的size。

Query 操作

就是找第k大。

总结与反思

在多次交换的时候一定要注意前后值是否发生改变，需不需要保留历史版本，太坑了。

代码

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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
/*************************************************
*           Copyright: lemonaaaaa                *
*           Author: lemonaaaaa                   *
*           Date: 2020-08-24                     *
*           Description: luogu P2596 splay tree  *
**************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
struct splay_tree
{
int ch[maxn][2],fa[maxn],val[maxn],size[maxn],cnt[maxn],stack[maxn];
int tot,root;
splay_tree()
{
tot=root=0;
}
bool get(int x)
{
return ch[fa[x]][1]==x;
}
void update(int x)
{
if(!x) return;
size[x]=cnt[x];
if(ch[x][0]) size[x]+=size[ch[x][0]];
if(ch[x][1]) size[x]+=size[ch[x][1]]; 
}
void clear(int x)
{
ch[x][0]=ch[x][1]=val[x]=fa[x]=size[x]=cnt[x]=0;
}
void rotate(int x)
{
int old=fa[x],oldfa=fa[old],w=get(x);
ch[old][w]=ch[x][w^1];fa[ch[old][w]]=old;
fa[old]=x;ch[x][w^1]=old;fa[x]=oldfa;
if(oldfa) ch[oldfa][ch[oldfa][1]==old]=x;
update(old);update(x);
}
void splay(int x,int tar)
{
for(int father;(father=fa[x])!=tar;rotate(x))
if(fa[father]!=tar) rotate(get(x)==get(father)?father:x);
if(!tar) root=x;
}
void insert(int x)
{
if(!root)
{
root=++tot;
val[root]=x;
cnt[root]=size[root]=1;
return;
}
int now=root,father=0;
while(true)
{
if(val[now]==x)
{
cnt[now]++;
update(now);
update(father);
splay(now,0);
break;
}
father=now;
now=ch[now][x>val[now]];
if(!now)
{
now=++tot;
cnt[now]=size[now]=1;
val[now]=x;
fa[now]=father;
ch[father][x>val[father]]=now;
update(now);update(father);
splay(now,0);
break;
}
}
}
int find(int x)
{
int ans=0,now=root;
while(true)
{
if(x<val[now]) now=ch[now][0];
else
{
ans+=size[ch[now][0]];
if(val[now]==x)
{
splay(now,0);
return ans+1;
}
ans+=cnt[now];
now=ch[now][1];
}
}
}
int findkth(int x)
{
int now=root;
while(true)
{
if(ch[now][0]&&x<=size[ch[now][0]]) now=ch[now][0];
else
{
int temp=size[ch[now][0]]+cnt[now];
if(x<=temp) return val[now];
x-=temp;now=ch[now][1];
}
}
}
int pre()
{
int now=ch[root][0];
while(ch[now][1]) now=ch[now][1];
return now;
}
int next()
{
int now=ch[root][1];
while(ch[now][0]) now=ch[now][0];
return now;
}
void del(int x)
{
find(x);
if(cnt[root]>1)
{
cnt[root]--;
update(root);
return;
}
if(!ch[root][0]&&!ch[root][1])
{
clear(root);
root=0;
return;
}
if(!ch[root][0])
{
int oldroot=root;
root=ch[root][1];
fa[root]=0;
clear(oldroot);
return;
}
if(!ch[root][1])
{
int oldroot=root;
root=ch[root][0];
fa[root]=0;
clear(oldroot);
}
int leftbig=pre(),oldroot=root;
splay(leftbig,0);
ch[root][1]=ch[oldroot][1];
fa[ch[root][1]]=root;
clear(oldroot);
update(root);
return;
}
void print(int x)
{
if(ch[x][0]) print(ch[x][0]);
stack[++stack[0]]=val[x];
if(ch[x][1]) print(ch[x][1]);
}
};
int n,m,p[maxn],pos[maxn];
splay_tree tree;
char opt[10];
int main()
{
 #ifdef lemon
//freopen("P2596_1.in","r",stdin);
freopen("2596.txt","r",stdin);
#endif
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
scanf("%d",&p[i]);
pos[p[i]]=i;
tree.insert(i);
}
//for(int i=1;i<=n;i++) printf("##%d %d\n",i,tree.val[i]);
for(int i=1,x,y;i<=m;i++)
{
//printf("$%d\n",i);
scanf("%s%d",opt,&x);
if(opt[0]=='T')
{
tree.splay(pos[x],0);
//tree.find(pos[x]);
//if(tree.root==pos[x]) printf("Yes\n");
if(!tree.ch[tree.root][0]) continue;
else if(!tree.ch[tree.root][1])
{
//printf("$$");
tree.ch[tree.root][1]=tree.ch[tree.root][0];
tree.ch[tree.root][0]=0;
}
else
{
int nxt=tree.next();
tree.ch[nxt][0]=tree.ch[tree.root][0];
tree.fa[tree.ch[nxt][0]]=nxt;
tree.ch[tree.root][0]=0;
tree.splay(nxt,0);
}
}
else if(opt[0]=='B')
{
tree.splay(pos[x],0);
if(!tree.ch[tree.root][1]) continue;
else if(!tree.ch[tree.root][0])
{
tree.ch[tree.root][0]=tree.ch[tree.root][1];
tree.ch[tree.root][1]=0;
}
else
{
int pre=tree.pre();
tree.ch[pre][1]=tree.ch[tree.root][1];
tree.fa[tree.ch[pre][1]]=pre;
tree.ch[tree.root][1]=0;
tree.splay(pre,0);
}
}
else if(opt[0]=='I')
{
scanf("%d",&y);
if(!y) continue;
tree.splay(pos[x],0);
if(y==1)
{
int nxt=tree.next();
if(nxt==tree.root) continue;
//swap(pos[p[nxt]],pos[x]);
int pp=pos[x];
pos[p[nxt]]=pos[x];pos[x]=nxt;
swap(p[pp],p[nxt]);
}
else
{
int pre=tree.pre();
if(pre==tree.root) continue;
//swap(pos[p[pre]],pos[x]);
int pp=pos[x];
pos[p[pre]]=pos[x];pos[x]=pre;
swap(p[pp],p[pre]);
}
}
else if(opt[0]=='A')
{
tree.splay(pos[x],0);
printf("%d\n",tree.size[tree.ch[tree.root][0]]);
}
else
{
printf("%d\n",p[tree.findkth(x)]);
}
//tree.stack[0]=0;
//tree.print(tree.root);
//for(int j=1;j<=tree.stack[0];j++) printf("%d ",p[tree.stack[j]]);
//printf("\n");
}
return 0;
}
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 计算机系统基础 Bomb Lab 实验 http://lemonaaaaa.com/2020/08/bomb-lab/ 2020-08-26T05:33:06.000Z 2020-08-26T05:33:06.977Z

phase_6

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
;phase_6开始
0x00000000004010f4 <+0>:     push   %r14
0x00000000004010f6 <+2>:     push   %r13
0x00000000004010f8 <+4>:     push   %r12
0x00000000004010fa <+6>:     push   %rbp
0x00000000004010fb <+7>:     push   %rbx
0x00000000004010fc <+8>:     sub    $0x50,%rsp ;分配50个字节的空间

0x0000000000401100 <+12>:    mov    %rsp,%r13
0x0000000000401103 <+15>:    mov    %rsp,%rsi
0x0000000000401106 <+18>:    callq  0x40145c <read_six_numbers> ;读入6个数,读入的6个数从%rsp开始存，依次存在%rsp, %rsp+4, ..., %rsp+20

0x000000000040110b <+23>:    mov    %rsp,%r14 ;将rsp的地址传递给r14
0x000000000040110e <+26>:    mov    $0x0,%r12d ;将r12低32位赋值为0

;loop1 begin (for r12d: 0-5) ;第一层循环
0x0000000000401114 <+32>:    mov    %r13,%rbp
0x0000000000401117 <+35>:    mov    0x0(%r13),%eax ;将r13的值+0送到eax
0x000000000040111b <+39>:    sub    $0x1,%eax ;eax-=1
0x000000000040111e <+42>:    cmp    $0x5,%eax
0x0000000000401121 <+45>:    jbe    0x401128 <phase_6+52> ;上面两行相当于eax-1<=5，即eax<=6时跳转到+52，否则explode_bomb

0x0000000000401123 <+47>:    callq  0x40143a <explode_bomb> ;mission failed

0x0000000000401128 <+52>:    add    $0x1,%r12d ;r12d++
0x000000000040112c <+56>:    cmp    $0x6,%r12d
0x0000000000401130 <+60>:    je     0x401153 <phase_6+95> ;如果r12d==6，说明已经比较完了，那么跳转到+95(跳出循环)

0x0000000000401132 <+62>:    mov    %r12d,%ebx ;将r12低32位送到ebx

  ;loop2_in_1 begin (for ebx: r12d-5) ;开始第二层循环
0x0000000000401135 <+65>:    movslq %ebx,%rax
0x0000000000401138 <+68>:    mov    (%rsp,%rax,4),%eax
0x000000000040113b <+71>:    cmp    %eax,0x0(%rbp) ;比较第一层循环枚举到的数(0x0(%rbp))和当前枚举到的数是否相等
0x000000000040113e <+74>:    jne    0x401145 <phase_6+81> ;不相等则跳转到+81继续执行，相等则explode_bomb

0x0000000000401140 <+76>:    callq  0x40143a <explode_bomb> ;mission failed

0x0000000000401145 <+81>:    add    $0x1,%ebx ;ebx++
0x0000000000401148 <+84>:    cmp    $0x5,%ebx ;
0x000000000040114b <+87>:    jle    0x401135 <phase_6+65> ;上面两行相当于如果ebx+1<=5，则跳转到+65(第二层循环起点)
  ;loop2_in_1 end.

0x000000000040114d <+89>:    add    $0x4,%r13
0x0000000000401151 <+93>:    jmp    0x401114 <phase_6+32> ;进入下一次循环
;loop1 end. ;根据以上可以得出这两层循环是在判断输入的6个数都是小于等于6的，并且互不相等，否则便会引爆炸弹。

0x0000000000401153 <+95>:    lea    0x18(%rsp),%rsi ;将地址传给rsi，由+118可知这是循环结束的条件(0x18(%rsp)为*(rsp+24)，注意区分十进制和十六进制)
0x0000000000401158 <+100>:   mov    %r14,%rax ;将r14的地址传给rax，由前面我们知道r14的地址存的是rsp的地址，即为那6个数的首地址
0x000000000040115b <+103>:   mov    $0x7,%ecx ;将ecx赋值为7

;loop3 begin(for six values in rsp)
0x0000000000401160 <+108>:   mov    %ecx,%edx ;将ecx的值送到edx中(值为7)
0x0000000000401162 <+110>:   sub    (%rax),%edx ;把edx-*rax的值送到edx中，即edx-=*rax

0x0000000000401164 <+112>:   mov    %edx,(%rax) ;把edx的值送到*rax中，结合上两句，一次循环的操作*rax=7-*rax
0x0000000000401166 <+114>:   add    $0x4,%rax ;rax+4，即访问下一个地址
0x000000000040116a <+118>:   cmp    %rsi,%rax ;判断是否循环到结束条件
0x000000000040116d <+121>:   jne    0x401160 <phase_6+108> ;如果没有继续循环loop3
;loop3 end. ;根据loop3可以得出将输入的6个数中每一个数x变成7-x

0x000000000040116f <+123>:   mov    $0x0,%esi ;esi=0
0x0000000000401174 <+128>:   jmp    0x401197 <phase_6+163> ;直接跳转到+163

;loop4 begin

  ;loop5 begin ;嵌套在loop4里面
0x0000000000401176 <+130>:   mov    0x8(%rdx),%rdx ;访问下一个地址(链表的下一个元素)

0x000000000040117a <+134>:   add    $0x1,%eax ;eax+=1
0x000000000040117d <+137>:   cmp    %ecx,%eax ;比较ecx和eax
0x000000000040117f <+139>:   jne    0x401176 <phase_6+130>
  ;loop5 end.

0x0000000000401181 <+141>:   jmp    0x401188 <phase_6+148> ;注意这里是直接跳转到+148，不执行+143

0x0000000000401183 <+143>:   mov    $0x6032d0,%edx
  ;使用"p/s *0x6032d0 @24"查看
  ;*0x6032d0: {332, 1, 6304480, 0, 168, 2, 6304496, 0, 924, 3, 6304512, 0, 691, 4, 6304528, 0, 477, 5, 6304544, 0, 443, 6, 0, 0}
  ;可以得到这个链表一共有6个元素，每个元素有4个字节，第三个字节为下一个元素的地址，第四个字节为0，前两个暂不清楚

0x0000000000401188 <+148>:   mov    %rdx,0x20(%rsp,%rsi,2)

0x000000000040118d <+153>:   add    $0x4,%rsi ;访问下一个地址
0x0000000000401191 <+157>:   cmp    $0x18,%rsi ;如果到最后一个地址则结束(rsi==24，注意区分十进制和十六进制)
0x0000000000401195 <+161>:   je     0x4011ab <phase_6+183> ;如果相等就结束循环

0x0000000000401197 <+163>:   mov    (%rsp,%rsi,1),%ecx ;不满足循环结束条件/从+128跳转过来,作为第一次循环的入口
0x000000000040119a <+166>:   cmp    $0x1,%ecx
0x000000000040119d <+169>:   jle    0x401183 <phase_6+143> ;ecx<=1则跳转到+143

0x000000000040119f <+171>:   mov    $0x1,%eax ;赋初值eax=1
0x00000000004011a4 <+176>:   mov    $0x6032d0,%edx ;传入链表的首地址到edx
0x00000000004011a9 <+181>:   jmp    0x401176 <phase_6+130> ;开始循环
;loop4 end.

0x00000000004011ab <+183>:   mov    0x20(%rsp),%rbx ;rbx=*(rsp+32)，则rbx存的为排序关键数
0x00000000004011b0 <+188>:   lea    0x28(%rsp),%rax ;将*(rsp+40)的地址送到rax
0x00000000004011b5 <+193>:   lea    0x50(%rsp),%rsi ;将*(rps+80)的地址送到rsi
0x00000000004011ba <+198>:   mov    %rbx,%rcx ;将rbx送到rcx，即rcx=rbx=*(rsp+32)

;loop begin for(rax 40-80)
0x00000000004011bd <+201>:   mov    (%rax),%rdx ;rdx=*rax
0x00000000004011c0 <+204>:   mov    %rdx,0x8(%rcx) ;*(rcx+8)=rdx
0x00000000004011c4 <+208>:   add    $0x8,%rax ;rax+=8

0x00000000004011c8 <+212>:   cmp    %rsi,%rax ;比较rsi和rax
0x00000000004011cb <+215>:   je     0x4011d2 <phase_6+222> ;当rax==rsi时跳转到+222，即结束循环

0x00000000004011cd <+217>:   mov    %rdx,%rcx ;rcx=rdx=*(rcx+8)
0x00000000004011d0 <+220>:   jmp    0x4011bd <phase_6+201> ;继续循环
;loop end.

0x00000000004011d2 <+222>:   movq   $0x0,0x8(%rdx)

0x00000000004011da <+230>:   mov    $0x5,%ebp ;赋值，数据寄存器ebp=5

;loop begin
0x00000000004011df <+235>:   mov    0x8(%rbx),%rax ;rax=*(rbx+8)
0x00000000004011e3 <+239>:   mov    (%rax),%eax ;eax=*rax=*(rbx+8)
0x00000000004011e5 <+241>:   cmp    %eax,(%rbx)
0x00000000004011e7 <+243>:   jge    0x4011ee <phase_6+250> ;如果*rbx>eax=*(rbx+8)，即前一个数必须大于后一个数，则跳转到+250，否则explode_bomb

0x00000000004011e9 <+245>:   callq  0x40143a <explode_bomb>

0x00000000004011ee <+250>:   mov    0x8(%rbx),%rbx ;将*(rbx+8)送到rbx，为下一次循环做准备(准备比较下一个数和下下个数)
0x00000000004011f2 <+254>:   sub    $0x1,%ebp ;ebp-=1
0x00000000004011f5 <+257>:   jne    0x4011df <phase_6+235> ;ebp不为0则继续循环
;loop end. ;这个循环判断整个序列是否按大小降序排列，如果不是则执行explode_bomb

;phase_6结束
0x00000000004011f7 <+259>:   add    $0x50,%rsp
0x00000000004011fb <+263>:   pop    %rbx
0x00000000004011fc <+264>:   pop    %rbp
0x00000000004011fd <+265>:   pop    %r12
0x00000000004011ff <+267>:   pop    %r13
0x0000000000401201 <+269>:   pop    %r14
0x0000000000401203 <+271>:   retq
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Educational Codeforces Round 94 (Rated for Div. 2) 题解 http://lemonaaaaa.com/2020/08/educational-codeforces-round-94-div2/ 2020-08-26T05:31:59.000Z 2020-08-26T05:31:59.043Z

A. String Similarity

题目链接

题目原文

1400A

题目大意

定义两个字符串相似：两个字符串中至少有一个位置的值相同。

现在给出一个长度为2n−12n-1的字符串ss，现在让你构造一个长度为nn的字符串，使得这个字符串与ss的所有长度为nn的子串都相似。

解题思路

可以发现，ss的所有长度为nn的子串都有一个公共位置s[n]s[n]

解法

直接输出nn个s[n]s[n]就行，这个答案一定与所有子串都相似。

代码

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
/*************************************************
*           Copyright: lemonaaaaa                *
*           Author: lemonaaaaa                   *
*           Date: 2020-8-25                      *
*           Description: Edu Codeforces Round 94 *
**************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n;
char str[maxn];
int main()
{
 #ifdef lemon
freopen("A.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
scanf("%s",str+1);
for(int i=1;i<=n;i++) printf("%c",str[n]);
printf("\n");
}
return 0;
}

B. RPG Protagonist

题目链接

题目原文

1400B

题目大意

现在有两个人，一个人可以带pp单位的重量，另一个人可以带ff单位的重量。现在有两种物品，给出两种物品单件的重量以及两种物品的数量，求这两个人最多一共带走多少物品（数量最多）。

解题思路

可以发现，我们一定是采取贪心的策略。

我们先考虑一个人，那一定是先尽可能地选重量小的装，这样一定能够装更多数量。

那其实我们只需要求出第一个人选剩下的数量，第二个人能装的数量可以直接O(1)算出来。

解法

直接枚举第一个人选了多少个第一种物品，然后我们根据贪心策略，我们一定是让第一个人尽可能地装满，然后这个时候我们就得到了两种物品剩下的数量，这个时候就按照前面说的直接先选小的的策略进行选择即可。

代码

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
/*************************************************
*           Copyright: lemonaaaaa                *
*           Author: lemonaaaaa                   *
*           Date: 2020-8-25                      *
*           Description: Edu Codeforces Round 94 *
**************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T;
long long p,f,cnts,cntw,s,w,ans;
int main()
{
 #ifdef lemon
freopen("B.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
ans=0;
scanf("%lld%lld",&p,&f);
scanf("%lld%lld",&cnts,&cntw);
scanf("%lld%lld",&s,&w);
for(long long i=0;i<=cnts;i++)
{
if(i*s>p) break;
long long resp=p-i*s;
long long t2=resp/w;
if(t2>cntw) t2=cntw;
long long t1=i+t2;

long long t3=cntw-t2;
if(s<=w)
{
long long t4=f/s;
if(t4>cnts-i) t4=cnts-i;
long long temp=f-t4*s;
long long t6=temp/w;
if(t6>t3) t6=t3;
long long t5=t4+t6;
ans=max(ans,t1+t5);
}
else
{
long long t4=f/w;
if(t4>t3) t4=t3;
long long temp=f-t4*w;
long long t6=temp/s;
if(t6>cnts-i) t6=cnts-i;
long long t5=t4+t6;
ans=max(ans,t1+t5);
}
}
printf("%lld\n",ans);
}
return 0;
}

C. Binary String Reconstruction

题目链接

题目原文

1400C

题目大意

对于一个原串ss，现在通过以下规则构建串tt。

对于一个位置ii，如果s[i−x]s[i-x]存在并且s[i−x]=1s[i-x]=1或者s[i+x]s[i+x]存在并且s[i+x]=1s[i+x]=1，那么t[i]t[i]就为1，否则t[i]t[i]为0.

现在给出串tt，让你还原原串ss.

解题思路

直接从前往后依次贪心还原即可，如果有冲突的就无解。注意00是要求ss前后两个位置都为00.

解法

如上。

代码

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
/*************************************************
*           Copyright: lemonaaaaa                *
*           Author: lemonaaaaa                   *
*           Date: 2020-8-25                      *
*           Description: Edu Codeforces Round 94 *
**************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,x;
char str[maxn];
int ans[maxn];
int main()
{
 #ifdef lemon
freopen("C.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%s%d",str+1,&x);
int n=strlen(str+1);
bool flag=false;
for(int i=1;i<=n;i++) ans[i]=-1;
for(int i=1;i<=n;i++)
{
if(str[i]=='1')
{
bool f=false;
if(i-x>=1)
{
if(ans[i-x]==1) f=true;
else if(ans[i-x]==-1) ans[i-x]=1,f=true;
}
if(!f&&i+x<=n)
{
if(ans[i+x]==1) f=true;
else if(ans[i+x]==-1) ans[i+x]=1,f=true;
}
if(!f) flag=true;
}
else
{
bool f=true;
if(i-x>=1)
{
if(ans[i-x]==-1) ans[i-x]=0;
if(ans[i-x]==1) f=false;
}
if(i+x<=n)
{
if(ans[i+x]==-1) ans[i+x]=0;
if(ans[i+x]==1) f=false;
}
if(!f) flag=true;
}
}
for(int i=1;i<=n;i++) if(ans[i]==-1)
{
int f=1;
if(i-x>=1&&str[i-x]=='0') f=0;
if(i+x<=n&&str[i+x]=='0') f=0;
ans[i]=f;
if(f==0)
{
if(i-x>=1&&str[i-x]=='1') flag=true;
if(i+x<=n&&str[i+x]=='1') flag=true;
}
if(f==1)
{
if(i-x>=1&&str[i-x]=='0') flag=true;;
if(i+x<=n&&str[i+x]=='0') flag=true;
}
}
if(flag) {printf("-1\n");continue;}
for(int i=1;i<=n;i++) printf("%d",ans[i]);printf("\n");
}
return 0;
}

D. Zigzags

题目链接

题目原文

1400D

题目大意

给出一个数组，求满足以下条件的四元组(i,j,k,l)(i,j,k,l)的个数。

1⩽i<j<k<l⩽nai=ak  and  aj=al1 \leqslant i < j < k < l \leqslant n \\ a_i = a_k \; \text{and} \; a_j=a_l

解题思路

先前缀和求出各数字出现的次数，再枚举jj和kk的位置，这时两个数字都是确定的，然后直接O(1)O(1)算出jj前a[k]a[k]的数量与kk后a[j]a[j]的数量，相乘累加答案即可。

解法

如上。

代码

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
/*************************************************
*           Copyright: lemonaaaaa                *
*           Author: lemonaaaaa                   *
*           Date: 2020-8-26                      *
*           Description: Edu Codeforces Round 94 *
**************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=3005;
int T,n,a[maxn],cnt[maxn][maxn];
int main()
{
 #ifdef lemon
freopen("D.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
for(int j=1;j<=n;j++)
{
cnt[i][j]=cnt[i-1][j];
}
cnt[i][a[i]]++;
}
long long ans=0;
for(int i=1;i<=n;i++)
{
for(int j=i+1;j<=n;j++)
{
ans+=(long long)cnt[i-1][a[j]]*(long long)(cnt[n][a[i]]-cnt[j][a[i]]);
}
}
printf("%lld\n",ans);
}
return 0;
}

edu-round-94

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Codeforces Round 665 (Div. 2) 题解 http://lemonaaaaa.com/2020/08/codeforces-round-665-div2/ 2020-08-22T12:24:38.000Z 2020-08-22T12:24:38.871Z

A. Distance and Axis

题目链接

题目原文

1401A

题目大意

在OXOX轴上，给出点AA的坐标x=nx=n，给出一个值kk，求问能不能在OXOX轴上找一个点BB，使得你∣OA−AB∣=k|OA-AB|=k。如果不能找到，你每次可以将AA点的坐标+1+1或−1-1，求至少移动点AA多少次，使得可以找到点BB （如果以开始就能找到，那么输出 00 ）。

解题思路

由题意得OA=nOA=n，设BB的坐标为yy，那么∣AB∣=∣n−y∣|AB|=|n-y|，那么∣OA−AB∣=∣2n−y∣|OA-AB|=|2n-y|，所以就是求是否存在2n−y2n-y等于kk。

解法

如果n<kn<k，那么一定解出来yy是负数，所以一定要将点AA移动到x=kx=k处，答案为n−kn-k。

如果n−kn-k为奇数，那么除以2之后为小数，所以应该+1+1或−1-1，答案为11。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n,k,ans;
int main()
{
 #ifdef lemon
freopen("A.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&k);
ans=0;
if(n<k) ans+=k-n,n=k;
else if((n-k)&1) ans++;
printf("%d\n",ans);
}
return 0;
}

B. Ternary Sequence

题目链接

题目原文

1401B

题目大意

有两个数组aa和bb，这两个数组都只会有3个值：0或1或2。现在告诉你这两个数组中这三个值的数量。请你构造a,ba,b数组，并且由下面规则生成cc数组，并且使得cc数组每一项的和最大，求这个最大值。

规则：

ci={aibiif ai>bi0if ai=bi−aibiif ai<bi c_i = \begin{cases} a_i b_i &\text{if } a_i > b_i \\ 0 &\text{if } a_i = b_i \\ -a_i b_i &\text{if } a_i < b_i\end{cases}

解题思路

这种题看过去不是贪心就是dp。

解法

我们贪心地想，首先要使得ai=2,  bi=1a_i=2, \; b_i=1的数量尽可能地多，然后尽可能地使得其他都为0，最后实在不行再使得值为ai=1,  bi=2a_i=1, \; b_i=2。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T;
long long x1,yy1,z1,x2,y2,z2;
int main()
{
 #ifdef lemon
freopen("B.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%lld%lld%lld%lld%lld%lld",&x1,&yy1,&z1,&x2,&y2,&z2);
long long t1=min(z1,y2),ans=0;
z1-=t1;y2-=t1;
ans+=2ll*t1;
long long t2=min(z1,z2);
z1-=t2;z2-=t2;
long long t3=min(x1,z2);
x1-=t3;z2-=t3;
ans-=2ll*z2;
printf("%lld\n",ans);
}
return 0;
}

C. Mere Array

题目链接

题目原文

1401C

题目大意

给出长度为nn的数组，每个数都大于1。记数组中最小的数为minn，现在你可以将数组中任意两个gcd=minngcd=minn的数进行交换。求有没有可能使得整个数组变成不下降序列。

解题思路

显然minn可以和所有数进行交换，那就将minn作为交换的中间值。

解法

将数组中是minn的倍数的数提出来，直接排序（因为他们都可以通过minn进行交换）。然后从小到大插入提出来的位置。最后check一下数组，如果这个数组满足要求，那么就ok。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int a[maxn],b[maxn],c[maxn],T,n;
int main()
{
 #ifdef lemon
freopen("C.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
int minn=0x7f7f7f7f;b[0]=0;
for(int i=1;i<=n;i++) scanf("%d",&a[i]),minn=min(minn,a[i]);
for(int i=1;i<=n;i++) if(a[i]%minn==0) b[++b[0]]=a[i];
sort(b+1,b+b[0]+1);
int p=1;
for(int i=1;i<=n;i++)
{
if(a[i]%minn) c[i]=a[i];
else c[i]=b[p++];
}
bool flag=true;
for(int i=2;i<=n;i++) if(c[i]<c[i-1]) flag=false;
if(flag) printf("YES\n");
else printf("NO\n");
}
return 0;
}

D. Maximum Distributed Tree

题目链接

题目原文

1401D

题目大意

给出一棵树，但没有边权。
给出一个数的因数形式（给出的数的乘积为k）。

现在你需要给每一条边赋值，使得所有每两个点之间通过的路径和最大，且边权需要满足以下要求：

  1. 每条边的边权必须大于0
  2. 所有边的边权之积为k
  3. 边权为1的边的数量尽可能地少

解题思路

显然我们需要将通过最多的边赋值最大，通过次数最低的边赋值最小。于是我们想到贪心。

解法

用树形dp求出每条边的通过次数，对于一条边i，它的通过次数等于它的子树大小*(n-它的子树大小)。然后再贪心求解。

注意m>n-1的情况！

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
const long long mod=1e9+7;
int T,n,head[maxn],k=0,size[maxn],tot,m;
struct node
{
int to,next;
} edge[maxn<<1];
void add(int u,int v)
{
edge[++k].to=v;
edge[k].next=head[u];
head[u]=k;
}
long long p[maxn],ans=0,b[maxn];
void dfs(int x,int fa)
{
size[x]=1;
for(int i=head[x];i;i=edge[i].next)
{
if(edge[i].to==fa) continue;
dfs(edge[i].to,x);
size[x]+=size[edge[i].to];
b[++tot]=(long long)size[edge[i].to]*(long long)(n-size[edge[i].to]);
}
}
int main()
{
 #ifdef lemon
freopen("D.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
memset(head,0,sizeof(head));k=0;tot=0;ans=0;
scanf("%d",&n);
for(int i=1,x,y;i<n;i++)
{
scanf("%d%d",&x,&y);
add(x,y);add(y,x);
}
scanf("%d",&m);
for(int i=1;i<=m;i++) scanf("%lld",&p[i]);
dfs(1,1);
sort(b+1,b+tot+1);
sort(p+1,p+m+1);
p[0]=1ll;
//for(int i=1;i<=tot;i++) printf("%d ",b[i]);printf("\n");
while(m>tot)
{
p[m-1]=(p[m-1]*p[m])%mod;
m--;
}
int pp=m;
for(int i=tot;i;i--)
{
b[i]%=mod;
ans=(ans+(b[i]*p[pp])%mod)%mod;
pp--;
if(pp<0) pp=0;
}
printf("%lld\n",ans);
}
return 0;
}
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Educational Codeforces Round 93 (Rated for Div. 2) 题解 http://lemonaaaaa.com/2020/08/educational-codeforces-round-93-div2/ 2020-08-15T13:46:33.000Z 2020-08-15T13:46:33.844Z

A. Bad Triangle

题目链接

题目原文

1398A

题目大意

给出n条边，每条边有一个长度，求问是否存在3条边不能构成三角形。

解题思路

最开始看错题了，以为是是否存在3条边能构成三角形，结果又一次10分钟没切掉A.

直接判断最小的两条边边长之和是否小于等于最长的边的边长即可。

解法

如上。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n,a[maxn],b[maxn];
int main()
{
 #ifdef lemon
//freopen("A.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);bool flag=false;
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=2;i<n;i++) if(a[1]+a[i]<=a[n])
{
printf("1 %d %d\n",i,n);
flag=true;
break;
}
if(!flag) printf("-1\n");
}
return 0;
}

B. Substring Removal Game

题目链接

题目原文

1398B

题目大意

Alice和Bob玩游戏，Alice先手。游戏规则如下：每次玩家可以选择任意相同且连续的数字从数组里删除，玩家得分为删除的这串数字中1的个数。现在Alice和Bob都采取最佳策略，求问Alice的最大可能得分是多少。

解题思路

分析：没人愿意选连续的一串0，不仅得0分，而且如果将两个1之间的所有0全部选完了之后另一个人就可以获得更多的分；就算只选一部分连续的0也是没有意义的。所以两个人执行最优策略一定是都选连续的1，并且肯定要从最长的连续的1开始选。

解法

统计连续的1的长度并从大到小排序为a1,a2,a3…aka_1,a_2,a_3 \dots a_k，那么Alice的得分即为a1  +a3  +a5  +…a_1\;+a_3\;+a_5\;+\dots。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T;
char str[maxn];
int a[maxn];
int main()
{
 #ifdef lemon
freopen("B.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%s",str+1);
int n=strlen(str+1);
a[0]=0;
for(int i=1;i<=n;i++)
{
if(str[i]=='1')
{
int cnt=0;
while(i<=n&&str[i]=='1')
{
cnt++;
i++;
}
a[++a[0]]=cnt;
i--;
}
}
sort(a+1,a+a[0]+1);
int ans=0;
for(int i=a[0];i>0;i-=2) ans+=a[i];
printf("%d\n",ans);
}
return 0;
}

C. Good Subarrays

题目链接

题目原文

1398C

题目大意

给出一串数，求区间长度等于区间和的区间个数。

解题思路

将所有数都-1，那么问题转换为了求区间和为0的区间个数。

解法

开一个map记录区间长度为i的数量，然后记录每个前缀和的出现次数。如果枚举到一个位置时前缀和已经出现过了，那么说明这个位置到 上一个位置、到之前所有前缀和等于这个位置前缀和的位置 之间，区间和为0，那么答案加上这些区间个数就行。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;
const int maxn=200005;
int T,n,a[maxn];
long long s[maxn],ans=0;
map<long long,long long> mp;
int main()
{
 #ifdef lemon
freopen("D.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);mp.clear();ans=0;
for(int i=1;i<=n;i++) scanf("%1d",&a[i]),a[i]--;
mp[0]=1;
for(int i=1;i<=n;i++)
{
s[i]=s[i-1]+a[i];
if(mp[s[i]]) ans+=mp[s[i]];
mp[s[i]]++;
}
printf("%lld\n",ans);
}
return 0;
}

D. Colored Rectangles

题目链接

题目原文

1398D

题目大意

给出三种颜色的若干棍棍，每次可以选择两种不同颜色的棍棍，将他们的长度相乘加到答案上，不能重复选，求能得到的最大答案是多少。

解题思路

最开始想的是贪心，每次都取最长的两组棍棍相乘，然后顺利通过了样例，交上去WA了。最开始还以为自己贪心细节写错了，后来发现贪心的实现没有问题，那就证明了这道题贪心是错的。然后一看数据范围，只有200，于是想到dp。

解法

f[i][j][k]表示第一种颜色选了i根，第二种颜色选了j根，第三种颜色选了k根得到的最大答案是多少。转移的话就枚举上一次选了哪两根来转移就好。选的顺序是从长到短，这个可以很容易证明~~（略）~~。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int n,k,m,a[maxn],b[maxn],c[maxn];
long long f[205][205][205];
int main()
{
 #ifdef lemon
freopen("C.txt","r",stdin);
#endif
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=m;i++) scanf("%d",&b[i]);
for(int i=1;i<=k;i++) scanf("%d",&c[i]);
sort(a+1,a+n+1,greater<int>());
sort(b+1,b+m+1,greater<int>());
sort(c+1,c+k+1,greater<int>());
long long ans=0;
for(int i=0;i<=n;i++)
{
for(int j=0;j<=m;j++)
{
for(int p=0;p<=k;p++)
{
if((i-1>=0)&&(j-1>=0)) f[i][j][p]=max(f[i][j][p],f[i-1][j-1][p]+a[i]*b[j]);
if((p-1>=0)&&(j-1>=0)) f[i][j][p]=max(f[i][j][p],f[i][j-1][p-1]+b[j]*c[p]);
if((i-1>=0)&&(p-1>=0)) f[i][j][p]=max(f[i][j][p],f[i-1][j][p-1]+a[i]*c[p]);
//printf("%d %d %d %lld\n",a[i],b[j],c[p],f[i][j][p]);
ans=max(ans,f[i][j][p]);
}
}
}
printf("%lld\n",ans);
return 0;
}

edu-round-93

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Codeforces Round 664 (Div. 2) 题解 http://lemonaaaaa.com/2020/08/codeforces-round-664-div2/ 2020-08-13T03:57:02.000Z 2020-08-13T03:57:02.602Z

A. Boboniu Likes to Color Balls

题目链接

题目原文

1395A

题目大意

给出红球的数量，绿球的数量，蓝球的数量，白球的数量，并且你有一次机会将一个红球、一个绿球和一个蓝球都涂成白球。询问是否可能用这些球组成回文串。

解题思路

四种球中如果最多只有一种球为奇数，那么一定可以组成回文串（将奇数个的那种球放最中间）。另外要注意当红球、蓝球、绿球的数量都大于0才能都涂成白球（白球数量要记得+=3）。

解法

如上。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
long long T,r,g,b,w;
long long get(long long x) {if(x&1) return 1;return 0;}
int main()
{
 #ifdef lemon
freopen("A.txt","r",stdin);
#endif
scanf("%lld",&T);
while(T--)
{
scanf("%lld%lld%lld%lld",&r,&g,&b,&w);
bool flag=false;
long long temp=get(r)+get(g)+get(b)+get(w);
if(temp<=1) flag=true;
if(r&&g&&b) r--,g--,b--,w+=3;
temp=get(r)+get(g)+get(b)+get(w);
if(temp<=1) flag=true;
if(flag) printf("YES\n");
else printf("NO\n");
}
return 0;
}

B. Boboniu Plays Chess

题目链接

题目原文

1395B

题目大意

在一个n×mn \times m的棋盘上，位置(Sx,Sy)(S_x,S_y)上有一个车（只能走直线）。求一种走法遍历整个棋盘。

解题思路

因为题目没有限制每个点只能走一次，那就随意走就好了。为了方便我采用的是一行一行地走，碰到边界拐弯。

解法

如上。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int ansx[maxn],ansy[maxn],n,m,sx,sy;
bool vis[105][105];
int main()
{
 #ifdef lemon
freopen("B.txt","r",stdin);
#endif
scanf("%d%d%d%d",&n,&m,&sx,&sy);
int now=1;
ansx[now]=sx;ansy[now]=sy;
vis[sx][sy]=true;
for(int i=1;i<=m;i++)
{
if(vis[sx][i]) continue;
ansx[++now]=sx;ansy[now]=i;
}
int cnt=1;
for(int i=sx+1;i<=n;i++)
{
if(cnt&1)
{
for(int j=m;j;j--)
{
ansx[++now]=i;ansy[now]=j;
}
}
else
{
for(int j=1;j<=m;j++)
{
ansx[++now]=i;ansy[now]=j;
}
}
cnt++;
}
for(int i=sx-1;i;i--)
{
if(cnt&1)
{
for(int j=m;j;j--)
{
ansx[++now]=i;ansy[now]=j;
}
}
else
{
for(int j=1;j<=m;j++)
{
ansx[++now]=i;ansy[now]=j;
}
}
cnt++;
}
for(int i=1;i<=now;i++) printf("%d %d\n",ansx[i],ansy[i]);
return 0;
}

C. Boboniu and Bit Operations

题目链接

题目原文

1395C

题目大意

给出一个长度为n的aa数组和一个长度为m的bb数组，对于aa数组中每一个元素aia_i，在bb数组里面找到一个元素与它求按位与，得到cic_i，求c1∣c2∣…∣cnc_1|c_2| \dots |c_n的最小值。

解题思路

因为ai,  bia_i,\;b_i的范围很小，而或起来值不会超过maxmaxai,maxbjmax{max{a_i},max{b_j}}，所以我们直接从小到大枚举答案进行验证就好。时间复杂度O(n⋅m⋅29)O(n \cdot m \cdot 2^9)

解法

枚举答案，对于每一个答案ansans，判断是否存在ai  and  bja_i\;and\; b_j是ansans的子集。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int n,m,a[maxn],b[maxn];
int main()
{
 #ifdef lemon
freopen("C.txt","r",stdin);
#endif
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=m;i++) scanf("%d",&b[i]);
for(int ans=0;ans<(1<<9);ans++)
{
bool flag=true;
for(int i=1;i<=n;i++)
{
bool f=false;
for(int j=1;j<=m;j++)
{
if((a[i]&b[j]&ans)==(a[i]&b[j])) f=true;
}
if(!f)
{
flag=false;
break;
}
}
if(flag)
{
printf("%d\n",ans);
break;
}
}
return 0;
}

D. Boboniu Chats with Du

题目链接

题目原文

1395D

题目大意

给出n个值a1,a2,a3…ana_1,a_2,a_3 \dots a_n，每天你可以选择一个值（不能重复选），如果这个值大于了m，那么你在接下来d天内不能选择。现在一共有n天，求最后能得到的最大的值的和。

解题思路

朴素解法：
这明显是一个01背包，如果aia_i小于等于m，那么cost就为1；否则cost就为d+1。直接做01背包，然后你就会发现TLE了。

解法：
因为d是固定的，所以如果我们要选aia_i大于m的值，一定从最大的开始选，选aia_i小于等于m的值同理。所以我们排序后对这两部分分别做前缀和，然后我们再直接暴力枚举选多少个aia_i小于等于m的值，然后由于d是固定的，所以我们可以O(1)算出可以选多少个aia_i大于m的值，用前缀和O(1)更新答案。总复杂度O(n⋅logn)O(n \cdot logn)。

另外注意边界，同学pretest AC了，一觉醒来就WA了。

解法

前缀和+枚举

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
long long n,d,m,a[maxn],f[maxn][2],s[maxn],ans=0;
int main()
{
 #ifdef lemon
freopen("D.txt","r",stdin);
#endif
scanf("%lld%lld%lld",&n,&d,&m);
for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
sort(a+1,a+n+1);
int tot=0;
for(int i=1;i<=n;i++)
{
if(a[i]<=m) tot++;
}
for(int i=tot;i;i--) s[i]=s[i+1]+a[i];
for(int i=n;i>=tot+1;i--) s[i]=s[i+1]+a[i];
for(int i=0;i<=tot;i++)
{
int tim=(n-i+d)/(d+1);
if(n-tot<tim) continue;
int t1=tot-i+1;
if(t1>tot) t1=0;
int t2=n-tim+1;
ans=max(ans,s[t1]+s[t2]);
}
printf("%lld\n",ans);
return 0;
}

round-664

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Codeforces Round 663 (Div. 2) 题解 http://lemonaaaaa.com/2020/08/codeforces-round-663-div2/ 2020-08-10T09:48:08.000Z 2020-08-10T09:48:08.114Z

A. Suborrays

题目链接

题目原文

1391A

题目大意

如果存在一个排列，对于其任意的连续子序列pi…pjp_i \dots p_j都满足pi  OR  pi+1  OR  …  OR  pj⩾j−i+1p_i \;OR \;p_{i+1} \;OR \;\dots \;OR \;p_j \geqslant j-i+1，则称这个排列为好排列。现在请输出任意长度为n的好排列。

解题思路

显然直接按从小到大输出一定能满足要求

解法

直接输出1  2  3  4  …  n1 \; 2 \; 3 \; 4 \; \dots \; n

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n,a[maxn];
int main()
{
 #ifdef lemon
freopen("A.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(int i=1;i<=n;i++) printf("%d ",i);
/*for(int i=1;i<=n;i++)
{
for(int j=i;j<=n;j++)
{
int temp=0;
for(int p=i;p<=j;p++) temp|=p;
if(temp<j-i+1) printf("NO\n");
}
}*/
printf("\n");
}
return 0;
}

B. Fix You

题目链接

题目原文

1391B

题目大意

给出n行m列的矩阵，每个格子的值是’R’或者’D’。当移动到一个值为’R’的格子，那么会自动向右移动一格；当移动到一个值为’D’的格子，那么会自动向下移动一格。求至少修改多少个格子的值，能够满足“无论起始位置在哪，中途不能移动到边界外，并且最终都能到达最右下角的格子。

解题思路

我们发现’R’和’D’都是单调的，也就是说不会往回走，大体上的趋势一定是向右下角走的，我们只需要考虑是否会移出边界。

  • 判断第n行每一列的值是否为’R’，如果不是，则必须修改，否则会移出边界。
  • 判断第m列每一列的值是否为’D’，如果不是，则必须修改，否则会移出边界。

解法

答案即为第n行格子值为’D’的数量和第m列格子值为’R’的数量之和。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n,m,a[105][105];
char str[maxn];
int main()
{
 #ifdef lemon
freopen("B.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
scanf("%s",str+1);
for(int j=1;j<=m;j++)
if(str[j]=='R') a[i][j]=0;
else a[i][j]=1; 
}
int ans=0;
for(int i=1;i<=n-1;i++) if(!a[i][m]) ans++;
for(int i=1;i<=m-1;i++) if(a[n][i]) ans++;
printf("%d\n",ans);
}
return 0;
}

C. Cyclic Permutations

题目链接

题目原文

1391C

题目大意

语言表达能力比较差，叙述上存在困难，直接看原文吧……那两个条件就是与最近的大于它的下标连边。

解题思路

考虑i<j<ki<j<k，那么我们发现只有ai>aj<aka_i>a_j<a_k能够构成简单环（此时ii与jj连边，jj与kk连边，ii与kk连边）。因为题目只需要满足存在一个简单环就行了，那就是只需要存在一个子序列（不一定连续）满足这个条件的就可以。

最开始尝试去用排列组合的方法直接算，后来发现比较困难，有重复情况。然后后来想到可以用总方案数-不满足要求的方案数。

显然总方案数为n!，那么现在考虑不满足要求的方案数。前面说到只要存在一个小的在中间，两边存在两个比它大的就行。那么我们就考虑最大的数，也就是n的位置。

  • 将n放第1个位置，左边放0个数，右边放n-1个数，且顺序必须是从大到小，所以方案数为C(n-1,0)
  • 将n放第2个位置，左边放1个数（从n-1个数中选1个），右边放n-2个数，且两边顺序必须是从n的位置开始，向两边从大到小排列（合唱队形），所以方案数为C(n-1,1)
  • 将n放第3个位置，左边放2个数（从n-1个数中选2个），右边放n-3个数，且两边顺序必须是从n的位置开始，向两边从大到小排列（合唱队形），所以方案数为C(n-1,2)
  • 将n放第n个位置，左边放n-1个数（从n-1个数中选n-1个），右边放0个数，且两边顺序必须是从n的位置开始，向两边从大到小排列（合唱队形），所以方案数为C(n-1,n-1)

所以不合法的方案数为∑i=0n−1(n−1i)=2n−1\sum\limits_{i=0}^{n-1}\dbinom{n-1}{i} = 2^{n-1}

解法

答案即为n!−2n−1n!-2^{n-1}

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1000005;
const long long mod=1e9+7;
long long fac[maxn];
long long poww(long long x,long long k)
{
long long ans=1;
while(k)
{
if(k&1) ans=(ans*x)%mod;
x=(x*x)%mod;
k>>=1;
}
return ans;
}
int main()
{
 #ifdef lemon
freopen("C.txt","r",stdin);
#endif
long long n;
scanf("%lld",&n);
long long ans=0;
fac[0]=fac[1]=1;
for(long long i=2;i<=n;i++) fac[i]=(fac[i-1]*i)%mod;
ans=fac[n];
ans=ans-poww(2ll,n-1);
ans=(ans%mod+mod)%mod;
printf("%lld\n",ans);
return 0;
}

D. 505

题目链接

题目原文

1391D

题目大意

如果一个二进制矩阵是good的，那么它的所有边长为偶数的子矩阵中1的个数都是奇数个。
给出n行m列的矩阵，求修改多少次矩阵中的值能够使这个矩阵变为good的。如果不存在修改方案满足要求，输出-1。

解题思路

如果n=1||m=1，那么没有边长为偶数的子矩阵，输出0
如果n>=4&&m>=4，那么考虑两个连续的2x2的矩阵。如果这两个连续的2x2矩阵都满足要求，也就是说这两个连续的矩阵中1的个数都是奇数，那么这两个矩阵合起来的2x4的矩阵中1的个数就为偶数了。所以n>=4&&m>=4一定不存在合法的矩阵，也就是无论怎么修改都不能满足要求，所以输出-1

现在n就只能是2或3了，考虑动态规划。f[i][j]表示第i列的状态为j，j为3位二进制，表示这一列的3位分别为0或者1。那么我们可以枚举这一列的状态和上一列的状态进行转移。
假设这一列原来的状态是now（输入的状态），枚举的状态是j，上一列的状态是p。如果j和p满足要求，那么我们就可以进行转移，而满足的要求为这相邻的两列所有长度为偶数的子矩阵的1的个数为奇数，这里预处理一下就好（最大也就是3x2的矩阵）。

解法

转移方程f[i][j]=min(f[i][j],f[i-1][p]+(now^j)中1的个数);
now^j中1的个数即为需要修改这一列的数的个数。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
using namespace std;
const int maxn=1000005;
int n,m,ans=0x7f7f7f7f;
int a[4][maxn],f[maxn][8];
bool ok[8][8]={false};
int calc(int x)
{
int ans=0;
while(x)
{
if(x&1) ans++;
x>>=1;
}
return ans;
}
int main()
{
 #ifdef lemon
//freopen("D.txt","r",stdin);
#endif
scanf("%d%d",&n,&m);
if(n>=4&&m>=4) return printf("-1\n"),0;
if(n==1||m==1) return printf("0\n"),0;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) scanf("%1d",&a[i][j]);
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
{
int t[3];
t[0]=t[1]=t[2]=0;
for(int p=0;p<n;p++)
{
if((1<<p)&i) t[p]++;
if((1<<p)&j) t[p]++;
}
bool flag=true;
for(int p=0;p<n-1;p++)
{
if(!((t[p]+t[p+1])&1)) flag=false;
}
if(flag) ok[i][j]=true;
}
}
memset(f,0x7f7f7f7f,sizeof(f));
for(int i=0;i<8;i++) f[0][i]=0;
for(int i=1;i<=m;i++)
{
int now=a[1][i]+a[2][i]*2+a[3][i]*4;
for(int j=0;j<8;j++)
{
for(int p=0;p<8;p++)
{
if(!ok[j][p]) continue;
f[i][j]=min(f[i][j],f[i-1][p]+calc(now^j));
}
}
}
for(int i=0;i<8;i++) ans=min(ans,f[m][i]);
printf("%d\n",ans);
return 0;
}

round-663

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Codeforces Round 660 (Div. 2) 题解 http://lemonaaaaa.com/2020/07/codeforces-round-660-div2/ 2020-07-31T02:54:10.000Z 2020-08-10T09:41:51.879Z

A. Captain Flint and Crew Recruitment

题目链接

题目原文

1388A

题目大意

如果一个数 xx 能够表示成两个不同质数的乘积，那我们就称 xx 为nearly prime。现给出 nn ，求 nn 能不能分解成 44 个不同数的和，其中 33 个是nearly prime？

解题思路

先考虑要求的3个nearly prime，因为要3个不同的数，所以我们需要所有的数尽量小，否则和会超出n。最开始我的想法是直接取6、10、14、n-30，过样例就能发现n-30与前面三个数可能会重复，不满足题意。那直接考虑枚举哪三个质数，只要有不重复的并且和小于n，那就能满足题意。

解法

处理出一部分两两质数的积，枚举取哪三个质数，看n-三个质数是否大于0并且不与三个质数相等。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n;
int num[10]={0,2,3,5,7,11,13},a[maxn],tot=0;
int main()
{
#ifdef lemon
freopen("a.txt","r",stdin);
#endif
scanf("%d",&T);
for(int i=1;i<=6;i++)
for(int j=i+1;j<=6;j++)
a[++tot]=num[i]*num[j];
sort(a+1,a+tot+1);
while(T--)
{
scanf("%d",&n);
bool flag=false;
for(int i=1;i<=tot;i++)
{
for(int j=i+1;j<=tot;j++)
{
for(int k=j+1;k<=tot;k++)
{
if(flag) break;
int temp=n-a[i]-a[j]-a[k];
if(temp<=0) break;
if(temp==a[i]||temp==a[j]||temp==a[k]) break;
flag=true;
printf("YES\n%d %d %d %d\n",a[i],a[j],a[k],temp);
}
}
}
if(!flag) printf("NO\n");
}
return 0;
}

B. Captain Flint and a Long Voyage

题目链接

题目原文

1388B

题目大意

给出一个 nn ，你需要确定一个nn位的十进制数xx，将xx每一位写成二进制形式（要去掉前导零），再删去二进制的后nn位，使得最后剩下的二进制最大。求xx的最小可能值。

解题思路

根据样例以及初步分析，因为不能有前导零，并且二进制数必须要长。一位十进制数最多能表示成4位二进制数，分别是9(1001)和8(1000)。这样就很显然了，二进制前面n*3位全部是1001，后面n位全部是1000。

解法

确定一下多少个9，剩下补8。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
int T,n;
int main()
{
#ifdef lemon
freopen("B.txt","r",stdin);
#endif
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
int res=n%4;
int t=n-n/4;
if(res) t--;
for(int i=1;i<=t;i++) printf("9");
for(int i=t+1;i<=n;i++) printf("8");
printf("\n");
}
return 0;
}

C. Uncle Bogdan and Country Happiness

题目链接

题目原文

1388C

题目大意

给出一棵树，每个节点给出人数、不一定准确的心情值。每个人从1号节点出发，在路上可能有些人心情会从good变成bad。每个人沿着最短路径回到自己的节点，求每个节点给出的心情值是否可能都是准确的。（心情值=good人数-bad人数）

解题思路

直接dfs就行。

解法

对每一个点求出它和它的子树中的人数，然后根据这个人数和预估心情值就可以算出多少个人是好心情，多少个人是坏心情。

如果好心情人数算出来是以下情况，那必然不合法：

  • 是负数
  • 是小数
  • 比子树总人数大
  • 比子树的好心情人数少

就这样就过了。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200005;
struct node
{
int to,next;
} edge[maxn<<1];
int head[maxn],k=0;
void add(int u,int v)
{
edge[++k].to=v;
edge[k].next=head[u];
head[u]=k;
}
int n,T;
long long m,p[maxn],h[maxn],good[maxn],bad[maxn],size[maxn];
bool flag=false;
void dfs(int x,int fa)
{
size[x]=p[x];
for(int i=head[x];i;i=edge[i].next)
{
if(edge[i].to==fa) continue;
dfs(edge[i].to,x);
size[x]+=size[edge[i].to];
}
good[x]=size[x]+h[x];
if((good[x]&1)||good[x]<0) flag=true;
good[x]>>=1;
bad[x]=size[x]-good[x];
if(bad[x]<0) flag=true;
int total_good=0;
for(int i=head[x];i;i=edge[i].next)
{
if(edge[i].to==fa) continue;
total_good+=good[edge[i].to];
}
if(good[x]<total_good) flag=true;
}
int main()
{
#ifdef lemon
freopen("C.txt","r",stdin);
#endif
memset(head,0,sizeof(head));
memset(good,0,sizeof(good));
memset(bad,0,sizeof(bad));
memset(size,0,sizeof(size));
scanf("%d",&T);
while(T--)
{
k=0;flag=false;
scanf("%d%lld",&n,&m);
for(int i=1;i<=n;i++) scanf("%lld",&p[i]);
for(int i=1;i<=n;i++) scanf("%lld",&h[i]);
for(int i=1,x,y;i<n;i++)
{
scanf("%d%d",&x,&y);
add(x,y);add(y,x);
}
dfs(1,1);
if(flag) printf("NO\n");
else printf("YES\n");
for(int i=1;i<=n;i++) head[i]=good[i]=bad[i]=size[i]=0;
}
return 0;
}

D. Captain Flint and Treasure

题目链接

题目原文

1388D

题目大意

给出长度为n的a数组和b数组，一共操作n次（每个位置必须操作一次），若第i次选定位置i，则ans+=a[i]，并且a[b[i]]+=a[i]，确定一个操作顺序使得取出的ans最大，并输出操作顺序。

解题思路

题目中保证了不会出现环，并且a[b[i]]+=a[i]是单向操作，自然而然地就想到了有向图的拓扑排序，直接做DAG dp就好。

解法

从度数为0的点开始，如果当前值大于0，那么加到下一个点上就可以使下一个点更优（意义为先选这个点）；如果当前值小于0，那么加到下一个点会使结果更差，就不加（意义为先选下一个点，后选这个点）。最后输出方案按照拓扑序输出，见代码，应该很好理解。

代码

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
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=200005;
struct node
{
int to,next;
} edge[maxn<<1];
int k=0,head[maxn];
void add(int u,int v)
{
edge[++k].to=v;
edge[k].next=head[u];
head[u]=k;
}
int n,a[maxn],degree[maxn],rd[maxn],p[maxn],tot=0;
long long ans=0,f[maxn];
void toposort()
{
queue<int> q;
for(int i=1;i<=n;i++)
if(!rd[i]) q.push(i);
while(!q.empty())
{
int x=q.front();q.pop();
p[++tot]=x;
ans+=f[x];
for(int i=head[x];i;i=edge[i].next)
{
f[edge[i].to]+=max(0ll,f[x]);
rd[edge[i].to]--;
if(!rd[edge[i].to]) q.push(edge[i].to);
}
}
}
int main()
{
memset(f,0,sizeof(f));
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1,b;i<=n;i++)
{
scanf("%d",&b);
if(b==-1) continue;
add(i,b);
rd[b]++;
degree[i]++;
degree[b]++;
}
for(int i=1;i<=n;i++) f[i]=(long long)a[i];
toposort();
printf("%lld\n",ans);
for(int i=1;i<=n;i++) if(f[p[i]]>=0) printf("%d ",p[i]);
for(int i=n;i;i--) if(f[p[i]]<0) printf("%d ",p[i]);
return 0;
}

round-660

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla OpenCV 3 第三章 学习笔记 http://lemonaaaaa.com/2020/06/opencv3-3/ 2020-06-27T09:40:14.000Z 2020-06-27T09:40:14.758Z
HighGUI 图形用户界面初步

图像的载入、显示和输出到文件

OpenCV 的命名空间

using namespace cv;

Mat 类

Mat 类是用于保存图像以及其他矩阵数据的数据结构，默认情况下尺寸为0。我们也可以指定其初始尺寸。
如cv::Mat pic(320,640,cv""Scalar(100);。

读取图片文件：Mat scrImage = imread("src.jpg");

图像载入（imread()函数）

函数原型：Mat imread( const String& filename, int flags = IMREAD_COLOR );

  • 第一个参数，对应所需要载入的图片路径名
    在Windows操作系统下，支持的文件格式如下：
    1. Windows位图：bmp, dib ；
    2. JPEG 文件： jpeg, jpg, jpe ；
    3. JPEG 2000 文件：jp2 ；
    4. PNG文件：png ；
    5. 便携文件格式： pbm, pgm, ppm ；
    6. Sun rasters 光栅文件： sr, ras ；
    7. TIFF 文件： tiff, tif 。
  • 第二个参数，为载入标识，它指定一个加载图像的颜色类型，由函数原型可以看到它自带默认值为 IMREAD_COLOR (值为1)，所以在调用时可以忽略这个参数。这个参数在OpenCV中标识图像格式的枚举体中取值。
    枚举的定义如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
enum ImreadModes {
       IMREAD_UNCHANGED            = -1, //!< If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). Ignore EXIF orientation.
       IMREAD_GRAYSCALE            = 0,  //!< If set, always convert image to the single channel grayscale image (codec internal conversion).
       IMREAD_COLOR                = 1,  //!< If set, always convert image to the 3 channel BGR color image.
       IMREAD_ANYDEPTH             = 2,  //!< If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit.
       IMREAD_ANYCOLOR             = 4,  //!< If set, the image is read in any possible color format.
       IMREAD_LOAD_GDAL            = 8,  //!< If set, use the gdal driver for loading the image.
       IMREAD_REDUCED_GRAYSCALE_2  = 16, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/2.
       IMREAD_REDUCED_COLOR_2      = 17, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/2.
       IMREAD_REDUCED_GRAYSCALE_4  = 32, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/4.
       IMREAD_REDUCED_COLOR_4      = 33, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/4.
       IMREAD_REDUCED_GRAYSCALE_8  = 64, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/8.
       IMREAD_REDUCED_COLOR_8      = 65, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/8.
       IMREAD_IGNORE_ORIENTATION   = 128 //!< If set, do not rotate the image according to EXIF's orientation flag.
     };

所以默认载入三通道的彩色图像，其他参数用途在注释中也已明确。

  • flags > 0 : 返回一个3通道的彩色图像
  • flags = 0 : 返回灰度图像
  • flags < 0 : 返回包含Alpha通道的加载图像

Mat image0=imread("1.jpg", 2 | 4); 载入无损的源图像
Mat image1=imread("1.jpg", 0); 载入灰度图
Mat image2=imread("1.jpg", 199); 载入3通道的彩色图像

图像显示（imshow()函数）

imshow()函数用于在指定的窗口中显示一幅图像。
原型：void imshow(const string& winname, InputArray mat)

  • 第一个参数：填需要显示的窗口标识名称。
  • 第二个参数：填需要显示的图像。

如果窗口是用 CV_WINDOW_AUTOSIZE （默认值）标志创建的，那么显示图像原始大小。否则，将根据图像的深度进行缩放以适合窗口。

创建窗口（namedWindow()函数）

namedWindow用于创建一个窗口。如果是简单地进行图片显示，则不用这个函数创建窗口。但如果需要在显示窗口之前就用到窗口名时，就需要这个函数先创建出窗口，显式地规定窗口名称，比如指定滑动条依附在某个窗口上。

函数原型：void namedWindow(const String& winname, int flags = WINDOW_AUTOSIZE);

  • 第一个参数，填写被用作窗口的标识符的窗口名称
  • 第二个参数，窗口的标识，其enum定义如下：
1
2
3
4
5
6
7
8
9
10
11
enum WindowFlags {
       WINDOW_NORMAL     = 0x00000000, //!< the user can resize the window (no constraint) / also use to switch a fullscreen window to a normal size.
       WINDOW_AUTOSIZE   = 0x00000001, //!< the user cannot resize the window, the size is constrainted by the image displayed.
       WINDOW_OPENGL     = 0x00001000, //!< window with opengl support.

       WINDOW_FULLSCREEN = 1,          //!< change the window to fullscreen.
       WINDOW_FREERATIO  = 0x00000100, //!< the image expends as much as it can (no ratio constraint).
       WINDOW_KEEPRATIO  = 0x00000000, //!< the ratio of the image is respected.
       WINDOW_GUI_EXPANDED=0x00000000, //!< status bar and tool bar
       WINDOW_GUI_NORMAL = 0x00000010, //!< old fashious way
    };

输出图像到文件（imwrite()函数）

imwrite()函数用于输出图像到文件。

函数原型：bool imwrite( const String& filename, InputArray img, const std::vector<int>& params = std::vector<int>());

  • 第一个参数，填需要写入的文件名，注意要带上后缀。
  • 第二个参数，一般填一个Mat类型的图像数据。
  • 第三个参数，标识为特定格式保存的参数编码，有默认值vector，一般不用填写。如果要填写，需要了解以下内容：
    1. 对于 JPEG 格式的图片，这个参数表示从0到100的图片质量，默认为95；
    2. 对于 PNG 格式的图片，这个参数表示压缩级别，从0到9.较高的值意味着更小的尺寸和更长的压缩时间，默认值为3；
    3. 对于 PPM, PGM 或 PBM 格式的图片，这个参数表示一个二进制格式标志，取值为0或1，默认值为1。

imwrite函数可保存的文件格式 和imread函数可读取格式相同。

创建和使用滑动条

滑动条可以动态调节参数，它依附于窗口而存在。

此外，OpenCV没有实现按钮的功能，所以很多时候，可以用仅含0和1的滑动条来实现按钮的按下和弹起效果。

创建滑动条（createTrackbar()函数）

此函数往往会和一个回调函数配合起来使用。

函数原型：int createTrackbar(const String& trackbarname, const String& winname,int* value, int count, TrackbarCallback onChange = 0, void* userdata = 0);

  • 第一个参数：轨迹条的名字。
  • 第二个参数：窗口的名字，表示这个轨迹条会依附到哪个窗口上（对应前面用namedWindow()创建的窗口）。
  • 第三个参数：一个指向整型的指针，表示滑块的位置。在创建时，滑块的初始位置就是该变量当前的值。
  • 第四个参数：表示滑块可以达到的最大位置的值。滑块最小位置的值始终为0。
  • 第五个参数：一个指向回调函数的指针，默认值为0。每次滑块位置改变时，这个函数都会进行回调。
    回调函数的原型必须为void XXXX(int, void*);，其中第一个参数是轨迹条的位置，第二个参数是用户数据（见下面的第六个参数）。如果回调是NULL指针，则表示没有回调函数的调用，仅第三个参数value有变化。
  • 第六个参数：void*类型的userdata，默认值为0。这个参数是用户传给回调函数的数据，用来处理轨迹条事件。如果使用的第三个参数的value是全局变量的话，完全可以不用管这个userdata参数。

createTrackbar函数要指定回调函数onChange，在轨迹条位置改变的时候来调用这个回调函数，并且创建的轨迹条显示在指定的winname所代表的窗口上。

示例代码：（Code by 毛星云）

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
//--------------------------------------【程序说明】-------------------------------------------
//程序说明：《OpenCV3编程入门》OpenCV2版书本配套示例程序17
//程序描述：为程序界面添加滑动条
//开发测试所用IDE版本：Visual Studio 2010
//开发测试所用OpenCV版本：3.0 beta
//2014年11月 Created by @浅墨_毛星云
//2014年12月 Revised by @浅墨_毛星云
//------------------------------------------------------------------------------------------------


//---------------------------------【头文件、命名空间包含部分】-------------------------------
//描述：包含程序所使用的头文件和命名空间
//-------------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace cv;
#pragma warning(disable:4996)
//-----------------------------------【宏定义部分】-------------------------------------------- 
//  描述：定义一些辅助宏 
//------------------------------------------------------------------------------------------------ 
#define WINDOW_NAME "【滑动条的创建&线性混合示例】"        //为窗口标题定义的宏 


//-----------------------------------【全局变量声明部分】--------------------------------------
//描述：全局变量声明
//-----------------------------------------------------------------------------------------------
const int g_nMaxAlphaValue = 100;//Alpha值的最大值
int g_nAlphaValueSlider;//滑动条对应的变量
double g_dAlphaValue;
double g_dBetaValue;

//声明存储图像的变量
Mat g_srcImage1;
Mat g_srcImage2;
Mat g_dstImage;


//-----------------------------------【on_Trackbar( )函数】--------------------------------
//描述：响应滑动条的回调函数
//------------------------------------------------------------------------------------------
void on_Trackbar(int, void*)
{
//求出当前alpha值相对于最大值的比例
g_dAlphaValue = (double)g_nAlphaValueSlider / g_nMaxAlphaValue;
//则beta值为1减去alpha值
g_dBetaValue = (1.0 - g_dAlphaValue);

//根据alpha和beta值进行线性混合
addWeighted(g_srcImage1, g_dAlphaValue, g_srcImage2, g_dBetaValue, 0.0, g_dstImage);

//显示效果图
imshow(WINDOW_NAME, g_dstImage);
}


//-----------------------------【ShowHelpText( )函数】--------------------------------------
//描述：输出帮助信息
//-------------------------------------------------------------------------------------------------
//-----------------------------------【ShowHelpText( )函数】----------------------------------
//描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
void ShowHelpText()
{
//输出欢迎信息和OpenCV版本
printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书！\n");
printf("\n\n\t\t\t此为本书OpenCV3版的第17个配套示例程序\n");
printf("\n\n\t\t\t   当前使用的OpenCV版本为：" CV_VERSION);
printf("\n\n  ----------------------------------------------------------------------------\n");
}


//--------------------------------------【main( )函数】-----------------------------------------
//描述：控制台应用程序的入口函数，我们的程序从这里开始执行
//-----------------------------------------------------------------------------------------------
int main(int argc, char** argv)
{

//显示帮助信息
ShowHelpText();

//加载图像 (两图像的尺寸需相同)
g_srcImage1 = imread("1.jpg");
g_srcImage2 = imread("2.jpg");
if (!g_srcImage1.data) { printf("读取第一幅图片错误，请确定目录下是否有imread函数指定图片存在~！ \n"); return -1; }
if (!g_srcImage2.data) { printf("读取第二幅图片错误，请确定目录下是否有imread函数指定图片存在~！\n"); return -1; }

//设置滑动条初值为70
g_nAlphaValueSlider = 70;

//创建窗体
namedWindow(WINDOW_NAME, 1);

//在创建的窗体中创建一个滑动条控件
char TrackbarName[50];
sprintf(TrackbarName, "透明值 %d", g_nMaxAlphaValue);

createTrackbar(TrackbarName, WINDOW_NAME, &g_nAlphaValueSlider, g_nMaxAlphaValue, on_Trackbar);

//结果在回调函数中显示
on_Trackbar(g_nAlphaValueSlider, 0);

//按任意键退出
waitKey(0);

return 0;
}

运行效果：（分别为透明度0%、50%、100%的情况）
trackbar2trackbar1trackbar3

获取当前轨迹条的位置（getTrackbarPos()函数）

函数原型：int getTrackbarPos(const String& trackbarname, const String& winname);

  • 第一个参数：表示轨迹条的名字。
  • 第二个参数：表示轨迹条的父窗口的名称。

鼠标操作

和创建滑动条的函数类似，指定鼠标操作消息回调函数的函数为setMouseCallback

函数原型：setMouseCallback(const String& winname, MouseCallback onMouse, void* userdata = 0);

  • 第一个参数：窗口的名字。
  • 第二个参数：指定窗口里每次鼠标事件发生的时候，被调用的函数指针。
    这个函数的原型大概是void Foo(int event, int x, int y, int flags, void *param);其中event变量enum值的定义见后文，x和y是鼠标指针在图像坐标系中的坐标值，flag是的enum值的定义见后文。param是用户定义的传递到setMouseCallback函数调用的参数。
  • 第三个参数：用户定义的传递到回调函数的参数，默认值为0。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//! Mouse Events see cv::MouseCallback
enum MouseEventTypes {
       EVENT_MOUSEMOVE      = 0, //!< indicates that the mouse pointer has moved over the window.
       EVENT_LBUTTONDOWN    = 1, //!< indicates that the left mouse button is pressed.
       EVENT_RBUTTONDOWN    = 2, //!< indicates that the right mouse button is pressed.
       EVENT_MBUTTONDOWN    = 3, //!< indicates that the middle mouse button is pressed.
       EVENT_LBUTTONUP      = 4, //!< indicates that left mouse button is released.
       EVENT_RBUTTONUP      = 5, //!< indicates that right mouse button is released.
       EVENT_MBUTTONUP      = 6, //!< indicates that middle mouse button is released.
       EVENT_LBUTTONDBLCLK  = 7, //!< indicates that left mouse button is double clicked.
       EVENT_RBUTTONDBLCLK  = 8, //!< indicates that right mouse button is double clicked.
       EVENT_MBUTTONDBLCLK  = 9, //!< indicates that middle mouse button is double clicked.
       EVENT_MOUSEWHEEL     = 10,//!< positive and negative values mean forward and backward scrolling, respectively.
       EVENT_MOUSEHWHEEL    = 11 //!< positive and negative values mean right and left scrolling, respectively.
     };
1
2
3
4
5
6
7
8
9
//! Mouse Event Flags see cv::MouseCallback
enum MouseEventFlags {
       EVENT_FLAG_LBUTTON   = 1, //!< indicates that the left mouse button is down.
       EVENT_FLAG_RBUTTON   = 2, //!< indicates that the right mouse button is down.
       EVENT_FLAG_MBUTTON   = 4, //!< indicates that the middle mouse button is down.
       EVENT_FLAG_CTRLKEY   = 8, //!< indicates that CTRL Key is pressed.
       EVENT_FLAG_SHIFTKEY  = 16,//!< indicates that SHIFT Key is pressed.
       EVENT_FLAG_ALTKEY    = 32 //!< indicates that ALT Key is pressed.
     };

示例代码：（Code by 毛星云）

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
144
145
146
147
148
149
150
//--------------------------------------【程序说明】-------------------------------------------
//程序说明：《OpenCV3编程入门》OpenCV2版书本配套示例程序18
//程序描述：HelloOpenCV
//开发测试所用IDE版本：Visual Studio 2010
//开发测试所用OpenCV版本：3.0 beta
//2014年11月 Created by @浅墨_毛星云
//2014年12月 Revised by @浅墨_毛星云
//------------------------------------------------------------------------------------------------

//---------------------------------【头文件、命名空间包含部分】-----------------------------
//描述：包含程序所使用的头文件和命名空间
//-------------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
using namespace cv;

//-----------------------------------【宏定义部分】--------------------------------------------
//  描述：定义一些辅助宏 
//------------------------------------------------------------------------------------------------ 
#define WINDOW_NAME "【程序窗口】"        //为窗口标题定义的宏 


//-----------------------------------【全局函数声明部分】------------------------------------
//描述：全局函数的声明
//------------------------------------------------------------------------------------------------
void on_MouseHandle(int event, int x, int y, int flags, void* param);
void DrawRectangle(cv::Mat& img, cv::Rect box);
void ShowHelpText();

//-----------------------------------【全局变量声明部分】-----------------------------------
//描述：全局变量的声明
//-----------------------------------------------------------------------------------------------
Rect g_rectangle;
bool g_bDrawingBox = false;//是否进行绘制
RNG g_rng(12345);



//-----------------------------------【main( )函数】--------------------------------------------
//描述：控制台应用程序的入口函数，我们的程序从这里开始执行
//-------------------------------------------------------------------------------------------------
int main(int argc, char** argv)
{
//【0】改变console字体颜色
system("color 9F");

//【0】显示欢迎和帮助文字
ShowHelpText();

//【1】准备参数
g_rectangle = Rect(-1, -1, 0, 0);
Mat srcImage(600, 800, CV_8UC3), tempImage;
srcImage.copyTo(tempImage);
g_rectangle = Rect(-1, -1, 0, 0);
srcImage = Scalar::all(0);

//【2】设置鼠标操作回调函数
namedWindow(WINDOW_NAME);
setMouseCallback(WINDOW_NAME, on_MouseHandle, (void*)&srcImage);

//【3】程序主循环，当进行绘制的标识符为真时，进行绘制
while (1)
{
srcImage.copyTo(tempImage);//拷贝源图到临时变量
if (g_bDrawingBox) DrawRectangle(tempImage, g_rectangle);//当进行绘制的标识符为真，则进行绘制
imshow(WINDOW_NAME, tempImage);
if (waitKey(10) == 27) break;//按下ESC键，程序退出
}
return 0;
}



//--------------------------------【on_MouseHandle( )函数】-----------------------------
//描述：鼠标回调函数，根据不同的鼠标事件进行不同的操作
//-----------------------------------------------------------------------------------------------
void on_MouseHandle(int event, int x, int y, int flags, void* param)
{

Mat& image = *(cv::Mat*) param;
switch (event)
{
//鼠标移动消息
case EVENT_MOUSEMOVE:
{
if (g_bDrawingBox)//如果是否进行绘制的标识符为真，则记录下长和宽到RECT型变量中
{
g_rectangle.width = x - g_rectangle.x;
g_rectangle.height = y - g_rectangle.y;
}
}
break;

//左键按下消息
case EVENT_LBUTTONDOWN:
{
g_bDrawingBox = true;
g_rectangle = Rect(x, y, 0, 0);//记录起始点
}
break;

//左键抬起消息
case EVENT_LBUTTONUP:
{
g_bDrawingBox = false;//置标识符为false
//对宽和高小于0的处理
if (g_rectangle.width < 0)
{
g_rectangle.x += g_rectangle.width;
g_rectangle.width *= -1;
}

if (g_rectangle.height < 0)
{
g_rectangle.y += g_rectangle.height;
g_rectangle.height *= -1;
}
//调用函数进行绘制
DrawRectangle(image, g_rectangle);
}
break;

}
}



//-----------------------------------【DrawRectangle( )函数】------------------------------
//描述：自定义的矩形绘制函数
//-----------------------------------------------------------------------------------------------
void DrawRectangle(cv::Mat& img, cv::Rect box)
{
cv::rectangle(img, box.tl(), box.br(), cv::Scalar(g_rng.uniform(0, 255), g_rng.uniform(0, 255), g_rng.uniform(0, 255)));//随机颜色
}


//-----------------------------------【ShowHelpText( )函数】-----------------------------
//          描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
void ShowHelpText()
{
//输出欢迎信息和OpenCV版本
printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书！\n");
printf("\n\n\t\t\t此为本书OpenCV3版的第18个配套示例程序\n");
printf("\n\n\t\t\t   当前使用的OpenCV版本为：" CV_VERSION);
printf("\n\n  ----------------------------------------------------------------------------\n");
//输出一些帮助信息
printf("\n\n\n\t欢迎来到【鼠标交互演示】示例程序\n");
printf("\n\n\t请在窗口中点击鼠标左键并拖动以绘制矩形\n");

}

运行结果：
mouse

总结

前面几张比较基础，学得比较细致。虽然现在还在入门，但是已经学到了许多其他的知识，比如C++的一些以前没有理解或者不知道的操作。学习，重在坚持，希望能够坚持下去。后面要看算法了，可能花在这上面的时间不会太多。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla OpenCV 3 第一章 学习笔记 http://lemonaaaaa.com/2020/06/opencv3-1/ 2020-06-26T07:52:52.000Z 2020-06-26T08:05:39.907Z

前言

如果能够生活，那就好好生活。

如果能够学习，那就好好学习。

永远怀揣梦想，永远不要放弃。

简述

这一章主要是配置 OpenCV 和展示了一些示例，先敲出来感受一下。

与书配套的的 GitHub 仓库:https://github.com/QianMo/OpenCV3-Intro-Book-Src

图像腐蚀

用图像中的暗色部分“腐蚀掉”图像中的高亮部分。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <opencv2\opencv.hpp>  

using namespace cv;

int main()
{
Mat srcImage = imread("2.jpg");  //载入原图
imshow("src", srcImage);  //显示原图
Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));  //进行腐蚀操作
Mat dstImage;
erode(srcImage, dstImage, element);  //显示效果图
imshow("output", dstImage);
waitKey(0);
return 0;
}

camera_canny

摄像头操作

通过摄像头调用来配合canny边缘检测，得到canny边缘检测并高斯模糊后的摄像头采集视频

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <opencv2\opencv.hpp>  
using namespace cv;

int main()
{
VideoCapture capture(0);
Mat edges;
while (1)
{
Mat frame;  //用于存储每一帧的图像
capture >> frame;  //读取当前帧
cvtColor(frame, edges, COLOR_BGR2GRAY);  //转换BGR彩色图为灰度图像
blur(edges, edges, Size(7, 7));  //进行模糊，使用3x3内核降噪
Canny(edges, edges, 0, 30, 3);  //进行canny边缘检测并显示
imshow("output", edges);  //显示当前帧
if (waitKey(30) >= 0) break;  //延时30ms
}
return 0;
}

camera_canny

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 雨下整夜 http://lemonaaaaa.com/2020/05/music-2020520/ 2020-05-20T15:46:02.000Z 2020-05-20T15:57:28.190Z 
        
        
窗外的麻雀在电线杆上多嘴
你说这一句很有夏天的感觉
手中的铅笔在纸上来来回回
我用几行字形容你是我的谁
秋刀鱼的滋味猫跟你都想了解
初恋的香味就这样被我们寻回
那温暖的阳光像刚摘的鲜艳草莓
你说你舍不得吃掉这一种感觉
雨下整夜我的爱溢出就像雨水
院子落叶跟我的思念厚厚一叠
几句是非也无法将我的热情冷却
你出现在我诗的每一页
雨下整夜我的爱溢出就像雨水
窗台蝴蝶像诗里纷飞的美丽章节
我接着写
把永远爱你写进诗的结尾
你是我唯一想要的了解
雨下整夜我的爱溢出就像雨水
院子落叶跟我的思念厚厚一叠
几句是非也无法将我的热情冷却
你出现在我诗的每一页
那饱满的稻穗幸福了这个季节
而你的脸颊像田里熟透的蕃茄
你突然对我说七里香的名字很美
我此刻却只想亲吻你倔强的嘴
雨下整夜我的爱溢出就像雨水
院子落叶跟我的思念厚厚一叠
几句是非也无法将我的热情冷却
你出现在我诗的每一页
整夜我的爱溢出就像雨水
窗台蝴蝶像诗里纷飞的美丽章节
我接着写
把永远爱你写进诗的结尾
你是我唯一想要的了解
]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla
      
    
    
    
    
      
    
      
    
    
      
    
      
    
  
  
  
    git pull 之后本地恢复到之前版本
    
    http://lemonaaaaa.com/2020/05/git-pull-recall/
    2020-05-10T03:08:59.000Z
    2020-05-10T03:18:55.322Z
    
    
 第一步
git reflog 查看历史变更记录
 第二步
git reset --hard HEAD@{n} 回退到引用位置n
]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla
      
    
    
    
    
      
    
      
    
    
      
    
      
    
      
    
  
  
  
    计算机系统基础 知识点梳理
    
    http://lemonaaaaa.com/2020/05/introduction-to-computer-systems/
    2020-05-02T15:41:15.000Z
    2020-05-04T04:05:58.602Z
    
    
计算机系统基础 第一章到第三章 知识点梳理
        
            
        
        
 
第一章 系统概述
1-1
这张图说的真的好，虽然和知识没有什么关系，最初看到也觉得没什么，但是学了大半学期再倒回来看这些话，我认为是十分正确的。同样的代码，不同的写法，效率可能差上成百上千倍。然后就是特别是通过bomb lab，做了之后我对整个C语言的理解都不一样了。知其然，更要知其所以然，可能这就是系统的魅力吧！
 为什么要学习计算机系统
  • 为了编程序的时候少出错（逻辑性，准确性，内存溢出等）
  • 为了在程序出错的时候很快找到出错的地方（gdb调试，或者直接查看汇编指令，找到错误）
  • 为了明白程序是怎样在计算机上执行的（利用程序执行的原理，可以编写出更快的程序）
  • 作为计算机专业的同学应该具有的底层意识。
 计算机基本工作原理
一些基本的概念。
 冯·诺依曼体系
冯·诺依曼结构最重要的思想是存储程序。
  1. 计算机的基本部件：控制器、存储器、运算器、输入设备和输出设备。（计导必考题目！！）
  2. 存储器不仅能存放数据，而且也能存放指令，形式上两者 没有区别，但计算机应能区分数据还是指令。
  3. 控制器应能自动取出指令来执行。
  4. 运算器应能进行加/减/乘/除四种基本算术运算，并且也 能进行一些逻辑运算和附加运算。
  5. 操作人员可以通过输入设备、输出设备和主机进行通信。
  6. 内部以二进制表示指令和数据。每条指令由操作码和地址码两部分组成。操作码指出操作类型，地址码指出操作数的地址。由一串指令组成程序。
  7. 采用“存储程序”工作方式。
 计算机是如何工作的
1-1-2
图中的部件解释：
  • CPU：中央处理器
  • PC：程序计数器
  • MAR：存储器地址寄存器
  • ALU：算术逻辑部件
  • IR：指令寄存器
  • MDR：存储器数据寄存器
  • GPRs：通用寄存器组（由若干通用寄存器组成，早期就是累加器）
程序执行前：
数据和指令事先存放在存储器中，每条指令和每个数据都有地址，指令按序存放，指令由OP、ADDR字段组成，程序起始地址置PC
注意：
  1. 程序启动前，指令和数据都存放在存储器中，形式上没有差别，都是0/1序列
  2. 采用”存储程序“工作方式：程序由指令组成，程序被启动后，计算机能自动取出一条一条指令执行，在执行过程中无需人的干预。
  3. 指令中需要给出的信息：
    (1) 操作性质（操作码）
    (2) 源操作数1 或/和源操作数2（立即数、寄存器编号、存储地址）
    (3) 目的操作数地址（寄存器编号、存储地址）
开始执行程序：
  • 第一步：根据PC取指令
  • 第二步：指令译码
  • 第三步：取操作数
  • 第四步：指令执行
  • 第五步：回写结果
  • 第六步：修改PC的值
  • 继续执行下一条指令
 程序的开发和执行
 机器语言
机器语言就是0/1代码啦！在计算机科学导论中我们也动手写了图灵机的操作（虽然我们班好像没有要求，但因为某种原因我写过几份，现在回想起来也挺有趣的）。感觉机器语言和图灵机有点类似，通过读写纸带和打孔之类的。
但是，如果要修改，或者打错了，那么就要从头再来，非常地崩溃，可读性也非常差。
 汇编语言
  • 用助记符表示操作码
  • 用标号表示位置
  • 用助记符表示寄存器
优点：
  • 不会因为增减指令而需要修改其他指令
  • 不需记忆指令编码，编写方便
  • 可读性比机器语言强
1-2-2
 高级语言
  • 它们与具体机器结构无关
  • 面向算法描述，比机器级语言描述能力强得多
  • 高级语言中一条语句对应几条、几十条甚至几百条指令
  • 有“面向过程”和“面向对象”的语言之分
  • 处理逻辑分为三种结构：顺序结构、选择结构、循环结构
  • 有两种转换方式：“编译”和“解释” 
    • 编译程序(Complier)：将高级语言源程序转换为机器级目标程序，执行时只要启动目标程序即可，比如C++、C、Java等
    • 解释程序(Interpreter )：将高级语言语句逐条翻译成机器指令并立即执行，不生成目标文件，比如Python等
 源代码的处理
1-2-3-1
1-2-3-2
 计算机的层次结构
1-3-1
1-3-2
 计算机性能的定义
这部分在书上有，mooc上没有。其主要指标为吞吐率(throughput)和响应时间(response time)
  1. 吞吐率：在单位时间内所完成的工作量。
  2. 响应时间：从作业提交开始到作业完成所用的时间。
 
第二章 数据的机器级表示与处理
 数制和编码
  • 十进制、二进制、十六进制、八进制……
  • 定/浮点表示
 数制
  1. 十进制(Decimal)：结尾加D表示。
  2. 二进制(Binary)：结尾加B表示。
  3. 八进制(Octal)：结尾加O表示。
  4. 十六进制(Hexadecimal)：结尾加H表示或者前缀加0x表示。
进制转换：
整数部分：除基取余，上左下右
小数部分：乘基取整，上左下右
 定点数和浮点数
计算机中只能通过约定小数点的位置来表示小数点
  • 小数点位置约定在固定位置的数称为定点数
  • 小数点位置约定为可浮动的数称为浮点数
实数的定义：X=(−1)s×M×REX=(-1)^s \times M \times R^E
其中SS取值为00或者11，用来决定数XX的符号；MM是尾数，EE是阶/指数。RR是基数。
 定点数的编码
原码、补码、移码、反码
  1. 原码：最高位的00/11表示正负，数值部分不变。但是缺点有：00的表示不唯一，不利于编程；加减运算方式不统一；对硬件设计的要求较高；特别是当a<ba<b时候，实现a−ba-b比较困难。
  2. 补码（从50年代以来整数采用的编码方式）：[X]补=2n+X[X]_\text{补}=2^n + X。同时补码实现了加和减的统一。
    结论一：一个负数的补码等于模减该负数的绝对值
    结论二：对于某一确定的模，某数减去小于模的另一数，总可以用该数加上另一数负数的补码来代替实现了加法和减法的统一。 
    变形补码：采用双符号位存放可能溢出的中间结果。
    负数的补码的简便求法：从右至左遇到的第一个11的前面各位取反（不含这个11）
  3. 移码：将每一个数值加上一个偏置常数bias。2-1-3-1
  4. 反码：直接将二进制按位取反，一般没什么用。
 C语言中的数
 整数
2-2-1-1
其中整数类型分为带符号整数和无符号整数。
2-2-1-2
整数表示比较简单，大概熟悉C语言的程序员都掌握的比较好。
 浮点数
浮点数的表示就很复杂了，编码上有许多细节。
首先是对科学计数法的概念：
2-2-2-1
  • 浮点数的表示范围：
2-2-2-2
第0位数符S；第1-8位为8位移码表示阶码EE（偏置常数为128）
第9～31位为24位二进制原码小数表示的尾数MM。规格化尾数的小数点后第一位总是1，故规定第一位默认的“1”不明显表示出来。这样可用23个 数位表示24位尾数
最大正数：0.11…1×211…11=(1−2−24)×21270.11 \dots 1 \times 2^{11 \dots 11} = (1-2^{-24}) \times 2 ^{127}
最小正数：0.10…0×200…0=(1/2)×2−1280.10 \dots 0 \times 2^{00 \dots 0} = (1/2) \times 2^{-128}
2-2-2-3
  • IEEE 754 标准(重点)
2-2-2-4
  • 规格化数
ExponentSignificand
1-254任意小数点前隐含1
00+/-0
2550+/-inf
255nonzeroNaN
  • 非规格化数
当 Exponent==0Exponent == 0 并且 Significand!=0Significand != 0 时，用来表示非规格化数。
2-2-2-5
 非数值表示
 西文字符
ASCII控制字符
二进制十进制十六进制缩写可以显示的表示法名称/意义
0000 0000000NUL␀空字符（Null）
0000 0001101SOH␁标题开始
0000 0010202STX␂本文开始
0000 0011303ETX␃本文结束
0000 0100404EOT␄传输结束
0000 0101505ENQ␅请求
0000 0110606ACK␆确认回应
0000 0111707BEL␇响铃
0000 1000808BS␈退格
0000 1001909HT␉水平定位符号
0000 1010100ALF␊换行键
0000 1011110BVT␋垂直定位符号
0000 1100120CFF␌换页键
0000 1101130DCR␍归位键
0000 1110140ESO␎取消变换（Shift out）
0000 1111150FSI␏启用变换（Shift in）
0001 00001610DLE␐跳出数据通讯
0001 00011711DC1␑设备控制一（XON 启用软件速度控制）
0001 00101812DC2␒设备控制二
0001 00111913DC3␓设备控制三（XOFF 停用软件速度控制）
0001 01002014DC4␔设备控制四
0001 01012115NAK␕确认失败回应
0001 01102216SYN␖同步用暂停
0001 01112317ETB␗区块传输结束
0001 10002418CAN␘取消
0001 10012519EM␙连接介质中断
0001 1010261ASUB␚替换
0001 1011271BESC␛跳出
0001 1100281CFS␜文件分割符
0001 1101291DGS␝组群分隔符
0001 1110301ERS␞记录分隔符
0001 1111311FUS␟单元分隔符
0111 11111277FDEL␡删除
ASCII可显示字符
二进制十进制十六进制图形
0010 00003220（空格）(␠)
0010 00013321!
0010 00103422"
0010 00113523#
0010 01003624$
0010 01013725 %
0010 01103826&
0010 01113927'
0010 10004028(
0010 10014129)
0010 1010422A*
0010 1011432B+
0010 1100442C,
0010 1101452D-
0010 1110462E.
0010 1111472F/
0011 000048300
0011 000149311
0011 001050322
0011 001151333
0011 010052344
0011 010153355
0011 011054366
0011 011155377
0011 100056388
0011 100157399
0011 1010583A:
0011 1011593B;
0011 1100603C<
0011 1101613D=
0011 1110623E>
0011 1111633F?
 
二进制十进制十六进制图形
0100 00006440@
0100 00016541A
0100 00106642B
0100 00116743C
0100 01006844D
0100 01016945E
0100 01107046F
0100 01117147G
0100 10007248H
0100 10017349I
0100 1010744AJ
0100 1011754BK
0100 1100764CL
0100 1101774DM
0100 1110784EN
0100 1111794FO
0101 00008050P
0101 00018151Q
0101 00108252R
0101 00118353S
0101 01008454T
0101 01018555U
0101 01108656V
0101 01118757W
0101 10008858X
0101 10018959Y
0101 1010905AZ
0101 1011915B[
0101 1100925C\
0101 1101935D]
0101 1110945E^
0101 1111955F_
 
二进制十进制十六进制图形
0110 00009660`
0110 00019761a
0110 00109862b
0110 00119963c
0110 010010064d
0110 010110165e
0110 011010266f
0110 011110367g
0110 100010468h
0110 100110569i
0110 10101066Aj
0110 10111076Bk
0110 11001086Cl
0110 11011096Dm
0110 11101106En
0110 11111116Fo
0111 000011270p
0111 000111371q
0111 001011472r
0111 001111573s
0111 010011674t
0111 010111775u
0111 011011876v
0111 011111977w
0111 100012078x
0111 100112179y
0111 10101227Az
0111 10111237B{
0111 11001247C|
0111 11011257D}
0111 11101267E~
 汉字
  • 汉字的区位码：由94行、94列组成，行号为区号，列号为位号。
  • 汉字的国标码：将区号和位号各自加上32(20H)。国标码中区号和位号各占7位。在计算机内部，为方便处理与存储，前面添一个0，构成一个字节。
  • 至少需要2个字节才能表示一个汉字内码（因为汉字总数超过6万个）
 数据宽度和储存容量
 容量单位
中文表示转化
千字节KB1KB=210字节=1024B1KB = 2^{10} \text{字节} = 1024 B
兆字节MB1MB=220字节=1024KB1MB = 2^{20} \text{字节} = 1024 KB
千兆字节GB1GB=230字节=1024MB1GB = 2^{30} \text{字节} = 1024 MB
兆兆字节TB1TB=240字节=1024GB1TB = 2^{40} \text{字节} =1024 GB
 通信中的带宽单位
中文表示转化
千比特/秒kb/s1kbps=103b/s=1000bps1kbps = 10^{3} b/s = 1000 bps
兆比特/秒Mb/s1Mb/s=106b/s=1000kbps1Mb/s = 10^{6} b/s = 1000 kbps
千兆比特/秒Gb/s1Gb/s=109b/s=1000Mbps1Gb/s = 10^{9} b/s = 1000 Mbps
兆兆比特/秒Tb/s1Tb/s=1012b/s=1000Gbps1Tb/s = 10^{12} b/s =1000 Gbps
注意：容量单位和带宽单位里面明显大小写有一些不一样，因为表示的含义不同，一个是1000，一个1024.
 C语言中数据类型的宽度
C声明典型32位机器(单位：字节)典型64位机器(单位：字节)
char11
short int22
int44
long int48
char*48
float44
double88
long double 的确切精度没有规定，所以对于不同平台来说，有的是8字节，有的是10字节，有的是12字节或者16字节。
 数据的存储和排列顺序
80年代开始，几乎所有通用计算机都采用字节编址。在高级语言中声明的基本数据类型有char、short、int、long、long long、float、double、long double等各种不同长度数据，一个基本数据可能会占用多个存储单元。所以有一些问题我们还需要考虑，比如说：变量的地址是其最大地址还是最小地址？多个字节在存储单元中存放的顺序如何？
 大/小端方式
2-5-1-1
测试代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
using namespace std;
const int maxn=200005;

int main()
{
union NUM
{
int a;
char b;
} num;
num.a=0x12345678;
if(num.b==0x12) printf("Big Endian\n");
else printf("Little Endian\n");
printf("num.b=0x%X\n",num.b);
return 0;
}
在我的机器上运行的结果：
2-5-1-2
大小端非常重要，因为在看指令的时候，大小端不同，表示的值就不同。
注意：IA-32采用的是小端方式。
 数字逻辑电路
 布尔代数
AABBA⋅BA \cdot BA+BA+BAˉ\bar{A}A⊕BA \oplus B
000010
010111
100101
111100
 全加器(一位加法器)
两个加数为AA和BB，低位进位为Cin，和为FF，向高位的进位为Cout。
化简之后，逻辑表达式如下：
F=A⊕B⊕CinF=A \oplus B \oplus Cin
Cout=A⋅B+A⋅Cin+B⋅CinCout=A \cdot B + A \cdot Cin + B \cdot Cin
2-6-2
 n位加法器
n位加法器可用n个全加器实现
 无符号整数加
2-6-3-1-1
2-6-3-1-2
 带符号整数加
  • 溢出标志OF：OF=Cn⊕Cn−1OF=C_n \oplus C_{n-1}
  • 符号标志SF：SF=Fn−1SF=F_{n-1}
  • 零标志ZF：ZF=1ZF=1当且仅当F=0F=0
  • 进位/借位标志CF：CF=Cout⊕CinCF=Cout \oplus Cin
2-6-3-2-1
2-6-3-2-2
 n位整数加/减运算器
[A+B]补=[A]补+[B]补(mod    2n)[A+B]_{\text{补}} = [A]_{\text{补}} + [B]_{\text{补}} (mod\;\;2^n)
[A−B]补=[A]补+[−B]补(mod    2n)[A-B]_{\text{补}} = [A]_{\text{补}} + [-B]_{\text{补}} (mod\;\;2^n)
2-6-4-1
  • 当SubSub为11时，做减法。
  • 当SubSub为00时，做加法。
算术逻辑部件ALU：
2-6-4-2
 数据的运算
高级语言程序中涉及的运算（以C语言为例）
  • 整数算术运算、浮点数算术运算
  • 按位、逻辑、移位、位扩展和位截断等运算
指令集中涉及到的运算：
涉及到的定点数运算：
算术运算：
  • 带符号整数：取负/ 符号扩展/ 加/ 减/ 乘/ 除 / 算术移位
  • 无符号整数：0扩展/ 加/ 减/ 乘/ 除/ 逻辑左移/ 逻辑右移
逻辑运算：
  • 逻辑操作：与/ 或/ 非/ …
涉及到的浮点数运算：加、减、乘、除
指令中的运算操作在运算电路中进行
  • 基本运算部件ALU、通用寄存器组，以及其他部件
 整数的加减运算
  1. 计算机中所有运算都基于加法器实现。
  2. 加法器不知道所运算的是带符号数还是无符号数。
  3. 加法器不判定对错，总是取低n位作为结果，并生成标志信息。
 无符号数
加法：
  • 当x+y<2n,result=x+yx+y < 2^n, result=x+y
  • 当2n≤x+y<2n+1,result=x+y−2n2^n \leq x+y < 2^{n+1}, result=x+y-2^n
减法：
  • 当x−y<0,result=x−y+2nx-y<0, result=x-y+2^n
  • 当x−y≥0,result=x−yx-y \geq 0, result=x-y
 带符号数
加法：
  • 当x+y<−2n−1,result=x+y+2nx+y<-2^{n-1}, result=x+y+2^n，负溢出
  • 当−2n−1≤x+y<2n−1,result=x+y-2^{n-1} \leq x+y < 2^{n-1}, result=x+y，正常
  • 当x+y≥2n−1,result=x+y−2nx+y \geq 2^{n-1}, result=x+y-2^n，正溢出
减法：
  • 当x−y<−2n−1,result=x−y+2nx-y<-2^{n-1}, result=x-y+2^n，负溢出
  • 当−2n−1≤x−y<2n−1,result=x−y-2^{n-1} \leq x-y <2^{n-1}, result=x-y，正常
  • 当x−y≥2n−1,result=x−y−2nx-y \geq 2^{n-1}, result=x-y-2^n，正溢出
 
第三章 程序的转换及机器级表示
 概述
机器级指令和汇编指令一一对应，都是机器级指令。
  • 机器指令是一个0/1序列，由若干字段组成。
     3-1
  • 汇编指令是机器指令的符号表示，在不同机器上格式可以不同
    比如说：Intel格式：mov [bx+di-6],cl
    AT&T格式：movb %cl, -6(%bx,%di)
    这两条指令的功能其实都是表示M[R[bx]+R[di]-6]←R[cl]，其中R表示的是寄存器内容，M表示的是存储单元内容。
 IA-32 指令系统
 概述
 寄存器组织
3-2-1-1
编号8位寄存器16位寄存器32位寄存器64位寄存器128位寄存器
000ALAXEAXMM0/ST(0)XMM0
001CLCXECXMM1/ST(1)XMM1
010DLDXEDXMM2/ST(2)XMM2
011BLBXEBXMM3/ST(3)XMM3
100AHSPESPMM4/ST(4)XMM4
101CHBPEBPMM5/ST(5)XMM5
110DHSIESIMM6/ST(6)XMM6
111BHDIEDIMM7/ST(7)XMM7
字长不断扩充，指令保持兼容，ST(0) - ST(7)是80位，MM0 - MM7使用其低64位
IA-32中寄存器名称的含义：
  • CS —— 代码段寄存器（Code Segment）
  • SS —— 栈段寄存器（Stack Segment）
  • DS —— 数据段寄存器（Data Segment）
  • ES —— 扩展段寄存器（Extended Segment）
  • FS，GS —— 数据段寄存器
  • EAX —— 累加寄存器（Extended Accumulator Register）
  • ECX —— 计数寄存器（Extended Counter Register）
  • EDX —— 数据寄存器（Extended Data Register）
  • EBX —— 指向数据段（DS）的指针（Extended Base Register）
  • ESI —— 指向数据段（DS）的指针，表示字符串操作的源（Extended Source Index）
  • EDI —— 指向数据段（ES）的指针，表示字符串操作的目标（Extended Destination Index）
  • EBP —— 指向栈（SS）的指针，一般表示当前栈帧的底部（Extended Base Pointer）
  • ESP —— 指向栈（SS）顶的指针（Extended Stack Pointer）
  • EIP —— 指令寄存器（Enhanced Instruction Pointer）
  • EFLAG —— 标志位寄存器
 标志寄存器
  • 6个条件标志
  1. OF、SF、ZF、CF，功能在前文已经介绍，这里不再赘述
  2. AF：辅助进位标志（在BCD码运算时才有意义）
  3. PF：奇偶标志
  • 3个控制标志
  1. DF（Direction Flag）：方向标志（自动变址方向是增还是减）
  2. IF（Interrupt Flag）：中断允许标志（仅对外部可屏蔽中断有用）
  3. TF（Trap Flag）：陷阱标志（是否是单步跟踪状态）
 保护模式下的寻址方式
寻址方式说明
立即寻址指令直接给出操作数
寄存器寻址指定的寄存器R的内容为操作数
位移LA=(SR)+ALA=(SR)+A
基址寻址LA=(SR)+(B)LA=(SR)+(B)
基址加位移LA=(SR)+(B)+ALA=(SR)+(B)+A
比例变址加位移LA=(SR)+(I)×S+ALA=(SR)+(I) \times S + A
基址加变址加位移LA=(SR)+(B)+(I)+ALA=(SR)+(B)+(I)+A
基址加比例变址加位移LA=(SR)+(B)+(I)×S+ALA=(SR)+(B)+(I) \times S + A
相对寻址LA=(PC)+ALA=(PC)+A 跳转目标指令地址
注：LA:线性地址，(X)：X的内容，SR：段寄存器，PC：程序计数器，R：寄存器，A：指令中给定地址段的位移量，B：基址寄存器，I：变址寄存器，S：比例系数
  • 举例说明：
1
2
3
4
5
int x;
float a[100];
short b[4][4];
char c;
double d[10];
3-2-1-3
  1. 如何计算a[i]的地址？
    104+i×4104+i \times 4，当i=99i=99时，Address=104+99×4=500Address=104+99 \times 4 = 500
  2. 如何计算b[i][j]的地址？
    504+i×8+j×2504 + i \times 8 + j \times 2，当i=3,j=2i=3,j=2时，Address=504+24+4=532Address=504+24+4=532
  3. 如何计算d[i]的地址？
    544+i×8544+i \times 8，当i=9i=9时，Address=544+9×8=500Address=544+9 \times 8 = 500
 机器指令格式
3-2-1-4
 指令类型
 传送指令
1.通用数据传送指令
  • MOV：一般传送，包括movb、movw和movz等
  • MOVS：符号扩展传送，如movsbw、movswl等
  • MOVZ：零扩展传送，如movzwl、movzbl等
  • XCHG：数据交换
  • PUSH/POP：入栈/出栈，如pushl、pushw、popl、popw等
2.地址传送指令
  • LEA：加载有效地址，如leal (%edx,%eax), %eax的功能为R[eax]←R[edx]+R[eax]，执行前，若R[edx]=i，R[eax]=j，则指令执行后，R[eax]=i+j
3.输入输出指令
  • IN和OUT：I/O端口与寄存器之间的交换
4.标志传送指令
  • PUSHF、POPF：将EFLAG压栈，或将栈顶内容送EFLAG
入栈 pushw %ax
  1. 栈（Stack）是一种采用“先进后出”方式进行访问的一块存储区，用于嵌套过程调用。从高地址向低地址增长
  2. “栈”不等于“堆栈”（由“堆”和“栈”组成）
3-2-2-1-1
出栈 popw %ax
3-2-2-1-2
 定点算术指令
  • 加/减运算（影响标志、不区分无/带符号）
    ADD：加，包括addb、addw、addl等
    SUB：减，包括subb、subw、subl等
  • 增1/减1运算（影响除CF以外的标志、不区分无/带符号）
    INC：加，包括incb、incw、incl等
    DEC：减，包括decb、decw、decl等
  • 取负运算（影响标志、若对0取负，则结果为0且CF清0，否则CF置1）
    NEG：取负，包括negb、negw、negl等
  • 比较运算（做减法得到标志、不区分无/带符号）
    CMP：比较，包括cmpb、cmpw、cmpl等
  • 乘/除运算（不影响标志、区分无/带符号）
    MUL/IMUL：无符号乘/带符号乘DIV/IDIV：带无符号除/带符号除
1.乘法指令：
  • 指令中只给出一个操作数SRC：则另一个源操作数隐含在AL/AX/EAX中，将SRC和累加器内容相乘，结果存放在AX（16位）或DX-AX（32位）或 EDX-EAX（64位）中。DX-AX表示32位乘积的高、低16位分别在DX和AX中。
    得到的结果的位数：n位×n位=2n位n\text{位}\times n\text{位}=2n\text{位}
  • 指令中给出两个操作数DST和SRC，则将DST和SRC相乘，结果在DST中。
    得到的结果的位数：n位×n位=n位n\text{位}\times n\text{位}=n\text{位}
  • 指令中给出三个操作数REG、SRC和IMM，则将SRC和立即数IMM相乘，结果在REG中。
    得到的结果的位数：n位×n位=n位n\text{位}\times n\text{位}=n\text{位}
2.除法指令
只明显指出除数，用EDX-EAX中内容除以指定的除数
  • 若为8位，则16位被除数在AX寄存器中，商送回AL，余数在AH
  • 若为16位，则32位被除数在DX-AX寄存器中，商送回AX，余数在DX
  • 若为32位，则被除数在EDX-EAX寄存器中，商送EAX，余数在EDX
3-2-2-2-1
 按位运算
1.移位运算（左/右移时，最高/最低位送CF）
  • SHL/SHR: 逻辑左/右移，包括shlb、shrw、shrl等
  • SAL/SAR: 算术左/右移，左移判溢出，右移高位补符（移位前、后符号位发生变化，则OF=1 ）包括salb、sarw、sarl等
  • ROL/ROR: 循环左/右移，包括rolb、rorw、roll等
  • RCL/RCR: 带进位循环左/右移，即：将CF作为操作数 一部分循环移位，包括rclb、rcrw、rcll等 
    3-2-2-3-1
注：sarw $1,%ax可简写成sarw %ax
2.逻辑运算
  • NOT：非，包括notb、notw、notl等
  • AND：与，包括andb、andw、andl等
  • OR：或，包括orb、orw、orl等
  • XOR：异或，包括xorb、xorw、xorl等
  • TEST：做“与”操作测试，仅影响标志
仅NOT不影响标志，其他指令OF=CF=0，而ZF和SF则根据结果设置：若全0，则ZF=1；若最高位为1，则SF=1
 控制转移指令
指令执行可按顺序或跳转到转移目标指令处执行
  • 无条件转移指令
    JMP DST：无条件转移到目标指令DST处执行
  • 条件转移
    Jcc DST：cc为条件码，根据标志（条件码）判断是否满足条件，若满足，则转移到目标指令DST处执行，否则按顺序执行
  • 条件设置
    SETcc DST：按条件码cc判断的结果保存到DST（是一个8位寄存器）
  • 调用和返回指令（用于过程调用）
    CALL DST：返回地址RA入栈，转DST处执行
    RET：从栈中取出返回地址RA，转到RA处执行
  • 中断指令
这里我们可以注意到，调用的函数返回地址是RA，这非常重要
3-2-2-4
 C语言程序的机器级表示
 过程调用的机器级表示
 过程调用的执行步骤
过程调用的执行步骤(P为调用者，Q为被调用者)
  1. P将入口参数（实参）放到Q能访问到的地方；
  2. P保存返回地址，然后将控制转移到Q； （CALL指令）
  3. Q保存P的现场，并为自己的非静态局部变量分配空间；
  4. 执行Q的过程体（函数体）；
  5. Q恢复P的现场，释放局部变量空间；
  6. Q取出返回地址，将控制转移到P。（RET指令）
3-3-1-1
 IA-32的寄存器使用约定
  • 调用者保存寄存器：EAX、EDX、ECX
    当过程P调用过程Q时，Q可以直接使用这三个寄存器，不用将它们的值保存到栈中。如果P在从Q返回后还要用这三个寄存器的话，P应在转到Q之前先保存，并在从Q返回后先恢复它们的值再使用。
  • 被调用者保存寄存器：EBX、ESI、EDI
    Q必须先将它们的值保存到栈中再使用它们，并在返回P之前恢复它们的值。
  • EBP和ESP分别是帧指针寄存器和栈指针寄存器，分别用来指向当前栈帧的底部和顶部。
注意：
  1. 所以为了减少准备和结束阶段的开销，每个过程应该先使用EAX、ECX、EDX，这样就不用存栈。
  2. 返回参数总在EAX中
 过程（函数）的结构
一个C过程的大致结构如下：
准备阶段：
  • 形成帧底：push指令 和mov指令
  • 生成栈帧（如果需要的话）：sub指令或and指令
  • 保存现场（如果有被调用者保存寄存器）：mov指令（为什么？因为所有过程共享一套GPRs）
过程（函数）体：
  • 分配局部变量空间，并赋值
  • 具体处理逻辑，如果遇到函数调用时，
    (1) 准备参数：将实参送栈帧入口参数处
    (2) CALL指令：保存返回地址并转被调用函数
  • 在EAX中准备返回参数
3-3-1-3
第一个入口参数在EBP+8的位置（EBP存EBP在Caller中的旧值，EBP+4存返回地址）
结束阶段：
  • 退栈：leave指令或pop指令
  • 取返回地址返回：ret指令
 选择和循环语句
1.switch-case语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
movl    8(%ebp),%eax
subl    $10,%eax
cmpl    $7,%eax
ja      .L5
jmp     *.L8(,%eax,4)
.L1
...
.L2
...
.L3
...
.L4
...
.L5
...
.L7
...
跳转表在目标文件的只读节中，按4字节边界对齐。
3-3-1-4-1
2.循环结构与递归结构的比较
循环结构一般使用的都是简单变量，直接保存到寄存器中。而递归结构每次都要分配栈空间，时间和空间的开销都非常得大。（比如递归写法的快速幂和迭代写法的快速幂，速度会差几十倍至几十倍（取决于数据范围）。所以，为了提高程序性能，能使用非递归方式执行则最好用非递归结构。
 复杂数据类型的分配和访问
 数组
数组定义数组名数组元素类型数组元素大小(B)数组大小(B)起始地址元素i的地址
char S[10]Schar110&S[0]&S[0]+i
char* SA[10]SAchar*440&SA[0]&SA[0]+4*i
double D[10]Ddouble880&D[0]&D[0]+8*i
double* DA[10]DAdouble*440&DA[0]&DA[0]+4*i
数组元素和指针变量的表达式计算示例：
序号表达式类型值的计算方式汇编代码
1Aint*SAleal (%ecx),%eax
2A[0]intM[SA]movl (%ecx),%eax
3A[i]intM[SA+4*i]movl (%ecx,%edx,4),%eax
4&A[3]int*SA+12leal 12(%ecx),%eax
5&A[i]-Aint(SA+4*i-SA)/4=imovl %edx,%eax
6*(A+i)intM[SA+4*i]movl (%ecx,%edx,4),%eax
7*(&A[0]+i-1)intM[SA+4*i-4]movl -4(%ecx,edx,4),%eax
8A+iint*SA+4*ileal (%ecx,%edx,4),%eax
指针数组和多维数组：
  • 由若干指向同类目标的指针变量组成的数组称为指针数组。
    其定义的一般形式如下：
    存储类型 数据类型 *指针数组名[元素个数]
    例如，int *a[10];定义了一个指针数组a，它有10个元素，每个元素都是一个指向int型数据的指针。
  • 一个指针数组可以实现一个二维数组
 结构体和联合体
 结构体成员在内存的存放和访问
  • 分配在栈中的auto结构型变量的首地址由EBP或ESP来定位
  • 分配在静态区的结构型变量首地址是一个确定的静态区地址
  • 结构型变量 x 各成员首址可用“基址加偏移量”的寻址方式
结构体数据作为入口参数：
首先，当结构体变量需要作为一个函数的形参时，形参和调用函数中的实参应具有相同结构。
然后，其传递有两种方式：
  • 若采用按值传递，则结构成员都要复制到栈中参数区，这既增加时间开销又增加空间开销，且更新后的数据无法在调用过程使用
  • 通常应按地址传递，即：在执行CALL指令前，仅需传递指向结构体的指针而不需复制每个成员到栈中
 联合体数据的分配和访问
联合体各成员共享存储空间，按最大长度成员所需空间大小为目标
注：联合体通常用于特殊场合，如，当事先知道某种数据结构中的不同字段的使用时间是互斥的，就可将这些字段声明为联合，以减少空间。但有时会得不偿失，可能只会减少少量空间却大大增加处理复杂性。
 数据的对齐存放
 为什么要对齐
各种不同长度的数据存放时，有两种处理方式:
  • 按边界对齐（若一个字为32位）
    字地址：4的倍数(低两位为0)
    半字地址：2的倍数(低位为0)
    字节地址：任意
  • 不按边界对齐
    坏处：可能会增加访存次数
 对齐方式的设定
#pragma pack(n)
  • 为编译器指定结构体或类内部的成员变量的对齐方式。
  • 当自然边界（如int型按4字节、short型按2字节、float按4字节）比n大时，按n字节对齐。
  • 缺省或#pragma pack() ，按自然边界对齐。
__attribute__((aligned(m)))
  • 为编译器指定一个结构体或类或联合体或一个单独的变量(对象)的对齐方式。
  • 按m字节对齐(m必须是2的幂次方)，且其占用空间大小也是m的整数倍，以保证在申请连续存储空间时各元素也按m字节对齐。
__attribute__((packed))
  • 不按边界对齐，称为紧凑方式。
 越界访问和缓冲区溢出
先看一个例子直观感受：
3-4-4-4
当i>1的时候，就出现了问题，因为数组访问越界了，影响到了其他位置的值甚至直接爆栈。
C语言程序中对数组的访问可能会有意或无意地超越数组存储区范围而无法发现。
数组存储区可看成是一个缓冲区，超越数组存储区范围的写入操作
称为缓冲区溢出。
例如，对于一个有10个元素的char型数组，其定义的缓冲区有10个字节。若写一个字符串到这个缓冲区，那么只要写入的字符串多于9个字符（结束符‘\0’占一个字节），就会发生“写溢出”。
带来的破坏：
  • 缓冲区溢出是一种非常普遍、非常危险的漏洞，在各种操作系统、
    应用软件中广泛存在。
  • 缓冲区溢出攻击是利用缓冲区溢出漏洞所进行的攻击。利用缓冲区
    溢出攻击，可导致程序运行失败、系统关机、重新启动等后果。
 x86-64 体系
 x86-64操作数格式
操作数的寻址有如下方式：
  • 立即数，用来表示常数值，书写方式为’$'加标准C表示法表示的整数，如$-577或$0x1F。
  • 寄存器，R[ra]表示ra寄存器的内容。
  • 内存引用，M[Addr]表示地址为Addr的存储单元内的值
立即数Imm、基址寄存器rb、变址寄存器ri、比例因子s（其值为1、2、4、8）。
类型格式操作数值名称
立即数$ImmImm立即数寻址
寄存器raR[ra]寄存器寻址
存储器ImmM[Imm]绝对寻址
存储器(ra)M[R[ra]]间接寻址
存储器Imm(rb)M[Imm+R[rb]]（基址+偏移量）寻址
存储器(rb,ri)M[R[rb]+R[ri]]变址寻址
存储器Imm(rb,ri)M[Imm+R[rb]+R[ri]]变址寻址
存储器(,ri,s)M[R[ri]*s]比例变址寻址
存储器Imm(,ri,s)M[Imm+R[ri]*s]比例变址寻址
存储器(rb,ri,s)M[R[rb]+R[ri]*s]比例变址寻址
存储器Imm(rb,ri,s)M[Imm+R[rb]+R[ri]*s]比例变址寻址
 x86-64寄存器
X86-64有16个64位寄存器，分别是：rax，rbx，rcx，rdx，esi，edi，rbp，rsp，r8，r9，r10，r11，r12，r13，r14，r15。其中：
  • rax 作为函数返回值使用。
  • rsp 栈指针寄存器，指向栈顶
  • rdi，rsi，rdx，rcx，r8，r9 用作函数参数，依次对应第1参数，第2参数……
  • rbx，rbp，r12，r13，r14，r15 用作数据存储，遵循被调用者使用规则，简单说就是随便用，调用子函数之前要备份它，以防他被修改
  • r10，r11 用作数据存储，遵循调用者使用规则，简单说就是使用之前要先保存原值
注：
  • 最多有六个整形或指针型参数通过寄存器传递，超过六个只能通过栈来传递（所以在传递参数的时候尽量保证传递的参数个数在6个以内，如果是数组就用传递指针，这样可以提高程序的运行效率）
  • 在函数中尽量使用rax,r10，r11，若使用rbx,rbp,r12，r13，r14,r15则需要将它们先保存在栈中在使用，最后返回前再恢复其值
63~0位31~0位15~0位7~0位用途
%rax%eax%ax%al返回值
%rbx%ebx%bx%bl被调用者保存
%rcx%ecx%cx%cl第4个参数
%rdx%edx%dx%dl第3个参数
%rsi%esi%si%sil第2个参数
%rdi%edi%di%dil第1个参数
%rbp%ebp%bp%bpl被调用者保存
%rsp%esp%sp%spl栈指针
%r8%r8d%r8w%r8b第5个参数
%r9%r9d%r9w%r9b第6个参数
%r10%r10d%r10w%r10b调用者保存
%r11%r11d%r11w%r11b调用者保存
%r12%r12d%r12w%r12b被调用者保存
%r13%r13d%r13w%r13b被调用者保存
%r14%r14d%r14w%r14b被调用者保存
%r15%r15d%r15w%r15b被调用者保存
]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla
      
    
    
    
    
      
    
      
    
    
      
    
      
    
      
    
      
    
  
  
  
    常见的一些User-Agent
    
    http://lemonaaaaa.com/2020/04/user-agent/
    2020-04-21T15:15:34.000Z
    2020-05-10T03:11:22.850Z
    
    
User-Agent我们一般在抓包的时候用，因为要将Python（举例）伪装成正常的用户上网操作，让服务器识别为正常操作返回正常的数据给你。同时，这个也可以去评论其他博客（比如说Valine这种评论系统就会显示你的操作系统和浏览器，你可以修改，让对方感到迷惑：什么年代了都还在用Windows 98？？？）
 操作系统标识
 FreeBSD
X11; FreeBSD (version no.) i386
X11; FreeBSD (version no.) AMD64
 Linux
X11; Linux ppc
X11; Linux ppc64
X11; Linux i686
X11; Linux x86_64
 Mac
Macintosh; PPC Mac OS X
Macintosh; Intel Mac OS X
 Solaris
X11; SunOS i86pc
X11; SunOS sun4u
 Windows
Windows NT 10.0 对应操作系统 windows 10
windows NT 6.2 对应操作系统 windows 8
Windows NT 6.1 对应操作系统 windows 7
Windows NT 6.0 对应操作系统 windows vista
Windows NT 5.2 对应操作系统 windows 2003
Windows NT 5.1 对应操作系统 windows xp
Windows NT 5.0 对应操作系统 windows 2000
Windows ME
Windows 98 (Windows NT 98)
 常用浏览器
safari 5.1 – MAC
User-Agent:Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50
safari 5.1 – Windows
User-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50
IE 9.0
User-Agent:Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0;
IE 8.0
User-Agent:Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0)
IE 7.0
User-Agent:Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)
IE 6.0
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Firefox 4.0.1 – MAC
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:2.0.1) Gecko/20100101 Firefox/4.0.1
Firefox 4.0.1 – Windows
User-Agent:Mozilla/5.0 (Windows NT 6.1; rv:2.0.1) Gecko/20100101 Firefox/4.0.1
Opera 11.11 – MAC
User-Agent:Opera/9.80 (Macintosh; Intel Mac OS X 10.6.8; U; en) Presto/2.8.131 Version/11.11
Opera 11.11 – Windows
User-Agent:Opera/9.80 (Windows NT 6.1; U; en) Presto/2.8.131 Version/11.11
Chrome 17.0 – MAC
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11
 国产浏览器
Maxthon
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon 2.0)
TT
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler 4.0)
The World 2.x
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)
The World 3.x
User-Agent:?Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; The World)
搜狗浏览器 1.x
User-Agent:?Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; SE 2.X MetaSr 1.0; SE 2.X MetaSr 1.0; .NET CLR 2.0.50727; SE 2.X MetaSr 1.0)
360SE
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; 360SE)
Avant
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Avant Browser)
Green Browser
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)
 移动设备端
safari iOS 4.33 – iPhone
User-Agent:Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5
safari iOS 4.33 – iPod Touch
User-Agent:Mozilla/5.0 (iPod; U; CPU iPhone OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5
safari iOS 4.33 – iPad
User-Agent:Mozilla/5.0 (iPad; U; CPU OS 4_3_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8J2 Safari/6533.18.5
Android N1
User-Agent: Mozilla/5.0 (Linux; U; Android 2.3.7; en-us; Nexus One Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1
Android QQ For android
User-Agent: MQQBrowser/26 Mozilla/5.0 (Linux; U; Android 2.3.7; zh-cn; MB200 Build/GRJ22; CyanogenMod-7) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1
Android Opera Mobile
User-Agent: Opera/9.80 (Android 2.3.4; Linux; Opera Mobi/build-1107180945; U; en-GB) Presto/2.8.149 Version/11.10
Android Pad Moto Xoom
User-Agent: Mozilla/5.0 (Linux; U; Android 3.0; en-us; Xoom Build/HRI39) AppleWebKit/534.13 (KHTML, like Gecko) Version/4.0 Safari/534.13
BlackBerry
User-Agent: Mozilla/5.0 (BlackBerry; U; BlackBerry 9800; en) AppleWebKit/534.1+ (KHTML, like Gecko) Version/6.0.0.337 Mobile Safari/534.1+
WebOS HP Touchpad
User-Agent: Mozilla/5.0 (hp-tablet; Linux; hpwOS/3.0.0; U; en-US) AppleWebKit/534.6 (KHTML, like Gecko) wOSBrowser/233.70 Safari/534.6 TouchPad/1.0
Nokia N97
User-Agent: Mozilla/5.0 (SymbianOS/9.4; Series60/5.0 NokiaN97-1/20.0.019; Profile/MIDP-2.1 Configuration/CLDC-1.1) AppleWebKit/525 (KHTML, like Gecko) BrowserNG/7.1.18124
Windows Phone Mango
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows Phone OS 7.5; Trident/5.0; IEMobile/9.0; HTC; Titan)
UC标准
User-Agent: NOKIA5700/ UCWEB7.0.2.37/28/999
UCOpenwave
User-Agent: Openwave/ UCWEB7.0.2.37/28/999
UC Opera
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; ) Opera/UCWEB7.0.2.37/28/999
        
            
        
        ]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla
      
    
    
    
    
      
    
      
    
    
      
    
      
    
  
  
  
    UML 自学笔记
    
    http://lemonaaaaa.com/2020/04/uml-notes/
    2020-04-18T03:20:56.000Z
    2020-04-18T03:20:56.583Z
    
    
 UML 简介
1997年，OMG（难道是Oh My God？） 组织（Object Management Group对象管理组织）发布了统一建模语言（Unified Modeling Language，UML）。UML 是一种编制软蓝图的标准化语言，它的目标之一就是为开发团队提供标准通用的设计语言来开发和构建计算机应用。UML 提出了一套 IT 专业人员期待多年的统一的标准建模符号。通过使用UML，这些人员能够阅读和交流系统架构和设计规划。UML支持面向对象的技术，能够准确的方便地表达面向对像的概念，体现面向对象的分析和设计风格。
UML
 UML 模型
  • 事物(Things)：UML模型中最基本的构成元素，是具有代表性的成分的抽象
  • 关系(Relationships)：关系把事物紧密联系在一起
  • 图(Diagrams )：图是事物和关系的可视化表示
 UML 特点
  • 面向对象
  • 可视化，表达能力强
  • 独立于过程
  • 独立于程序设计
  • 容易掌握使用
 UML 概述
  • UML 是 OMG 在1997年1月提出了创建由对象管理组和 UML1.0 规范草案；
  • UML 是一种为面向对象开发系统的产品进行说明、可视化、和编制文档的标准语言；
  • UML 作为一种模型语言，它使开发人员专注于建立产品的模型和结构，而不是选用什么程序语言和算法实现；
  • UML 是不同于其他常见的编程语言，如C + +，Java中，COBOL等，它是一种绘画语言，用来做软件蓝图；
  • UML 不是一种编程语言，但工具可用于生成各种语言的代码中使用UML图；
  • UML 可以用来建模非软件系统的处理流程，以及像在一个制造单元等.
 UML 构建模块
 构建块的定义
  • 事物
  • 关系
  • 图
 事物
  • 结构事物
  • 行为事物
  • 分组事物
  • 注释事物
 结构事物
结构事物是模型中的静态部分，用以呈现概念或实体的表现元素，是软件建模中最常见的元素
  • 1.类
类是指具有相同属性、方法、关系和语义的对象的集合。
类
  • 2.接口
接口是指类或组件所提供的服务（操作），描述了类或组件对外可见的动作。
接口
  • 3.协作
协作定义元素之间的相互作用。
协作
  • 4.用例
用例定义了执行者（在系统外部和系统交互的人）和被考虑的系统之间的交互来实现的一个业务目标。
用例
  • 5.组件
组件描述物理系统的一部分。
组件
  • 6.节点
一个节点可以被定义为在运行时存在的物理元素。
节点
 行为事物
行为事物指的是 UML 模型中的动态部分，代表语句里的 “动词”，表示模型里随着时空不断变化的部分
  • 1.交互
交互被定义为一种行为，包括一组元素之间的消息交换来完成特定的任务。
交互
  • 2.状态机
状态机由一系列对象的状态组成，它是有用的，一个对象在其生命周期的状态是很重要的。
状态机
 分组事物
可以把分组事物看成是一个"盒子"，模型可以在其中被分解。目前只有一种分组事物，即包（package）。结构事物、动作事物甚至分组事物都有可能放在一个包中。包纯粹是概念上的，只存在于开发阶段，而组件在运行时存在。
  • 包
封装是唯一一个分组事物可收集结构和行为的东西。
包包
 注释事物
注释事物可以被定义为一种机制来捕捉UML模型元素的言论，说明和注释。注释是唯一一个注释事物。
  • 注释
注释用于渲染意见，约束等的UML元素。
注释注释
 关系
关系是另一个最重要的构建块UML，它显示元素是如何彼此相关联，此关联描述的一个应用程序的功能，UML中定义了依赖、协作、泛化、实现四种关系。
  • 1.依赖关系
依赖是两件事物之间的语义联系，其中一个事物的变化也影响到另一个事物。
依赖
  • 2.协作
一种描述一组对象之间连接的结构关系，如聚合关系（描述了整体和部分间的结构关系）。
协作
  • 3.泛化
泛化可以被定义为一个专门的元件连接关系与一个广义的元素，它基本上描述了在对象世界中的继承关系，是一种一般化-特殊化的关系。
泛化
  • 4.实现
类之间的语义关系，其中的一个类指定了由另一个类保证执行的契约。
实现
 图
UML 图的整个讨论的最终输出所有要素，关系用于使一个完整的UML图，图中表示的系统。
UML 图的视觉效果是整个过程中最重要的部分。
图是事物集合的分类，UML 中包含多种图。
  1. 类图：类图描述系统所包含的类、类的内部结构及类之间的关系；
  2. 对象图：对象图是类图的一个具体实例；
  3. 用例图：用例图从用户的角度出发描述系统的功能、需求，展示系统外部的各类角色与系统内部的各种用例之间的关系；
  4. 顺序图：顺序图表示对象之间动态合作的关系；
  5. 协作图：协作图描述对象之间的协作关系；
  6. 活动图：活动图描述系统中各种活动的执行顺序。
  7. 状态图：状态图描述一类对象的所有可能的状态以及事件发生时状态的转移条件；
  8. 部署关系图：部署关系图定义系统中软硬件的物理体系结构；
  9. 组件图：组件图描述代码部件的物理结构以及各部件之间的依赖关系；
 UML 类图
因为博主主要是学习C++面向对象程序设计，所以接下来，主要介绍UML图形标识中的类图。一个类图是由类和与之相关的各种静态关系共同组成的图形。类图展示的是软件模型的静态结构、类的内部结构以及和其他类的关系。通过类图，能够描述一部分面向对象的相关概念（如类、模板等）以及它们的相互关系。
 类和对象
类图中最基本的是要图形化描述类，要表示类的名称、数据成员和函数成员，以及各成员的访问控制属性。
在UML语言中，用一个由上而下分为3段的矩形来表示一个类。类名写在顶部区域，数据成员（UML中称为属性）在中间区域，函数成员（UML中称为操作）在底部区域。
比如说：
1
2
3
4
5
6
7
8
9
10
class Clock
{
private:
int hour;
int minute;
int second;
public:
void showTime();
void setTime(int newH=0,int newM=0,int newS=0);
};
以clock类举例
 数据成员
根据图的详细程度，每个数据成员可以包括其访问控制属性、名称、类型、默认值和约束特性，最简单的情况是只表示出它的名字，其余部分都是可选的。UML规定语法如下：
[访问控制属性] 名称 [重数] [:类型] [=默认值] [{约束特性}]
至少指定数据成员的名称，其余都是可选的。
其中的访问控制属性可分为Public, Private 和 Protected 三种，分别对应于 UML 中的“+”、“-”和“#”。
 函数成员
每个函数成员可以包括其访问控制属性、名称、参数表、返回类型和约束特性，最简单的情况是只表示出它的名字，其余部分都是可选的。UML规定语法如下：
[访问控制属性] 名称 [(参数表)] [:返回类型] [{约束特性}]
至少指定函数成员的名称，其余都是可选的。
其中的访问控制属性可分为Public, Private 和 Protected 三种，分别对应于 UML 中的“+”、“-”和“#”。
 对象
在UML语言中，用一个矩形来表示一个对象。对象的名字要加下划线。对象的全名写在图形的上部区域，由类名和对象名组成，其间用冒号隔开，表示方式为“对象名:类名”。在一些情况下，可以不出现对象名或类名。数据成员及其值表示在下面区域，数据成员是可选的。
以myClock对象举例
以student类举例 以student对象举例
 几种关系的图形标识
 依赖关系
类或对象之间的依赖描述了一个事物的变化可能会影响到使用它的另一个事物,反之不成立。当要表明一个类使用另一个类作为它的函数成员参数时，就使用依赖关系。通常类之间的调用关系.友元、类的实例化都属于这类关系。对于大多数依赖关系而言,简单的.不加修饰的依赖关系就足够了。然而,为了详述其含义的细微差别,UML定义了一些可以用于依赖关系的构造型。最常用的构造型是使用<< use >>。当需要表示两个类之间的使用关系时,要使用<< use >>构造型。
图4-6说明了如何表示类间的依赖关系,UML图形把依赖绘成一条指向被依赖的事物的虚线。图中的“类A”是源，“类B”是目标,表示“类A”使用了“类B”,或称“类A"依赖“类B"。
依赖关系
 作用关系——关联
关联用于表述一个类的对象和另一个类的对象之间相互作用的连接。在UML语言中,用实线来表示的两个类(或同一个类)之间的关联,在线段两端通常包含多重性(或称重数)。多重性可说是关联最重要的特性,关联一端的多重性表明:关联另一端类的每个对象要求与本端类的多少个对象发生作用。图4-7说明了在UML中对关联的表示。
作用关系
图中的“重数A"决定了类B的每个对象与类A的多少个对象发生作用,同样“重数B”决定了类A的每个对象与类B的多少个对象发生作用。重数标记的形式和含义均列于表4-1中。
重数
 包含关系——聚集和组合
类或对象之间的包含关系在UML中由聚集和组合两个概念描述,它们是一种特殊的关联。UML中的聚集表示类之间的关系是整体与部分的关系，“包含”、“组成”、“分为…部分”等都是聚集关系。一条直线段有两个端点,这是聚集的一个例子。聚集可以进一步划分成共享聚集和组成聚集(简称组合)。
  • 例如,课题组包含许多成员,但是每个成员又可以是另一个课题组的成员,即部分可以参加多个整体,称之为共享聚集。
  • 另一种情况是整体拥有各部分,部分与整体共存,如整体不存在了,部分也会随之消失,这称为组合。组合是一种简单聚集形式,但是它具有更强的拥有关系。例如，打开一个视窗口,它就由标题、外框和显示区所组成。在UML中,聚集表示为空心菱形,组合表示为实心菱形。
图4-8说明了如何表示类的聚合和组合。
聚集和组合
 继承关系——泛化
类之间的继承关系在UML中称为泛化,使用带有三角形标识的直线段表示这种继承关系，三角的一个尖指向父类,其对边上的线指向子类。图4-10说明了泛化关系。子类1说明单继承，子类2说明多继承。
泛化关系
 注释
为了更生动地描述类、对象以及它们之间的关系,除了上述最基本的图形符号外，UMI还有一些辅助性的图形符号，下面介绍注释。
UML的注释是一种最重要的能够独立存在的修饰符号。注释是附加在元素或元素集上用来表示说明的图形符号。用注释可以为模型附加一些诸如说明、评述和注解等的信息。在UML图形上,注释表示为带有褶角的矩形,然后用虚线连接到UML的其他元素上,它是一种用于在图中附加文字注释的机制。
注释
 结语
引用其他博主的一句话：
UML的一切实际上就是为了交流。先编码后修复是错误的，先设计再纠错是正确的。
UML图是用来画出来找错误的，而不是要画一个完美的图形，无论是否正确，画图是用来记录和构思你的想法的，而不是一开始就是要画一个正确的图。
        
            
        
        ]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla
      
    
    
    
    
      
    
      
    
    
      
    
      
    
  
  
  
    2020 年的春天 油菜花照常开放
    
    http://lemonaaaaa.com/2020/03/canola-flowers-2020/
    2020-03-01T05:29:11.000Z
    2020-03-01T05:29:11.150Z
    
    
愿疫情早日结束……
        
            
        
        
 蓝天
1
 花朵
2
 一望无际
3
 白房子
4
5
 小船
6
 远方
7
]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla
      
    
    
    
    
      
    
      
    
    
      
    
      
    
      
    
  
  
  
    Codeforces Round 624 (Div. 3) 题解
    
    http://lemonaaaaa.com/2020/02/codeforces-round-624-div3/
    2020-02-25T15:56:24.000Z
    2020-04-17T12:59:30.116Z
    
    
还是div. 3比较适合我这种菜，不过最后一道题一个细节没调出来真的可惜了。
 A. Add Odd or Subtract Even
题目链接
 题目原文
1311A
 题目大意
给出 aa 和 bb 两个正整数。每一次操作，你可以将 aa 做以下两种操作之一：
  • 任选一个正奇数 xx ，将 aa 加上 xx 。
  • 任选一个正偶数 yy ，将 aa 减去 yy 。
问至少操作多少次，可以使 aa 和 bb 的值相等。
 思路
容易发现，有以下几种情况：
  1. a==ba==b ，答案为 00 。
  2. a<ba<b 。如果 aa 和 bb 的差值是奇数，那么直接加上一个正奇数就可，答案为 11 ；如果差值是偶数，那么答案为 22 ，加两次正奇数或者加一次正奇数再减一次正偶数。
  3. a>ba>b 。与2.同理且相反。
 代码
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
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
using namespace std;
const int maxn=200005;

int main()
{
long long T,x,y;
scanf("%lld",&T);
while(T--)
{
scanf("%lld%lld",&x,&y);
long long ans;
if(x==y) ans=0;
  else if(x &lt; y)
  {
long long temp=y-x;
if(temp&1) ans=1;
else ans=2;
}
else
{
long long temp=x-y;
if(temp&1) ans=2;
else ans=1;
}
printf("%lld\n",ans);
}
return 0;
}
 B. WeirdSort
题目链接
 题目原文
1311B
 题目大意
给出 nn 个数和 mm 个位置 posipos_i ，可以让 posipos_i 和 posi+1pos_i+1 交换任意次位置，求是否能通过交换，使这 nn 个数以非递减顺序排列。
 思路
最开始还没有思路，把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
31
32
33
34
35
36
37
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
using namespace std;
const int maxn=105;
int T,n,m,p[maxn],a[maxn];
bool vis[maxn];
int main()
{
scanf("%d",&T);
while(T--)
{
memset(vis,false,sizeof(vis));
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1,x;i<=m;i++)
{
scanf("%d",&x);
vis[x]=true;
}
for(int i=1;i<=n;i++)
{
int s=i,t=i;
while(vis[t]) t++;
sort(a+s,a+t+1);
i=t;
}
bool flag=false;
for(int i=2;i<=n;i++)
{
if(a[i]<a[i-1]) flag=true;
}
if(flag) printf("NO\n");
else printf("YES\n");
}
return 0;
}
 C. Perform the Combo
题目链接
 题目原文
1311C
 题目大意
给出一个字符串，要求枚举一遍该字符串，再给出 mm 个错误操作，每次遇到错误操作就会从头开始重新枚举。求最后执行完 mm 个错误操作后，26个小写字母每个都被枚举了多少遍。
 思路
直接前缀和，每次 O(1)O(1) 查询，时间复杂度 O(t⋅max(n,m)⋅26)O(t\cdot max(n,m)\cdot26) 。
 代码
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
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
using namespace std;
const int maxn=200005;
int cnt[maxn][26];
char s[maxn];
int p[maxn],n,m,T;
long long ans[26];
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
scanf("%s",s+1);
for(int i=1;i<=n;i++)
for(int j=0;j<26;j++) cnt[i][j]=0;
for(int i=1;i<=n;i++) cnt[i][s[i]-'a']++;
for(int i=1;i<=n;i++)
for(int j=0;j<26;j++) cnt[i][j]+=cnt[i-1][j];
memset(ans,0,sizeof(ans));
for(int i=1,x;i<=m;i++)
{
scanf("%d",&x);
for(int j=0;j<26;j++) ans[j]+=cnt[x][j];
}
for(int i=0;i<26;i++) ans[i]+=cnt[n][i];
for(int i=0;i<26;i++) printf("%lld ",ans[i]);
printf("\n");
}
return 0;
}
 D. Three Integers
题目链接
 题目原文
1311D
 题目大意
给出 AA , BB , CC 三个正整数，每次可以将这三个数任意一个数加上 11 或者减去 11 ，求最少操作多少次，能使 CC 能被 BB 整除， BB 能被 AA 整除。
 思路
因为数据范围是 1000010000 ，直接枚举 AA ，再枚举 BB ，CC 就不要枚举了，直接除以枚举的 BB ，直接取最近的值就好。
 代码
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
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
using namespace std;
const int maxn=200005;
int main()
{
#ifdef lemon
freopen("D.txt","r",stdin);
#endif
long long T,a,b,c;
scanf("%lld",&T);
while(T--)
{
scanf("%lld%lld%lld",&a,&b,&c);
long long ans=1e18,ansa,ansb,ansc;
for(long long i=1;i<=10000;i++)
{
for(long long j=1;j<=10000;j++)
{
if(i*j>50000) break;
long long temp=0,tempa,tempb,tempc;
temp+=abs(a-i)+abs(b-i*j);
long long p=c/(i*j);
tempa=i;tempb=i*j;
if(p==0)
{
temp+=abs(c-i*j);
tempc=i*j;
}
else
{
if(abs(c-i*j*p)<abs(c-i*j*(p+1)))
{
temp+=abs(c-i*j*p);
tempc=i*j*p;
}
else
{
temp+=abs(c-i*j*(p+1));
tempc=i*j*(p+1);
}
}
if(temp &lt; ans)
{
ans=temp;
ansa=tempa;
ansb=tempb;
ansc=tempc;
}
}
}
printf("%lld\n%lld %lld %lld\n",ans,ansa,ansb,ansc);
}
return 0;
}
 E. Construct the Binary Tree
题目链接
 题目原文
1311E
 题目大意
给出 nn 和 dd ，求问存不存在 nn 个点的二叉树，其所有节点的深度之和为 dd ，如果存在，需要输出每一个节点的父节点（根节点为 00 ）。
 思路
先把 nn 个点连成一条链，再不断地从链尾取下点按深度递增的顺序加在某些点后即可。
 代码
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
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
using namespace std;
const int maxn=5005;
int T,n,d;
int point[maxn][maxn],fa[maxn],cnt[maxn];
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&d);
for(int i=0;i &lt; n;i++)
{
fa[i+1]=i;
cnt[i]=1;
point[i][0]=i+1;
}
int res=n*(n-1)/2-d;
if(res<0)
{
printf("NO\n");
continue;
}
int depth=1;
for(int i=n-1;i;i--)
{
int delta=min(i-depth,res);
res-=delta;
int pos=i-delta;
fa[i+1]=point[pos-1][cnt[pos]/2];
point[pos][cnt[pos]++]=i+1;
if(cnt[pos]>=(1 &lt; &lt; depth)) depth++;
if(!res) break;
}
if(res!=0)
{
printf("NO\n");
continue;
}
printf("YES\n");
for(int i=2;i<=n;i++) printf("%d ",fa[i]);
}
return 0;
}
 F. Moving Points
题目链接
 题目原文
1311F
 题目大意
在 XX 轴上有 nn 个点，每个点有一个初始坐标 xix_i 和一个速度 viv_i ，求问每每两个点对之间可能达到的最近距离之和，时间可以为正为负为零且不一定为整数。
 思路
感觉这道题的变形都有好多了，看完题就知道肯定是和时间没有关系的。
所以对于任意两个点 ii , jj ，假使 xi<xjx_i<x_j  分两种情况讨论：
  • vi≤vjv_i\leq v_j ，那么最近的时候就是初始位置时，对答案贡献为 xj−xix_j-x_i 。
  • vi>vjv_i>v_j ，那么一定会相遇，对答案贡献为 00 。
所以我们先对初始位置从小到大排序，再对速度离散化，用树状数组或者线段树维护一个前缀和，就好了。我没调出来的原因是计数的时候乘错地方了（后悔死）。
 代码
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
#include &lt; cstdio &gt;
#include &lt; cstring &gt;
#include &lt; algorithm &gt;
#define lowbit(x) (x&(-x))
using namespace std;
const int maxn=200005;
struct node
{
int x,v;
} a[maxn];
bool cmp(node a,node b) {return a.x<b.x;}
int cnt[maxn],n,b[maxn];
long long val[maxn];
void add(int x,int v)
{
for(int i=x;i<=n;i+=lowbit(i))
{
cnt[i]++;
val[i]+=(long long)v;
}
}
long long get(int x)
{
long long temp=0;
for(int i=x;i;i-=lowbit(i)) temp+=val[i];
return temp;
}
long long getc(int x)
{
long long temp=0;
for(int i=x;i;i-=lowbit(i)) temp+=cnt[i];
return temp;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i].x);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i].v);
b[i]=a[i].v;
}
sort(b+1,b+n+1);
int cnt=unique(b+1,b+n+1)-(b+1);
for(int i=1;i<=n;i++) a[i].v=lower_bound(b+1,b+cnt+1,a[i].v)-b;
sort(a+1,a+n+1,cmp);
long long ans=0;
for(int i=1;i<=n;i++)
{
ans+=a[i].x*getc(a[i].v)-get(a[i].v);
add(a[i].v,a[i].x);
}
printf("%lld\n",ans);
return 0;
}
round-624
        
            
        
        ]]>
    
    
    
      
      
        <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla