-1.前言

之前一直咕掉了， 这次把许多优质内容总结下，许多来自其他大佬的文章，底部有文章链接。

• 反向代理
• 负载均衡
• 动静分离

0.基本介绍

1.Web 服务器:

相比 Apache，Nginx 使用更少的资源，支持更多的并发连接，体现更高的效率，这点使 Nginx 尤其受到虚拟主机提供商的欢迎。能够支持高达 50,000 个并发连接数的响应，感谢 Nginx 为我们选择了 epoll and kqueue 作为开发模型.

2.负载均衡服务器

支持作为 HTTP代理服务器对外进行服务。Nginx用C编写,不论是系统资源开销还是 CPU 使用效率都比 Perlbal 要好的多。

3.作为邮件代理服务器

Nginx 同时也是一个非常优秀的邮件代理服务器（最早开发这个产品的目的之一也是作为邮件代理服务器），Last.fm 描述了成功并且美妙的使用经验.

4.优势

安装非常的简单，配置文件 非常简洁（还能够支持perl语法），Bugs非常少的服务器, Nginx 启动特别容易，并且几乎可以做到7*24不间断运行，即使运行数个月也不需要重新启动。你还能够在 不间断服务的情况下进行软件版本的升级。

1.基础内容

nginx  #启动nginxnginx -s reload  #根据最新配置重启nginxnginx -s stop  #立即停止nginxnginx -s quit #安全退出nginx -c /特定目录/nginx.conf  #以指定配置启动nginxnginx -t #检查配置是否正确nginx -t -c /特定目录/nginx.conf  #检查特定配置是否正确nginx -v #查看版本信息

Nginx默认的配置文件主要有 main、events、http、server、location 五个块组成。其中 http 、server、location 属于嵌套关系。

• main：主要控制Nginx子进程所属的用户和用户组、派生子进程数、错误日志位置与级别、pid位置、子进程优先级、进程对应cpu、进程能够打开的文件描述符数目等。
• events：控制Nginx处理连接的方式。
• http：Nginx处理http请求的主要配置块。
• server：Nginx中主机配置块，可用于配置多个虚拟主机。
• location：server中对应目录级别的控制块，可以有多个。

(0)关于nginx配置的一些说明

​ 通常web服务器放在反向代理的后面，这样就不能获取到客户的IP地址了，通过$remote_add$拿到的IP地址是反向代理服务器的iP地址。反向代理服务器在转发请求的http头信息中，可以增加x_forwarded_for信息，用以记录原有客户端的IP地址和原来客户端的请求的服务器地址。

#运行用户user nobody;#工作进程数worker_processes  1;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  info;#pid        logs/nginx.pid;#工作模式及连接数上限events {    #epoll是多路复用IO(I/O Multiplexing)中的一种方式,    #仅用于linux2.6以上内核,可以大大提高nginx的性能    use   epoll;     #单个后台worker process进程的最大并发链接数        worker_connections  1024;}http {    #设定mime类型,类型由mime.type文件定义    include    mime.types;    default_type  application/octet-stream;    #设定日志输出模板    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '                      '$status $body_bytes_sent "$http_referer" '                      '"$http_user_agent" "$http_x_forwarded_for"';    access_log  logs/access.log  main;    #sendfile 指令指定 nginx 是否调用 sendfile 函数（zero copy 方式）来输出文件，    #对于普通应用，必须设为 on,    #如果用来进行下载等应用磁盘IO重负载应用，可设置为 off，    #以平衡磁盘与网络I/O处理速度，降低系统的uptime.    sendfile     on;    #tcp_nopush     on;    #连接超时时间    #keepalive_timeout  0;    keepalive_timeout  65;    tcp_nodelay     on;    #开启gzip压缩    gzip  on;    gzip_disable "MSIE [1-6].";    #设定请求缓冲    client_header_buffer_size    128k;    large_client_header_buffers  4 128k;    #设定虚拟主机配置    server {        #侦听80端口        listen    80;        #定义使用 www.nginx.cn访问        server_name  www.nginx.cn;        #定义服务器的默认网站根目录位置        root html;        #设定本虚拟主机的访问日志        access_log  logs/nginx.access.log  main;        #默认请求        location / {            #定义首页索引文件的名称            index index.php index.html index.htm;           }        # 定义错误提示页面        error_page   500 502 503 504 /50x.html;        location = /50x.html {        }        #静态文件，nginx自己处理        location ~ ^/(images|javascript|js|css|flash|media|static)/ {            #过期30天，静态文件不怎么更新，过期可以设大一点，            #如果频繁更新，则可以设置得小一点。            expires 30d;        }        #PHP 脚本请求全部转发到 FastCGI处理. 使用FastCGI默认配置.        location ~ .php$ {            fastcgi_pass 127.0.0.1:9000;            fastcgi_index index.php;            fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;            include fastcgi_params;        }        #禁止访问 .htxxx 文件            location ~ /.ht {            deny all;        }    }}

​

(1)关于location

​ 其中location根据不同前缀的使用方式，大致分为普通location和正则location。多个正则location之间会按照先后顺序进行匹配，匹配成功后，就不会继续匹配后面定义的location。多个普通location之间遵循“最大匹配原则”，匹配度最高的location将会被执行，同时也可以利用 =精准匹配和 ^非正则匹配可以在正则匹配之前优先匹配，禁止执行原有的正则匹配。因此 当多种类型的 location 匹配同时出现时，最终执行结果为“= ”匹配优先于”^“匹配，“^~”匹配优先于正则匹配，正则匹配优先于普通的最大前缀匹配 只要优先的location 匹配成功，就不会执行其他的location 。

​ location指令的作用是根据用户请求的URI来执行不同的应用，也就是根据用户请求的网站URL进行匹配，匹配成功即进行相关的操作。
即：此模块专门将请求导向其他服务。

语法

1.精确匹配

location = / {   #精确匹配访问网站根目录}location = /login {   #精确匹配http://xxx.com/login}

2. ^~ 表示以什么打头，关键在于正则的开头符 ^

location ^~ /static/ {   #以/static打头，比如 http://xxx.com/static/jQuery.js}

3. 正则匹配(~ 区分大小写的正则， ~* 不区分大小的正则)

location ~ \.png {    #以png结尾，比如比如 http://xxx.com/img/a.png}location ~* \.png$ {    #以png或者PNG或者Png等等结尾，比如比如 http://xxx.com/img/a.pNg。如果是png结尾，会优先匹配上面一条。}

4.排除法的正则，同样区分大小写优先于不区分大小写

location !~ \.png$ {   #匹配“以png结尾”失败，进入location，那就情况多了去了，只要不以png结尾就行}location !~* \.xhtml$ {   #匹配“以png或者PNG或者PnG等等”结尾失败，进入location，那情况也多了去了，只要不是PNG的各种大小写变体就行}

5. 通用匹配

location / {   #用来兜底的，当前面其他所有的规则都不满足条件，就归入这个通用的}

总结就是如果$proxy_pass$ 结尾加上$/$则是绝对根路径，不会把匹配的路径部分带走，否则会带走。

(2)缓冲

nginx也提供了缓冲的机制，用于提高性能。没有缓冲的情况下，数据直接从后端服务器发送给客户端。缓冲的作用是在nginx上临时存储来自后端服务器的处理结果，从而可以提早关闭nginx到后端的连接，减少IO的损耗。一般内容存放在内存当中，但当内容过多，造成的内存不够时，会把内容存放在临时文件目录下。

(3)nginx配置多个配置文件

​ 需要在server中加：include config/*.conf;

(4)跨域

​ 跨域请求就是指：当前发起请求的域与该请求指向的资源所在的域不一样。这里的域指的是这样的一个概念：我们认为若协议 + 域名 + 端口号均相同，那么就是同域。

2.反向代理

​ 对于一个大型网站来说，随着网站访问量的快速增长，单台服务器已经无法承担大量用户的并发访问，必须以增加服务器的方式，提高计算机系统的处理能力，计算速度，进而满足当前业务量的需求。那么如何实现服务器之间的协同功能呢？Nginx提供的反向代理和负载均衡功能是一个很好的解决方案。

​ nginx的代理过程，就是将请求发送给nginx，然后将请求转发给后端服务器，后端服务器处理完毕之后将结果再发给nginx，nginx再把结果发送给客户端。后端服务器可在远程也可在本地，也可以是nginx服务器内部定义的其他虚拟主机。这些接收nginx转发的服务器被称为上游(upstream)使用nginx做代理的目的之一是扩展基础架构的规模。nginx可以处理大量并发连接，请求到来后，nginx可将其转发给任意数量的后台服务器进行处理，这等于将负载均衡分散到整个集群。

在Nginx服务器中，反向代理的配置非常简单，最主要的指令就是“proxy_pass”，用于设置后端服务器的地址。

server {        listen       80;       server_name  localhost;       location / {        proxy_pass http://localhost:9000;    }}

3.负载均衡

负载均衡就是将负载分摊到多个操作单元上执行，从而提高服务的可用性和响应速度，带给用户更好的体验。

Nginx默认支持轮询、权重、ip Hash等多种负载均衡策略。

• 轮询：默认设置方式，每个请求按时间顺序逐一分配到不同的后端服务器进行处理，可以自动剔除宕机服务器。
• 权重方式：利用weight指定轮询的权重比率，用于后端服务器性能不均的情况。
• ip_hash方式：每个请求按照IP的hash结果分配，这样可以让每个访客每次请求都访问同一个后端服务器，可以解决session共享的问题。
• 第三方模块：fair或url_hash等策略，nginx本身不包含该实现，需要下载对应的软件包。

客户端访问nginx的时候，只需要配置一个ip和一个端口，nginx帮助我们把请求转发不同的后台服务中。

如上配置 所有 http://localhost:80的请求都会被转发到http://localhost:9000。

轮询配置

server {        listen       80;       server_name  localhost;       location / {        proxy_pass http://web_server;    }}#配置负载均衡服务器组 轮询方式upstream web_server{      server  192.168.78.128;      server   192.168.78.129;}

权重方式配置

upstream web_server1{      server  192.168.78.128 weight=1;      server   192.168.78.129 weight=3;}upstream web_server2{      server  192.168.78.128 weight=1 max_fails=1 fail_timeout=2;      server   192.168.78.129 weight=3;     server 192.168.78.130   backup;}

按上图web_server1配置后，3/4的流量会转发到192.168.78.129的服务器上，1/4的流量会转发到192.168.78.128的服务器上,web_server2的配置表示 nginx在2s内发现后端服务异常达到max_fails次，就将该服务器标记为不可用。backup标记为预留的备份机器，当上面上个服务都宕机时，会将流量转发到备份机器。

IP Hash方式

upstream web_server1{      ip_hash;      server  192.168.78.128;      server   192.168.78.129;      server   192.168.78.130 down;}

down参数可以将服务器标记为下线状态，在路由分配时，会忽略该服务器。

参考文章

https://blog.csdn.net/qinqinde123/article/details/89448076

https://blog.csdn.net/tjcyjd/article/details/50695922

https://www.cnblogs.com/jasonbourne3/p/14099700.html

https://www.cnblogs.com/jasonbourne3/p/14099717.html

传送门

https://codeforces.ml/problemset?order=BY_RATING_ASC&tags=math%2Cnumber+theory%2C1800-3000

D. Dima and Lisa

哥德巴赫猜想习题

判断奇数$n$是否能分解为至多$3$个素数之和。

1个素数的情况：本身为质数，$\sqrt{n}$特判。

2个素数的情况：奇=奇+偶，显然只需特判$2,n-2$是否为质数即可。

3个素数的情况：根据弱哥德巴赫猜想：大于$7$的奇数可分解为$3$个质数之和。

我们就先找到小于$n$的最大质数，然后减去它，这样$n$就很小且$n$为偶数。

根据强哥德巴赫猜想：大于$2$的偶数可分解两个质数之和。然后暴力找就可以了。

bool ck(int n){    int mx=sqrt(n);    for(int i=2;i<=mx;i++)        if(n%i==0) return false;    return true;}int main(){    int n;    scanf("%d",&n);    if(ck(n)) return printf("1\n%d\n",n),0;    if(ck(n-2)) return printf("2\n2 %d\n",n-2),0;    for(int i=n-2;i>=2;i-=2){        if(ck(i)){            int x=n-i;            for(int j=x-2;j>1;j--)                if(ck(j)&&ck(x-j)){                    printf("3\n%d %d %d\n",i,j,x-j);return 0;                }        }    }    return 0;}

D. Same GCDs

$gcd$和欧拉函数定义。

$gcd(a,m)=g=gcd(gk_1,gk_2)=g$

$gcd(k_1,k_2)=1$

$gcd(a+x,m)=gcd((a+x)\pmod{m},m)=g$

$x’=(a+x)\bmod m \in[0,m-1]$

$gcd(a+x,m)=gcd(x’,m)=g$

$x’=x’’g,m=m’g$

$gcd(x’’,m’)=1$

$0\le x’<m\Rightarrow 0\le x’’<m’$

即：$ans=\varphi(m’)$

$\sqrt{n}$求$\varphi(m’)$即可。

ll phi(ll m){    ll s=m;    for(ll i=2;i*i<=m;i++)        if(m%i==0){            s-=s/i;            while(m%i==0) m/=i;        }    if(m>1) s-=s/m;    return s;}    scanf("%d",&t);while(t--){        scanf("%lld%lld",&a,&m);        ll g=__gcd(a,m);m/=g;        printf("%lld\n",phi(m));    }

C. Neko does Maths

$lcm(a+k,b+k)$ 最小，且$k$尽可能小。

令$g=gcd(a+k,b+k)$

令$ans=lcm(a+k,b+k)=\dfrac{(a+k)(b+k)}{g}$

$g=gcd(b-a,a+k)$

枚举$g|(b-a)$，只用在$(b-a)$的因子枚举，然后找到满足$g|(a+k)$的最小$k$，每次比较$lcm$，更新答案$k$。

复杂度：$O(\sqrt{b-a})$

ll a,b;ll ans=1e18,k,d;void f(ll x){    ll y=(a+x-1)/x*x;    ll lcm=y/x*(y+d);    if(lcm<=ans) ans=lcm,k=y-a;}int main(){    scanf("%lld%lld",&a,&b);    if(a>b) swap(a,b);  d=b-a;    for(ll i=1;i*i<=d;i++)        if(d%i==0) f(i),f(d/i);    printf("%lld\n",k);    return 0;}

1225D. Power Products

$\large ab=x^k,k\ge 2$

$\large a=x^{p_1},b=x^{p_2},p_1+p_2=k,(p_1,p_2\ge 0)$

对其进行质因数分解，并对指数$\pmod{k}$，则只需寻找质因数指数之和为$k$的数即可，这样我们可以用一个数组储存当前出现过的数，每次需要的数个数就是答案。

$a=p_1^{k_1}p_2^{k_2}\dots p_m^{k_m},b=p_1^{g_1}p_2^{g_2}\dots p_m^{g_m}$

则$k_i+g_i=k$

int n,k;int a[N];ll now,need;ll ans;void f(int x,int c){    c%=k;    int u=c,v=(k-c)%k;    while(now&&u--){        now*=x;        if(now>N) now=0;    }    while(need&&v--){        need*=x;        if(need>N) need=0;    }}int main(){    scanf("%d%d",&n,&k);    for(int i=1;i<=n;i++){        now=need=1;        int x;scanf("%d",&x);        int mx=sqrt(x);        for(int i=2;i<=mx;i++)            if(x%i==0){                int c=0;                while(x%i==0) c++,x/=i;                f(i,c);            }        if(x>1) f(x,1);        ans+=a[need];        a[now]++;    }    printf("%lld\n",ans);    return 0;}

时间复杂度：$O(n\sqrt{n})$

A. Nezzar and Board

裴蜀定理

https://harris.blog.csdn.net/article/details/113389644

B. Remainders Game

$x_1\equiv x_2\bmod c_i$

则$x_1-x_2\equiv 0\bmod {c_i}$

则$lcm(c_1,c_2\dots,c_n) | (x_1-x_2)$

而$(x_1-x_2)\pmod {k}\ne 0$

所以$lcm(c_1,c_2\dots,c_n)\pmod{k}\ne 0$

同时也是充要条件，构造$x=lcm(c_2,c_2\dots,c_n),y=2lcm(c_1,c_2\dots,c_n)$

为了防止$lcm$爆$long \ long$，可以一边$lcm$一边和$k$取$gcd$。最后看答案是否为$k$即可。

或者线筛一波，找到每个数的最大质因数，预处理出$lcm$的质因数分解。然后判断减掉$k$的所有质因数后是否还有多余的质因数。

ll gcd(ll a,ll b){    return !b?a:gcd(b,a%b);}ll lcm(ll a,ll b){    return a/gcd(a,b)*b;}int main(){    int n,k;scanf("%d%d",&n,&k);    ll s=1;    for(int i=1;i<=n;i++){        ll x;scanf("%lld",&x);        s=gcd(k,lcm(s,x));    }    puts(s==k?"Yes":"No");    return 0;}

894B. Ralph And His Magic Field

当$n,m$奇偶性不同且$k=-1$无解，因为所有数的乘积按照行和列分别算是不同的。

否则，考虑填完前$n-1$行和前$m-1$列，一共有：$2^{(m-1)(n-1)}$种方案。

最后一行和最后一列是确定的。

ll ksm(ll a,ll n,ll m=mod){    ll s=1;    while(n){        if(n&1) s=s*a%m;        a=a*a%m;        n>>=1;    }    return s;}ll n,m,k;int main(){    scanf("%lld%lld%lld",&n,&m,&k);    if(((n+m)&1)&&k==-1) puts("0");    else printf("%lld\n",ksm(ksm(2,n-1),m-1));    return 0;}

B1. Send Boxes to Alice (Easy Version)

枚举$k$ ，必然是$cnt_1$的因数较小的部分，然后分段模拟，每取移到一段的终点是最优的，最后取最小值即可。

code

vector<int>v;ll ans=2e18;void f(int x){    ll s=0;    int mx=SZ(v);    for(int i=0;i<mx;i+=x){        int p=v[(i+i+x-1)/2];        for(int j=i;j<i+x;j++)            s+=abs(p-v[j]);    }    ans=min(ans,s);}int main(){    scanf("%d",&n);    for(int i=1;i<=n;i++){        int x;scanf("%d",&x);        if(x) v.pb(i);    }    sz=SZ(v);    if(sz==1) return puts("-1"),0;    for(int i=2;i*i<=sz;i++)        if(sz%i==0){            f(i);            while(sz%i==0) sz/=i;        }    if(sz>1) f(sz);    printf("%lld\n",ans);     return 0;}

C. Line

$ax+by+c=0$，求$x,y$整数解。这不扩欧$sb$题吗。一开始居然没看出来

void exgcd(ll a,ll b,ll &x,ll &y){    if(!b) {x=1,y=0;return;}    exgcd(b,a%b,y,x);    y-=a/b*x;}int main(){    scanf("%lld%lld%lld",&a,&b,&c);    c=-c;    ll g=__gcd(a,b);    if(c%g) return puts("-1"),0;    ll t=c/g;    ll x,y;    exgcd(a,b,x,y);    x*=t,y*=t;    ll b1=b/g*t,a1=a/g*t;    while(x<-5e18&&b1>0){ //这一步还可以优化        x+=b1;        y-=a1;    }    if(x<-5e18||y>5e18) return puts("-1"),0;    printf("%lld %lld\n",x,y);    return 0;}

963A. Alternating Sum

给了前$k$项，发现递推关系是$\large A_i=A_{i-k}(\dfrac{b}{a})^k$

$\large A_i=s_ia^{n-i}b^i,A_{i-k}=s_{i-k}a^{n-i+k}b^{i-k}$

$\large A_i=A_{i-k}(\dfrac{b}{a})^k$

显然可预处理$[A_0,A_{k-1}]$和他们的和。

$s=\sum\limits_{0}^{k-1} A_i$

$\sum\limits_{i=k}^{2k-1}=s\times (\dfrac{b}{a})^k$

是一个等比数列，令$q=(\dfrac{b}{a})^k$。

$cnt=\dfrac{n+1}{k}$

$sum=\dfrac{s(1-q^{cnt})}{1-q}$

余项暴力求。$q=1$ 需特判，因为此时分母为$0$了。

int main(){    scanf("%lld%lld%lld%lld",&n,&a,&b,&k);    ll inv=ksm(a,mod-2);    ll q=ksm(b*inv%mod,k);    scanf("%s",s);    ll sum=0;    for(int i=0;i<k;i++){        if(s[i]=='+'){            sum=(sum+ksm(a,n-i)*ksm(b,i)%mod)%mod;        }        else {            sum=(sum-ksm(a,n-i)*ksm(b,i)%mod)%mod;        }    }    sum=sum<mod?sum+mod:sum;    ll cnt=(n+1)/k;    ll tot;    if(q==1){        tot=sum*cnt%mod;    }    else tot=sum*(1-ksm(q,cnt))%mod*ksm(1-q,mod-2)%mod;    ll rest=(n+1)%k;    for(int i=n-rest+1;i<=n;i++){        int j=i%k;        if(s[j]=='+'){            tot=(tot+ksm(a,n-i)*ksm(b,i)%mod)%mod;        }        else tot=(tot-ksm(a,n-i)*ksm(b,i)%mod)%mod;    }    printf("%lld\n",tot);    return 0;}

359C. Prime Number

$p$为质数，答案为$p^k$

对每个分子$v_i=sum-a_i$排序，从大到小，然后每次从后往前把相同的小的取出来，看个数是否$\pmod {x}=0$，如果不满足答案就是$p^{w}$。

否则合并一下，丢$\dfrac{cnt}{x}$个 $w+1$进去。

    for(int i=1;i<=n;i++)        v.pb(sum-a[i]);    sort(v.rbegin(),v.rend());    while(1){        ll w=v.back();        ll cnt=0;        while(!v.empty()&&v.back()==w){            cnt++;v.pop_back();        }        if(cnt%x){            w=min(w,sum);            printf("%lld\n",ksm(x,w));            return 0;        }        else {            cnt/=x;            for(int i=0;i<cnt;i++)                v.pb(w+1);        }    }

A 构造

显然当$tot=x$时无解。

当$tot\ne x$时肯定有解，考虑当$prefix(i)=x$时，因为题目限制$a_i$各不相同，所以我们交换$a_i,a_{i+1}$，注意到因为$a_n\ne x$，所以$i<n,i+1$存在。

B 数学

考虑面积的合法性：设用了$n$个三角形，边长为：$a+\sqrt{2}b$，因为只有这两种长度。

$n\times \dfrac{1}{2}=(a+\sqrt{2}b)^2=a^2+2b^2+\sqrt{2}ab$。

显然$\sqrt{2}ab=0$，且$n$为偶数才成立。

所以要么$a=0$，要么$b=0$。

当$b=0$，

由若干个$1\times 1$的正方形拼成，即答案为$2x$，$x$是平方数。

同理：当$a=0$时，答案是$4x$。

C 贪心

依题意，必定有解，可用反证法证，然后贪心每次选当前最小的加。

D 贪心

先把已经匹配的丢掉，然后不妨设剩下的$l\ge r$，因为等价，然后在维持$l\ge r$下，每次计算把相同颜色对数折半贡献。这样的正确性是如果不维持$l\ge r$，就会导致多算一段贡献，因为最后还是要把剩下的$l,r$相等。

for(int i=1; i <= n; i++) lc[i] = rc[i] = 0;        for(int i=1; i <= n; i++) cin>>c[i];        for(int i=1; i <= l ;i++) lc[c[i]]++;        for(int i = l+1; i <= n ;i++) rc[c[i]]++;        ll ans=0;        for(int i=1 ;i<=n;i++){            int mn=min(lc[i],rc[i]);            lc[i]-=mn,rc[i]-=mn;            l-=mn,r-=mn;        }        if(l<r) swap(l,r),swap(lc,rc);        for(int i=1 ;i <= n; i++){            int cha = l - r;            int ke = lc[i] >> 1;            int mn = min(cha , ke << 1);            ans += mn>>1,l -= mn;        }        ans+=(l-r)/2+(l+r)/2;        cout<<ans<<'\n';

好菜呀。qwq

​ 这个原理称为“如无必要，勿增实体”，即“简单有效原理”。正如他在《箴言书注》2卷15题说“切勿浪费较多东西去做，用较少的东西，同样可以做好的事情。”

• 在生活中，尽量用较少的假设和条件解决问题。

• 在编程中，尽量用更简洁，直接的代码逻辑解决问题。

• 但是注意能随便剔除条件，也不能剔除必要条件。

学习博客：

https://blog.csdn.net/bjweimengshu/article/details/116141374?utm_source=app&app_version=4.5.8

​ 古希腊则学家爱比克泰德曾经说过的一句著名的话：”我们登上并非我们所选择的舞台，演出并非我们所选择的剧本”。在座的有哪个同学是自愿来到这个世界上的，其实没有。“我们登上并非我们所选择的舞台”，在座的有谁的剧本是你自己设定的，其实不是的。仔细想一想，我们这一生中其实自己能决定的东西很少，我们可能只能决定5%的东西，但有95%的东西是我们决定不了的，我们决定不了我们的出身，我们决定不了我们的智商，我们更决定不了我们这一生的贵人相助。很多时候我们经常会羡慕别人的剧本，我自己有时候也非常羡慕别人的剧本，但是（其实）没有谁的剧本值得羡慕，你只能把你自己的剧本演好。如果在你的一生中真的遭遇到这些挫折，那对不起，这就是你的剧本。有两种选择，一种选择是弃演，一种选择是把既定的剧本给演好。所以希望大家能够演好自己的剧本。

经过测试，保存hexo-asset-image 配合 上传到服务器上的图片的加载速度，没有github+cdn加速块。

所以最终我还是决定用github+cdn加速，然后服务器和github双线部署。

利用github+cdn加速的方法。

首先：在对应主题下的_config 文件下开启cdn加速

jsDelivr:  url: 对应的仓库http: url  #　我的　https://cdn.jsdelivr.net/gh/Harris-H/Harris-H.github.io

然后在本地的hexo目录建一个专门用来储存的文件夹

我的是:

然后每次要上传图片时,就先本地保存到这个目录下,然后引用时候的url 前缀就是cdn加速后的地址:

我的是:

https://cdn.jsdelivr.net/gh/Harris-H/Harris-H.github.io/img/文件名

然后deploy以后,就可以看到自己的图片了.

关于利用插件+服务器上传图片的我有一篇文章有介绍.

https://he-hao.top/2021/04/15/upload-picture-to-server/

我终于解决了使用hexo-asset-image 上传图片的问题

1.安装hexo-asset-image

npm install hexo-asset-image --save

2.将hexo本地根目录下的_config.yml 修改

post_asset_folder: true

3.修改该插件目录下的index.js文件

'use strict';var cheerio = require('cheerio');// http://stackoverflow.com/questions/14480345/how-to-get-the-nth-occurrence-in-a-stringfunction getPosition(str, m, i) {  return str.split(m, i).join(m).length;}hexo.extend.filter.register('after_post_render', function(data){  var config = hexo.config;  if(config.post_asset_folder){    var link = data.permalink;    var beginPos = getPosition(link, '/', 3) + 1;    var appendLink = '';    // In hexo 3.1.1, the permalink of "about" page is like ".../about/index.html".    // if not with index.html endpos = link.lastIndexOf('.') + 1 support hexo-abbrlink    if(/.*\/index\.html$/.test(link)) {      // when permalink is end with index.html, for example 2019/02/20/xxtitle/index.html      // image in xxtitle/ will go to xxtitle/index/      appendLink = 'index/';      var endPos = link.lastIndexOf('.');    }    else {      var endPos = link.lastIndexOf('/');    }    link = link.substring(beginPos, endPos) + '/' + appendLink;    var toprocess = ['excerpt', 'more', 'content'];    for(var i = 0; i < toprocess.length; i++){      var key = toprocess[i];      var $ = cheerio.load(data[key], {        ignoreWhitespace: false,        xmlMode: false,        lowerCaseTags: false,        decodeEntities: false      });      $('img').each(function(){        if ($(this).attr('src')){          // For windows style path, we replace '\' to '/'.          var src = $(this).attr('src').replace('\\', '/');          if(!(/http[s]*.*|\/\/.*/.test(src)            || /^\s+\//.test(src)            || /^\s*\/uploads|images\//.test(src))) {            // For "about" page, the first part of "src" can't be removed.            // In addition, to support multi-level local directory.            var linkArray = link.split('/').filter(function(elem){              return elem != '';            });            var srcArray = src.split('/').filter(function(elem){              return elem != '' && elem != '.';            });            if(srcArray.length > 1)            srcArray.shift();            src = srcArray.join('/');            $(this).attr('src', config.root + link + src);            console.info&&console.info("update link as:-->"+config.root + link + src);          }        }else{          console.info&&console.info("no src attr, skipped...");          console.info&&console.info($(this));        }      });      data[key] = $.html();    }  }});

4.以后每次可以hexo n “文章名” ，会在_posts下自动生成一个同名文件夹用来放图片。

5.图片的markdown 格式为:

6.测试

上传到服务器F12看url

7.本文的图片就是通过该方式上传的。

更新一下，我的github+cdn加速好了，貌似这更快一点。

结构体LIS的问题

已解决

对于$n^2$可以解决的$LIS$问题，可以记录答案数组。

结构体LIS问题，利用二维偏序即可。

记忆化搜索实现起来更加方便，复杂度可能偏大，(递归)。

$O(nlogn+n)$实现LIS加上输出对应答案数组，注意LIS的d[]数组储存的是对应LIS长度的最小末尾元素，要输出答案数组还需要记录每个元素对应的LIS长度。

https://harris.blog.csdn.net/article/details/106444512

$dp$的常见范围 $n^2 (5\times 10^3,10^3)$

https://codeforces.ml/problemset/page/21?tags=dp,1500-2000

子串问题

$n(10^6)$

$O(n)$的递推问题，可能需要用到辅助数组，栈来递推。

如括号匹配的dp问题。

子串的dp问题，往往是类似区间合并，利用辅助数组来合并状态。

C. Looking for Order

状压的好题，跟顺序没有关系，所以可以直接剪枝跑。

给定一棵二叉搜索树的形态和序列，对应的填数是唯一确定的。

D. How many trees? 本题由上述知识可知，题意转化为求$n$个结点组成高度$\ge h$的二叉树形态个数。

树形dp问题：求不相交两个路径最大乘积。

枚举割边，分成两个连通块，然后dfs求两个连通块的直径乘积。

维护一个最大和次大子结点路径。

sum表示该子树的直径：分情况讨论，经过该结点，不过经过该节点。

int dp;int dfs(int u,int fa){    int sum=0,mx1=0,mx2=0;    for(int v:e[u]){        if(v==fa) continue;        sum=max(sum,dfs(v,u));//不经过该结点.        if(dp+1>mx1) mx2=mx1,mx1=dp+1;        else if(dp+1>mx2) mx2=dp+1;     }    sum=max(sum,mx1+mx2),dp=mx1;    return sum;} 

https://codeforces.ml/problemset/problem/14/E

多维dp问题。

波峰，波谷，需要维护最后两个变量来递推。

https://codeforces.ml/contest/16/problem/E

状压dp解决概率问题的好题。

貌似还有一个递推求二进制1的方法。

https://leetcode-cn.com/problems/counting-bits/solution/bi-te-wei-ji-shu-by-leetcode/

复习一波：

int cnt=0;while(x) x&=x-1,cnt++;return cnt;for(int i=1;i<=n;i++)    //O(n)    bit[i]=b[i>>1]+(i&1);for(int i=1;i<=n;i++)    //O(n)解决.    bit[i]=bit[i&(i-1)]+1;

贪心+高精度

https://codeforces.ml/contest/18/problem/D

遇到贡献为2^x 的最值问题，考虑贪心。因为$2^x>2^{x-1}+2^{x-2}\dots 2^2+2^1+2^0$.

此题给贡献从大到小排序，然后贪心地选择，每选择一就将该区间标记。

然后高精度加法预处理 $2^x=2^{x-1}+2^{x-1}$。

https://codeforces.ml/contest/18/problem/E

dp的好题，按行dp，因为每行必须两种颜色，$dp[i][x][y]$

尺取，队列维护区间的答案。

https://ac.nowcoder.com/acm/contest/9983/B

//V>=n下的最小价值,一个限制条件+物品选不选的问题(01背包)

把一个序列切一刀分成两个和相等的子数组，枚举切的位置即可。

把一个序列切两刀分成三个和相等的子数组的方案数：因为子数组的和是可以确定的：$\dfrac{sum}{3}$，然后求可以预处理出前后缀和，后缀和等于$\dfrac{sum}{3}$的个数，枚举对于每个前缀和$=\dfrac{sum}{3}$的位置$i$，有多少个$suf[j]=\dfrac{sum}{3},j\ge i+2$。

==Hint：把一个序列分成两个不相交且非空的和相等子数组的方案数？==

一个暴力的想法，枚举所有区间，然后找另外相等区间与其相等的个数。

复杂度大约在：$O(n^4)$。。。。

求最大零矩阵周长。

暴力$O(nm)^3$，考虑类似二维前缀和$dp$优化。

确定起始点$(i,j)$，终点$(x,y)$成立的条件是$a[x][y]=0$且$dp[x-1][y]$成立且$dp[x][y-1]$成立。

时间复杂度：$O(nm)^2$。

https://leetcode-cn.com/problems/maximum-points-you-can-obtain-from-cards/

滑动窗口经典题，维护定长区间的和，找到最值。

https://www.luogu.com.cn/problem/U148619?contestId=40088

断环成链，ST表预处理出区间最值，然后二分找到len. [x-len,x+len]，注意因为i!=j,所以是找[i-len,i-1],[i+1,i+len]的区间最值。

ST表习题待练习。

分块(暴力大法好！)待学。

https://www.luogu.com.cn/blog/cyffff/ti-xie-t2-diao-da-post

https://atcoder.jp/contests/abc191/tasks/abc191_c

这是什么神仙思维题？？

并查集重新建图跑dfs，注意标记边剪枝叶。

计算sz的时候可以不用再合并的时候算，而是类似桶把s[i]扫一遍。

spfa 可求最长路判正环，求最短路判负环。

背包问题，不能按$\dfrac{value}{weight}$的比值排序贪心做。

只有两种$weight$的背包问题，只需要分组，然后按$value$从大到小排序，然后第一组的个数，确定第二组的个数，取最值即可。

最小有向边生成树，很简单，除了根之外其他每个结点有且仅有一个父亲，所以存一下每个结点的最小边权父亲，然后除了根之外求和。

神奇构造题，用$1\times 2,2\times 1,2\times 2$填矩阵$n\times m$。

1.矩阵面积得为奇数。

2.$n,m$若存在奇数：

$n$为奇数，至少要$a-=\dfrac{m}{2}$

$m$为奇数，至少$b-=\dfrac{n}{2}$。

然后先假设都用$c$涂，一个小$tips$，$4$个$4$个的涂，且相连小正方形不同色，这样便于后面$a,b$来覆盖。

类似归并排序的模拟 比赛排名题，不是很熟。

每轮相邻的人比赛，最开始$(1,2)(3,4)(5,6)\dots$，胜者相邻后的继续比。

则第$k$轮可能比赛的人是$[(x-1)2^k+1,x2^k]$。

都减$1$,$[(x-1)2^k,x2^k-1]$

如何确定两个人是否能在第$k$轮遇到$:\dfrac{a-1}{2^k},\dfrac{b-1}{2^k}$。

构造题杀我。

傻逼树上博弈杀我。

思维杀我。

傻逼数学。

暴力dp是啥玩意，数据结构玩不动。

https://baike.baidu.com/item/%E7%93%B6%E9%A2%88%E7%94%9F%E6%88%90%E6%A0%91/2397900

最小生成树一定是瓶颈生成树。

BZOJ2429

最小支撑树？

https://blog.csdn.net/twtsa/article/details/8120269

极大化子矩形 论文。

悬线法 $O(nm)$

求最大不含障碍的子矩形。

枚举每个点向上扩展的最大高度(矩形的宽)$up[i][j]$，这个递推即可。

然后该悬线能向两边扩展的最大长度(矩形的长)。

递推$l[i][j]=l[i][j-1],r[i][j]=r[i][j+1]$。

$ans=max(ans,up[i][j]\times (r[i][j]-l[i][j]+1))$。

https://www.cnblogs.com/zhenglw/p/10102833.html

单调栈也可解决，还是需要预处理$up[i][j]$，

一行一行的维护，维护一个单调递增栈，当前待处理的矩形高如果$\le$栈顶就更新答案，然后弹出。

基环树，省选-黑题难度，待学。

https://www.luogu.com.cn/blog/ShadderLeave/ji-huan-shu-bi-ji

https://www.luogu.com.cn/blog/xww666/post-tuan-dui-t167649-qu-ti-xie

期望dp，树上高斯消元。

树形dp，好难写。

费用流问题

取反边的费用还有讲究吗？

神仙路径统计问题

https://www.luogu.com.cn/blog/wolfind/yi-suo-ge-lu-jing-ji-shuo-wen-ti

https://leetcode-cn.com/problems/longest-repeating-character-replacement/

滑窗

Hash需要练习

求两点斜率的更好写法。！

会不会有精度误差。

类似线段树的区间修改 lzay tag一样。

树也可以实现 lazy 标记子树操作加。

要初始化才能用。—-

leetcode 的isalpha 大小写都只会返回1024 醉了。

multiset 能logn 维护区间的最大，最小值。

两个单调队列能O(1) 维护最大，最小值。

单调队列能解决的问题：

区间最值。

dp优化：转移时：$dp[i]=max(dp[j])+a[i] ,j\in[l,r]$

区间平均值最大的区间长度 。

假了：肯定是最大那一个数，长度为1是最优的。

定区间 最大值最小。

​ 最小值最大。

常数优化：连续访问内存

$a[20][N]$优于$a[N][20]$。

网络流解决区间差分问题。

关于max,min 的宏定义问题

#define Max(a,b) a>b?a:b#define Min(a,b) a<b?a:bd

一般变量，宏定义较快，若参数为函数，因为宏定义在比较时会计算一次，返回计算值时也会计算一次，所以函数会执行两次，若为递归函数，则时间非常可怕。

所以一般还是用自带的比较函数。

lucas定理。

分形递归题。

二维矩形并，交，周长，面积，重合问题。

扩欧复杂度 ？ log(a+b)

EK EK EK EK 写板子

Dinic Dinic Dinic Dinic

用了IOS 之后不能用puts 了，不然会出错。

用若干变量初始化 vector

vector<int>v={a,b,c};

表达式排序

sort(a.begin(),a.end(),[](const auto &b,const auto &c){            return b[0]==c[0]?b[1]>c[1]:b[0]<c[0];        });

CDQ CDQ CDQ CDQ 分治

有向图求入度为0的点的个数，可以用floyd或者tarjan

并查集可用于无向图判环(因为并查集能维护双向关系)，但是不能判自环，因为初始赋值就是。

种类并查集 可以维护 敌对关系，朋友关系，单向关系。

两个栈实现 队列，一个栈为输入栈，另一个栈为输出栈，当输出栈不为空时 pop,peek操作直接取输出栈的栈顶，否则把输入栈的元素都丢入输出栈。

质因数分解求所有质因数复杂度最坏是$\sqrt{n}$的，如$n$为质数。

用埃氏筛可以$O(nloglogn)$预处理出每个数的所有质因数。

循环数组 仍然可以用单调栈求向左/右 第一个比它大/小的元素 ，只需要断环成链即可。

==期望dp==

一般是倒着。

==区间 MEX==

Treap(待复习)

https://www.luogu.com.cn/record/list?user=257206&language=&orderBy=0&page=6

除0错误 也会导致RE

组合数+周期+取模 等问题！

生成函数—–

$n$个结点的二叉树个数$C_n$卡特兰数，$n$个结点所有不同二叉树的叶子总数$nC_{n-1}$

A

考虑两个人，显然选择相同不会影响，只考虑选择不同的题目个数$cnt$，注意到cnt为奇数才不可能分数相同，考虑他们选择$1$的奇偶性，相同不会影响奇偶性，不同必然会使一个人选择$1$的奇偶性发生变化，当$cnt$为奇数时，最后两个人选择1的奇偶性必然是不同的，所以把所有人按照选择$1$的奇偶性分成两个集合，然后相乘即为答案。

时间复杂度：$O(nm)$

hint

考虑对称问题：满足学生答案可能相同的对数。

$cnt$为偶数才成立，而且他们选择$1$的奇偶性最后是相同的，所以答案是：

$C_{cnt_0}^2+C_{cnt_1}^2$

code

for(int i=1;i<=n;i++){        scanf("%s",s);int x=0;        for(int j=0;j<m;j++)            x+=s[j]=='1';        a[x&1]++;    }printf("%lld\n",1LL*a[0]*a[1]);

B

考虑若$a,b$答案存在，则$a$同时减小一个数$m$，$b$同时增大一个数$m$是不影响答案的，所以$a$的最小值可以为$0$，此时我们可以令$b_1$为第一列最小的数，这样就能构造出$a$的最小值为$0$，然后暴力特判即可。

时间复杂度：$O(n^2)$

code

b[0]=c[0][0];    for(int i=1;i<n;i++) b[0]=min(c[i][0],b[0]);     for(int i=0;i<n;i++) a[i]=c[i][0]-b[0];    for(int i=0;i<n;i++) b[i]=c[0][i]-a[0];    for(int i=0;i<n;i++){        if(b[i]<0) return puts("No"),0;        for(int j=0;j<n;j++){            if(a[i]+b[j]!=c[i][j]) return puts("No"),0;        }        }    puts("Yes");

C

质因数分解，按照质因数的个数来赋值,因为倍数关系的质因数肯定不同，然后设$a_1=1$即可满足最小。

code

bitset<N>vis;int p[N],cnt,a[N];void ss(int n){    vis[0]=vis[1]=1;    a[1]=1;    for(int i=2;i<=n;i++){        if(!vis[i]) p[++cnt]=i,a[i]=2;        for(int j=1;j<=cnt&&i*p[j]<=n;j++){            vis[i*p[j]]=1;            a[i*p[j]]=a[i]+1;            if(i%p[j]==0) break;        }    }}

https://github.com/Harris-H/Examination

已上传至GitHub。

​ $10^5$，考虑$O(n),O(nlogn)$

因为没有单调性，考虑贪心$O(n)$

枚举答案。

如果$sum>ans$ 考虑用$6,5,4\dots ,2$ 按顺序减差值。

否则用$1,2,3,4,5$逆序减差值。

class Solution {public:     int fun(vector<int>&h,int s){        int sum=0,ans=0;        for(int i=1;i<7;i++) sum+=h[i]*i;        if(sum>s){            int x=sum-s;            for(int i=6;i>1;i--){                int t=i-1;                if(t*h[i]>=x) return ans+(x+t-1)/t;                x-=t*h[i];                ans+=h[i];             }        }        else {            int x=s-sum;            for(int i=1;i<6;i++){                int t=6-i;                if(t*h[i]>=x) return ans+(x+t-1)/t;                x-=t*h[i];                ans+=h[i];            }        }        return ans;    }    int minOperations(vector<int>& a, vector<int>& b) {        int n=a.size(),m=b.size();        if(n>m) return minOperations(b,a);        if(6*n<m) return -1;        vector<int>c(7),d(7);        int ans=1e9;        for(auto i:a) c[i]++;        for(auto i:b) d[i]++;        for(int i=m;i<=6*n;i++){            ans=min(ans,fun(c,i)+fun(d,i));        }        return ans;    }};

5692. 车队 II

凸包维护。

class Solution {public:    struct node{        double x,y;    };    double cross(node &a,node &b,node&c){        return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y);    }    vector<double> getCollisionTimes(vector<vector<int>>& a) {        int n=a.size();        vector<node>s(n+1);         vector<double> ans(n);        int top=0;        for(int i=n-1;~i;i--){            node c={1.0*a[i][0],1.0*a[i][1]};            while(top>=2&&cross(c,s[top],s[top-1])<=0) top--;            if(!top) ans[i]=-1;            else {                auto &d=s[top];                if(c.y<=d.y) ans[i]=-1;                else {                    ans[i]=(d.x-c.x)/(c.y-d.y);                }            }            s[++top]=c;        }        return ans;    }};

C.构造

D.期望

期望dp一般倒序转移！！！！！

E.bfs

剪纸bfs，跑一次瞬移后应清空。

F.背包

二分+暴力

思路

​ 对第一个数组进行操作，特判修改$0$次和修改$1$次，若都不成立，则特判修改两次，当前数组若与$a[0]$有超过$4$个不一样则无解，小于$3$个不管，否则若有解，必定要修改不同的两个，然后特判。

代码

// Problem: E. Almost Fault-Tolerant Database// Contest: Codeforces - Codeforces Round #704 (Div. 2)// URL: https://codeforces.com/contest/1492/problem/E// Memory Limit: 512 MB// Time Limit: 2000 ms// Date: 2021-02-23 17:05:42// --------by Herio--------#include<bits/stdc++.h>using namespace std;typedef long long ll;typedef unsigned long long ull; const int N=1e3+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb emplace_back void Print(int *a,int n){    for(int i=1;i<n;i++)        printf("%d ",a[i]);    printf("%d\n",a[n]); }int n,m;vector<vector<int> >a;void check(vector<int>ans,bool f){    for(int i=0;i<n;i++){        int c=0;        for(int j=0;j<m;j++){            if(ans[j]!=a[i][j]) c++;            if(c>3) return;    //超过修改一次.        }        if(c>2){    //需要修改一次.            if(f) return;    //如果修改过一次后还需要修改 说明该情况要修改两次.            for(int j=0;j<m;j++){                if(ans[j]!=a[i][j]){                    vector<int>tmp=ans;                    tmp[j]=a[i][j];                    check(tmp,1);                }            }            return;        }    }    puts("Yes");    for(int j=0;j<m;j++) printf("%d ",ans[j]);    exit(0);}int main(){    scanf("%d%d",&n,&m);    a.resize(n,vector<int>(m));    for(int i=0;i<n;i++)        for(int j=0;j<m;j++) scanf("%d",&a[i][j]);    check(a[0],0);//特判a[0] 一次都不用修改和只修改一次两种情况.    for(int i=0;i<n;i++){        vector<int>dif;        for(int j=0;j<m;j++)            if(a[i][j]!=a[0][j]) dif.pb(j);        int sz=(int)dif.size();        if(sz>4) return puts("No"),0;//超过4不成立.        if(sz<=2) continue;//小于3不用管.        for(int x:dif)    //否则修改两个位置.            for(int y:dif){                vector<int>tmp=a[0];                tmp[x]=a[i][x],tmp[y]=a[i][y];                check(tmp,0);            }        break;    }    puts("No");    return 0;}

前言

​ 虽然小号上分了，但我很伤心，因为……..

​ 我放假能不能上紫呢！？

题解

A. Bovine Dilemma

​ 暴力枚举水题。

B. Last minute enhancements

​ 贪心水题。

C. Canine poetry

​ 考虑长度为2，3的回文串，然后用一个数组维护字符是否被修改过。

        scanf("%s",s+1);int n=strlen(s+1),ans=0;        mst(vis,0);for(int i=1;i<=n;i++){            int f=0;            if(s[i]==s[i-1]&&!vis[i-1]) f=1;            if(i>=2&&s[i]==s[i-2]&&!vis[i-2]) f=1;            ans+=(vis[i]=f);        }printf("%d\n",ans); 

D. 13th Labour of Heracles

​ 贪心，用优先队列维护度数大于1的，权越大在前面，权相同按度数排。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e5+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backint n;ll a[N],ans[N];int deg[N];struct node{    ll x,y;    bool operator<(const node&no)const{        return x==no.x?y<no.y:x<no.x;    }}; int main(){    int t;scanf("%d",&t);    while(t--){        scanf("%d",&n);mst(deg,0);        priority_queue<node>q;        ll s=0;for(int  i=1;i<=n;i++) scanf("%lld",&a[i]),s+=a[i];        for(int  i=1;i<n;i++){            int u,v;scanf("%d%d",&u,&v);            deg[u]++,deg[v]++;        }        for(int i=1;i<=n;i++){            if(deg[i]>1) q.push({a[i],(ll)deg[i]});        }        int cnt=n-2;printf("%lld",s);        while(cnt--){            node u=q.top();            s+=u.x;            printf(" %lld",s);            if(u.y==2){                q.pop();            }            else {                q.pop();                q.push({u.x,u.y-1});            }         }printf("\n");    }    return 0;}

E. Apollo versus Pan

​ 按位计算贡献，题解说的很明白了。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=5e5+5,M=60,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backint t,n;ll a[N],w[65]; int main(){    scanf("%d",&t);    while(t--){        scanf("%d",&n);        for(int i=0;i<60;i++) w[i]=0;        for(int i=1;i<=n;i++){            scanf("%lld",&a[i]);            for(int j=0;j<M;j++) w[j]+=a[i]>>j&1;        }        ll ans=0;        for(int i=1;i<=n;i++){            ll Xor=0,And=0;            for(int j=0;j<M;j++){                if(a[i]>>j&1){                    And+=(1LL<<j)%mod*w[j];                    Xor+=(1LL<<j)%mod*n;                    And%=mod,Xor%=mod;                 }else Xor+=(1LL<<j)%mod*w[j],Xor%=mod;            }            ans=(ans+Xor*And%mod)%mod;        }printf("%lld\n",ans);    }    return 0;}

F. Euclid’s nightmare

题意：给定$n$个$m$维向量，每个向量最多两维是$1$，其他都是0，问最多能生成多少个不同的$m$维向量，和最小生成这么多个向量的子集。

思路：并查集，每个向量看成一条边，然后连通分量的大小就是第二个答案，然后最大生成的向量个数就是$2^{size}$个，从小到大加入子集就满足字典序了。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=5e5+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backint n,m,s[N];int find(int x){    return x==s[x]?x:s[x]=find(s[x]);}int main(){    scanf("%d%d",&n,&m);    for(int i=1;i<=m+1;i++) s[i]=i;vector<int>ans;    for(int i=1;i<=n;i++){        int k;scanf("%d",&k);        int u,v=m+1;        scanf("%d",&u);        if(k==2) scanf("%d",&v);        u=find(u),v=find(v);        if(u!=v){            s[u]=v;            ans.pb(i);        }    }    ll t=1,sz=(int)ans.size();    for(int i=0;i<sz;i++) t=(t<<1)%mod;    printf("%lld %d\n",t,sz);    for(int i:ans) printf("%d ",i);printf("\n");    return 0;}

前言

自己$blog$的$md$炸掉了，我太惨了，反复折磨自己。

下面的每个知识点最后的页码对应PPT的页码。

正文

1.计算机网络的组成

3.计算机网络的硬件组成

硬件

服务器 工作站 网络接口卡 通信介质

软件

网络操作系统 网络协议软件

-第一章p23-p34

2.计算机网络的功能

资源共享，均衡负载及分布处理，信息快速传递和集中处理，综合信息服务，提高系统性价比，维护方便，扩展灵活。[资源+均负载分处理,两个信息，提高性价比…]

-第一章p21-p22

4.光纤的优缺点

高带宽，低衰减，不易干扰，腐蚀，细小而轻，便宜，安全性高。

缺点：操作技能要求高，易弯曲折，接口成本高。

-第一章p30-p30

5.网络协议

-第一章p34

6.网络的拓扑结构

-第一章p35-p40

7.网络的分类

-第一章p41-p49

8.广播和点对点网络特性

-第一章p42

9.三种网络交换方式

-第一章p47-49

10.网络分层结构 [大题]

分层是构建复杂系统的主要方法。

计算机系统采用分层结构，每一层在其下一层提供的功能基础上，实现为上一层提供的功能。

因此，越是底层，功能越弱；越是高层，功能越强。每一层的用户可以使用该层提供的功能。

计算机网络同样采用分层结构。

2.分层的优点

(1)　各层之间是独立的。

(2)　灵活性好。

(3)　结构上可分割开。

(4)　易于实现和维护。

(5)　能促进标准化工作。

•OSI参考模型

•TCP/IP体系结构

-第一章p50-60

11.TCP/IP 和 OSI 模型的优缺点

-第一章p59-65

12.局域网的特点

-第一章p71

13.IP 地址和 MAC 地址

-第一章p83-90

14.保留地址功能

-第一章p89

15.默认子网掩码 [大题]

-第一章p91-99

16.网关地址功能

-第一章p100-102

17.万维网和因特网是不是网络

-第一章p20 [未说]

18.WWW 的组成部分

-第一章p113-118, 2.1 P6-11 [未说]

19.电子邮件工作模式

-第一章p119-125 2.2 P6-11

20.PageRank 算法

-第一章p127-128

21.CSS 语法

-第三章p35-45

22.JavaScript 的作用和功能

-第三章p46-55

23.CMS [内容管理系统]

-第三章p59-62

24.无线电频谱的特点

-第五章p37

25.微波通信的特点

-第五章p43-45

26.卫星微波通信的特点

-第五章p46-47

27.近场通信 [NFC]

-第五章p51

28无线信号的损耗原因 [大题]

-第五章p52-54

29.信号调制

-第五章p55

30.信号复用的基本思想

-第五章 没找到

31.复用和多址

-第五章p57

32.WLAN 的组成

-第五章p71-79

33.WLAN 基础架构集中式拓扑的特点

-第五章p80-83

34.无线传感器网络的节点

-第五章p127-130

35.凯撒密码

-第六章p28

36.非对称密钥算法

-第六章p46-55

37.数字签名

-第六章p65

38.IPSec

-第六章p72-75

39.防火墙的作用

-第六章p76-80

40.防火墙的组成

-第六章p76-80

前言

咕咕了两天，觉得有必要写一下。

$Just\ Record\ it,and\ leave\ a\ memory$。

闲扯&热身赛

​ 从热身赛前一天讲起吧，因为热身赛与四级在同一天，而且热身赛在上午，所以考前一天，一直在 复习英语 [抱佛脚]，果然，有一大事，晚上就失眠了，早上5点就醒了，上午考完四级，听力懵逼过去了，中午提议和$wyy$一起去吃顿好的，结果就去了$kfc$，我请客吃了个大餐，[说好的AA呢?]，下午没事做跟上个星期天打比赛的主办方对线 [后来复审还是挺好的，进决赛了] 。然后随时间的推移来到了晚上的热身赛，晚上热身赛有点意思，热身赛一共有三个题，刚开题，$ycs$看到概率就丢了，我们直接快进到第二题，找了半天规律，乱搞了一个奇偶性的规律，后来发现有特例过不去，就又丢了，快进到第三题，发现跟之前在知乎上面看到的一个数学题有点像，下意识猜了个结论就是排序取中点，可惜的是没想到转换思想，$zyj$造数据给我整懵了，我也不知道这个题目坐标系是咋建的。哦豁，最后热身赛结束直接爆零了。后来看别人的$AC$代码，发现第一个题是概率问题，用组合数学化简一下然后暴力就可以了，我和$ycs$一直以为是概率$dp$，这题还可以用欧拉函数加速一波，估计是我们被上次的那个概率$dp$整怕了，哈哈。热身赛结束，我一看这一波爆零了，有点慌呀，平时我们训练的时候没爆零过呀，根据$zyj$的建议，我回去整理了一波模板，[后来这一堆模板成为了场外人员观战]。整理模板的时候，我发现我的博客都写的啥啊，全是我看不懂的，可能是我记忆力太差了，或是我太菜了，每一个模板都简单的回忆了亿下。噢，12点了该睡觉了。

正赛

​ 按照约定好的，$ycs$主写代码，我和$zyj$辅助，我划水。比赛开始了，刷新了一波界面，发现有人过$G$题了，集体懵逼。上来我好像看了个$E$题，发现是个环题，丢了，很快我们便找到了签到的$G$，很快$ycs$就$A$掉了，虽然后来我也不知道咋做的，没仔细看那个题。于是开始读其他的题，发现$B,D,M$过的人比较多，我读完了$D$发现这个题是可做的，然后建议一起搞$D$，结果发现要讨论好多情况，我们直接取了几种情况乱搞了下，交了一发，恩，$WA$掉，发现这题有点复杂，就先丢了。然后看$B,M$，读完$B$题，我的第一眼发现题目明显的提示，不是直接签到题吗，然后细心的$zyj$告诉我这题不是这个意思，噢，我人傻了，发现没有啥思路，就丢了。最后决定先搞$M$，发现是个树题，有点类似今年$PAT$甲级那道文件目录？我的第一个直觉是$map$搞，发现没有什么比较好的方法写出来，后来在$zyj$的帮助下，发现只需要$dfs+$贪心的遍历就好了，最后就只剩下建图了，$ycs$决定用字典树建图，我好久没用字典树，自然有点懵逼，好在$ycs$巨巨临危不乱，历经两个小时，成功建树一发$AC$了，$tql$了。我要好好学字典树了。然后我准备想$B$，发现这个题这么多人过，必然是签到啊，最终发现了结论，冲了一波，噢，就是这么简单。$A$掉$B$后，我让$zyj$看$I$题，我和$ycs$看$c$，讨论一会儿，只推出来了个最高位，但是不知道怎么统计每位的贡献，事后发现这个题是个裸的数位$dp$，然后$zyj$读完题目了，给我们讲了一波，我发现要一层一层的算，但是具体怎么算没想出来，然后$zyj$给出最短距离的计算方式，此时$ycs$好像有思路准备写这题的代码了，此时比赛还剩$1h$，我问了下$ycs$，一个小时能不能做出来这个题，搞不出来就丢了，去做人过得比较多的$D$，$ycs$自信的告诉我可以，然后开始搞$I$了，因为我没有啥实现的思路，我在看一些其他的题，最后$ycs$写了个代码，发现过不了样例，然后我和$zyj$一直在帮忙找错，最后我发现这同一层贡献肯定是$2\pi r$的倍数啊，怎么里面没有$r$，然后告诉了$ycs$，果然就出错在这里了，然后还是我们还是不敢交，准备用$zyj$构造的样例再测下，然后发现有点不对？实际上写的是对的，$ycs$交了下就过了。过了$4$题还剩下$20$分钟，我提议最后在$D$上挣扎下，恩，就是挣扎下而已，事后发现有的情况不需要讨论，此题的正解是特判两种，然后二分下第三种情况。比赛结束了，看了眼排名，不算打星的队伍的话，发现有机会拿铜。恩，最后拿了块铜牌，还是挺好的。

赛后

把冷了的炸鸡带回去之后，上食堂热了一波，吃的我拉肚子$\dots\dots$

然后看了下别人的过题代码，学习了一波。然后复习了之前丢了的数位$dp$。

整到12点，可以缓缓了。

$over$

上海站结束了，感谢两位队友带我拿牌牌，太开心啦😊。我躺的很舒服。

思路

映射$+$逆序对

考虑用先映射，然后用$BIT$一次求出逆序对数，然后模拟移动最后一个的变化。

注意左右不等价，都要移动$n$次。

时间复杂度：$O(nlogn)$

代码

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e5+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_back#define lowbit(x) x&(-x)int mp[N],a[N],b[N];ll tr[N];int n;void upd(int x,ll k){    while(x<=n){        tr[x]+=k;        x+=lowbit(x);    }}ll que(int x){ll s=0;    while(x){        s+=tr[x];        x-=lowbit(x);    }return s;}ll ans=1e18;int c[N],d[N];void solve(int *a,int *b){    mst(tr,0);    memcpy(c+1,a+1,(n+1)*sizeof(int));memcpy(d+1,b+1,(n+1)*sizeof(int));    ll res=0;    for(int i=1;i<=n;i++) mp[c[i]]=i;    for(int i=1;i<=n;i++){        d[i]=mp[d[i]];        res+=que(n)-que(d[i]);        upd(d[i],1LL);    }    ll tmp=res;    for(int i=n;i>=0;i--){        //printf("res=%lld\n",res);        res+=2*d[i]-n-1;        tmp=min(tmp,res);    }    ans=min(ans,tmp);}int main(){    scanf("%d",&n);    for(int i=1;i<=n;i++){        int x;scanf("%d",&a[i]);    }    for(int i=1;i<=n;i++){        scanf("%d",&b[i]);    }    solve(a,b);    solve(b,a);    printf("%lld\n",ans);    return 0;}

题意

给定$n$块地，$m$头牛，每头牛有两个喜爱的地，要给$m$块地染色$col\in[1,4]$，每头牛喜爱的两块地颜色要求不同，输出字典序最小的染色方案。

思路

贪心$+$暴力

从第一块地开始贪心地染色，然后暴力从小到大枚举染的颜色，特判$m$头牛是否满足条件，特判时只要判较小的那块地，后面未染色的地可以不用管。

时间复杂度：$O(4nm)$

代码

#include<bits/stdc++.h>using namespace std;const int N=200;typedef pair<int,int> PII;#define fi first#define se secondPII a[N];int ans[N],n,m;int main(){    scanf("%d%d",&n,&m);    for(int i=1;i<=m;i++){        scanf("%d%d",&a[i].fi,&a[i].se);        if(a[i].fi>a[i].se) swap(a[i].fi,a[i].se);    }    for(int i=1;i<=n;i++){        int f;        for(int j=1;j<=4;j++){             f=j;            for(int k=1;k<=m;k++){                if(a[k].se==i&&ans[a[k].fi]==j){                    f=0;break;                }            }            if(f) break;        }        ans[i]=f;    }    for(int i=1;i<=n;i++) printf("%d",ans[i]);    return 0;}

随便搞下就行了。

1121 Damn Single (25分)

需要注意以下细节的水题。

1122 Hamiltonian Cycle (25分)

哈密顿回路，暴力特判即可。

1123 Is It a Complete AVL Tree (30分)

$AVL$树的建立。

判断一个树是否为$CBT$，只需判断在一个节点没有子结点后，还会不会出现子结点，如果又出现了，则不是$CBT$。

#include<bits/stdc++.h>using namespace std;typedef long long ll;#define mst(a,b) memset(a,b,sizeof a)struct node{    int val;    node *l,*r;};node* ro_L(node *rt){    //左旋操作     node* t=rt->r;    rt->r=t->l;    t->l=rt;    return t;}  node* ro_R(node *rt){    //右旋操作     node * t=rt->l;    rt->l=t->r;    t->r=rt;    return t;}node* ro_LR(node *rt){    //左旋后右旋操作     rt->l=ro_L(rt->l);    return ro_R(rt);}node* ro_RL(node *rt){    //右旋后左旋操作     rt->r=ro_R(rt->r);    return ro_L(rt);}int getht(node *rt) {    if(!rt) return 0;    return max(getht(rt->l), getht(rt->r)) + 1;}node *insert(node *rt, int val) {        //AVL 插入结点     if(!rt) {        rt = new node();        rt->val = val;        rt->l=rt->r=NULL;    } else if(val < rt->val) {        rt->l=insert(rt->l, val);        if(getht(rt->l)-getht(rt->r) == 2)            rt=val<rt->l->val ? ro_R(rt) :ro_LR(rt);                //LL:LR    } else {        rt->r = insert(rt->r, val);        if(getht(rt->l) - getht(rt->r) == -2)            rt = val > rt->r->val ?ro_L(rt) :ro_RL(rt);            //RR:RL    }    return rt;}bool ok=1,jg=0;void lev(node *rt){    queue<node*>q;    q.push(rt);int f=0;    while(!q.empty()){        node * u=q.front();q.pop();        if(!f) printf("%d",u->val),f=1;        else printf(" %d",u->val);        if(u->l){            if(jg) ok=0;             q.push(u->l);        }        else jg=1;        if(u->r) {            if(jg) ok=0;            q.push(u->r);        } else jg=1;    }printf("\n");}int main(){    int n;    scanf("%d",&n);    node* rt=NULL;    for(int i=1,x;i<=n;i++){        scanf("%d",&x);        rt=insert(rt,x);    }    //printf("%d\n",rt->val);    lev(rt);     puts(ok?"YES":"NO");    return 0;}

简单特判

1117 Eddington Number (25分)

题意有误，应该是大于等于$E$天，排序二分即可。

1118 Birds in Forest (25分)

并查集大水题，注意查询时用$find()$不要用$s[]$数组。

1119 Pre- and Post-order Traversals (30分)

已知前序，后序求中序，不唯一的情况就是一个结点只有一个子树。

因此可以每次在前序中查找后序的倒数第二个结点，该结点就是子树的根，如果根只有该一个子树的话，可以默认为是右子树进行递归。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e4+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backint n,pre[N],post[N],in[N],id;bool f=true;void inorder(int l1,int r1,int l2,int r2){    if(l1==r1){        in[++id]=pre[l1];return;    }    if(pre[l1]==post[r2]){        int i=l1+1;        while(i<=r1&&pre[i]!=post[r2-1]) i++;        if(i-l1>1) inorder(l1+1,i-1,l2,l2+i-l1-2);        else f=false;        in[++id]=post[r2];        inorder(i,r1,l2+i-l1-1,r2-1);     }}int main(){    scanf("%d",&n);for(int i=1;i<=n;i++) scanf("%d",&pre[i]);    for(int i=1;i<=n;i++) scanf("%d",&post[i]);    inorder(1,n,1,n);puts(f?"Yes":"No");printf("%d",in[1]);    for(int i=2;i<=n;i++) printf(" %d",in[i]);printf("\n");    return 0;}

简单模拟。

1113 Integer Set Partition (25分)

贪心选即可。

1114 Family Property (25分)

并查集的水题，有些细节需要注意。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e5+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backint n,s[N],sz[N];int a[N],b[N],vis[N];struct node{    int id,s,x,y,f;}ans[N];int find(int x){    return x==s[x]?x:s[x]=find(s[x]);}bool cmp(node u,node v){    return u.y*v.s==v.y*u.s?u.id<v.id:u.y*v.s>v.y*u.s;}void Union(int u,int v){    u=find(u),v=find(v);    if(v!=u){        u<v?s[v]=u:s[u]=v;    }}int main(){    scanf("%d",&n);int tot=0;    for(int i=0;i<1e5;i++) s[i]=i;    for(int i=1;i<=n;i++){        int id,f1,f2;scanf("%d%d%d",&id,&f1,&f2);vis[id]=1;        if(~f1) Union(id,f1),vis[f1]=1;        if(~f2) Union(id,f2),vis[f2]=1;        int k;scanf("%d",&k);        for(int j=0,x;j<k;j++){            scanf("%d",&x),Union(x,id);vis[x]=1;        }        scanf("%d%d",&a[id],&b[id]);    }    for(int i=0;i<1e5;i++){        if(vis[i]){            int x=find(i);            ans[x].id=x;            ans[x].s++;            ans[x].x+=a[i];            ans[x].y+=b[i];            ans[x].f=1;        }    }vector<node>res;    for(int i=0;i<1e5;i++)     if(ans[i].f) res.pb(ans[i]);     sort(res.begin(),res.end(),cmp);printf("%d\n",res.size());    for(int i=0;i<res.size();i++){        printf("%04d %d %.3f %.3f\n",res[i].id,res[i].s,(double)res[i].x/res[i].s,(double)res[i].y/res[i].s);    }    return 0;}

1115 Counting Nodes in a BST (30分)

考察了$BST$的建立，学到了。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e5+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backstruct node{    int v;    node *l,*r;};node* build(node *x,int v){    if(!x){        x=new node();        x->v=v;        x->l=x->r=NULL;    }    else if(v<=x->v) x->l=build(x->l,v);    else x->r=build(x->r,v);return x;}int mx=-1,cnt[N];void dfs(node *x,int d){    if(!x){        mx=max(mx,d);return;    }    cnt[d]++;    dfs(x->l,d+1),dfs(x->r,d+1);}int main(){    node* rt=NULL;    int n;scanf("%d",&n);for(int i=1,x;i<=n;i++)        scanf("%d",&x),rt=build(rt,x);    dfs(rt,0);    printf("%d + %d = %d\n",cnt[mx-1],cnt[mx-2],cnt[mx-1]+cnt[mx-2]);    return 0;}

四则运算模拟题，代码太丑了。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e3+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define PII pair<int,int>#define fi first#define se second#define pb push_backstruct node{        ll x,y;    int f;}a,b; ll gcd(ll a,ll b){    return !b?a:gcd(b,a%b);}void show(ll x,ll y,int op){    if(!y){        printf("Inf");return;    }    if(op==-1) printf("(-");    if(x%y==0){        printf("%lld",x/y);    }    else {        if(x/y) printf("%lld ",x/y);        printf("%lld/%lld",x-x/y*y,y);    }    if(op==-1) printf(")");}void hj(ll &x,ll &y){    ll g=gcd(x,y);    x/=g,y/=g;}void Print(char op){    show(a.x,a.y,a.f);printf(" %c ",op);show(b.x,b.y,b.f);printf(" = ");}int main(){    scanf("%lld/%lld %lld/%lld",&a.x,&a.y,&b.x,&b.y);    if(a.x<0) a.f=-1,a.x=-a.x;    else a.f=1;    if(b.x<0) b.f=-1,b.x=-b.x;    else b.f=1;    hj(a.x,a.y);hj(b.x,b.y);    Print('+');    ll lcm=a.y/gcd(a.y,b.y)*b.y;    node z;    z.x=a.f*lcm/a.y*a.x+b.f*lcm/b.y*b.x;    if(z.x<0) z.f=-1,z.x=-z.x;    else z.f=1;    z.y=lcm;hj(z.x,z.y);    show(z.x,z.y,z.f);printf("\n");    Print('-');    z.x=a.f*lcm/a.y*a.x-b.f*lcm/b.y*b.x;    if(z.x<0) z.f=-1,z.x=-z.x;    else z.f=1;    z.y=lcm;hj(z.x,z.y);    show(z.x,z.y,z.f);printf("\n");    Print('*');    z.x=a.f*a.x*b.x*b.f;    z.y=a.y*b.y;    if(z.x<0) z.f=-1,z.x=-z.x;    else z.f=1;hj(z.x,z.y);    show(z.x,z.y,z.f);printf("\n");    Print('/');    z.x=a.f*a.x*b.y;    z.y=a.y*b.x*b.f;    if((z.x<0&&z.y>0)||(z.x>0&&z.y<0)){        z.x=abs(z.x),z.y=abs(z.y);        z.f=-1;    }     else z.f=1;hj(z.x,z.y);    show(z.x,z.y,z.f);printf("\n");    return 0;}

1089 Insert or Merge

插入排序，每次排好第$i$个位置，后面位置保持原序。

归并排序，分区间合并，类似倍增。

#include<bits/stdc++.h>using namespace std;typedef long long ll;const int N=1e3+5,M=2e4+5,inf=0x3f3f3f3f,mod=1e9+7;#define mst(a,b) memset(a,b,sizeof a)#define lx x<<1#define rx x<<1|1#define reg register#define PII pair<int,int>#define fi first#define se second#define pb push_back#define il inlineint a[N],b[N],n; int main(){    scanf("%d",&n);    for(int i=1;i<=n;i++) scanf("%d",&a[i]);    for(int i=1;i<=n;i++) scanf("%d",&b[i]);    int p=1,p1;    while(p<n&&b[p]<=b[p+1]) p++;    p1=++p;    while(p<=n&&a[p]==b[p]) p++;    if(p==n+1){        puts("Insertion Sort");        sort(b+1,b+p1+1);printf("%d",b[1]);        for(int i=2;i<=n;i++)            printf(" %d",b[i]);    }    else {        puts("Merge Sort");        int f=1,x=1;        while(f){            f=0;            for(int i=1;i<=n;i++)                if(a[i]!=b[i]) {                    f=1;break;                }            x<<=1;            for(int i=1;i<=n/x;i++)                sort(a+(i-1)*x+1,a+i*x+1);            sort(a+(n/x)*x+1,a+n+1);        }        printf("%d",a[1]);        for(int i=2;i<=n;i++) printf(" %d",a[i]);    }    return 0;}