Alex's Blog

矩阵快速幂运用

2020-03-21T11:20:08.000Z

引入

想要了解矩阵快速幂，就不得不提到矩阵的概念。矩阵就像一个二维数组，存储了一组数据，如：

M=\left[ \begin{matrix} 1&2&3\\ 4&5&6\\ 7&8&9\end{matrix}\right]

用 $M_{i,j}$ 表示矩阵第 $i$ 行第 $j$ 列的数据，如 $M_{2,3}=6$ 。

矩阵运算

加法

矩阵的加法和实数加法类似，要求运算的两个矩阵大小相等，将对应位置相加即可。

减法

与加法相同，对应位置相减即可。

乘法

矩阵乘法并非对应位置相乘。

若矩阵 $A\times B=C$ 有意义，那么 $A$ 的列数要求与 $B$ 的行数相等。

若 $A$ 的列数与 $B$ 的行数等于 $n$ ：

C_{i,j}=\sum_{k=1}^{n}A_{i,k}\times B_{k,j}

即结果第 $i$ 行第 $j$ 列的值为 $A$ 的第 $i$ 行与 $B$ 的第 $j$ 列的对应项相乘后求和。

一个很直观的理解是，把矩阵 $A$ 放在结果的左侧，矩阵 $B$ 放在结果的下方，将行与列延长，对应相乘后结果写在交点处。

\left[ \begin{matrix} \bold{1}&\bold{2}&\bold{3}\\ 4&5&6\\ 7&8&9\end{matrix}\right]\left[ \begin{matrix} \rightarrow&36&&\\ &\uparrow&&\\ &\uparrow&&\end{matrix}\right]\\\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\left[ \begin{matrix} 1&\bold{2}&3\\ 4&\bold{5}&6\\ 7&\bold{8}&9\end{matrix}\right]

注意矩阵乘法满足结合律，但是不一定满足交换律， $A\times B$ 成立不一定代表 $B\times A$ 成立。

除法

$\rightarrow$ To be continued.

快速幂

快速幂可以 $O(\log n)$ 求解 $a^n$ ，对矩阵同样适用。
代码：

int ans=1;
while(n){
if(n&1)ans*=a;
a*=a;
n>>=1;
}

矩阵快速幂

可以使用重载运算符的办法直接进行矩阵快速幂，方法和普通快速幂一样，但是要注意乘法顺序。ans的初始值要特别注意。如果想让它充当1，则需要设置成单位矩阵 $I$ 。

\left[\begin{matrix}1&0&0&\cdots&0\\0&1&0&\cdots&0\\0&0&1&\cdots&0\\\vdots&\vdots&\vdots&\ddots&0\\0&0&0&0&1\end{matrix}\right]

递推

使用矩阵快速幂，可以用 $O(\log n)$ 的时间复杂度完成 $n$ 次递推关系，如斐波那契数列。矩阵可以通过递推关系推算出来。

\because\left[\begin{matrix}1&1\\0&1\end{matrix}\right]\times\left[\begin{matrix}F_{n-1}\\F_{n-2}\end{matrix}\right]=\left[\begin{matrix}F_n\\F_{n-1}\end{matrix}\right]\\

\therefore F_n=\left[\begin{matrix}1&1\\0&1\end{matrix}\right]^n\times\left[\begin{matrix}1\\1\end{matrix}\right]

推算矩阵

矩阵由转移关系得来。以斐波那契数列为例：

\because F_n=1F_{n-1}+1F_{n-2}

F_{n-1}=1F_{n-1}+0F_{n-2}

\therefore M=\left[\begin{matrix}1&1\\0&1\end{matrix}\right]

其余类似。

例题

F(n,1)=F(n-1,2)+2F(n-3,1)+5

F(n,2)=F(n-1,1)+3F(n-3,1)+2F(n-3,2)+3

已知

F(1,1)=2,F(1,2)=3,F(2,1)=1,F(2,2)=4,F(3,1)=6,F(3,2)=5

求 $F(n,1)$ 和 $F(n,2)$ 。

矩阵

\left[\begin{matrix}0&1&0&0&2&0&5\\1&0&0&0&3&2&3\\1&0&0&0&0&0&0\\0&1&0&0&0&0&0\\0&0&1&0&0&0&0\\0&0&0&1&0&0&0\\0&0&0&0&0&0&1\\\end{matrix}\right]

代码

#include "bits/stdc++.h"
using namespace std;
const long long mod=99999999;
long long base[7][7]={
{0,1,0,0,2,0,5},
{1,0,0,0,3,2,3},
{1,0,0,0,0,0,0},
{0,1,0,0,0,0,0},
{0,0,1,0,0,0,0},
{0,0,0,1,0,0,0},
{0,0,0,0,0,0,1},
};
struct matrix{
long long v[30][30];
long long x,y;
};
matrix operator+(matrix a,matrix b){
matrix c;
if(a.x!=b.x||a.y!=b.y)return c;
long long x=a.x,y=a.y;
c.x=x;c.y=y;
for(long long i=0;i
for(long long j=0;j
c.v[i][j]=a.v[i][j]+b.v[i][j];
}
}
return c;
}
matrix operator-(matrix a,matrix b){
matrix c;
if(a.x!=b.x||a.y!=b.y)return c;
long long x=a.x,y=a.y;
c.x=x;c.y=y;
for(long long i=0;i
for(long long j=0;j
c.v[i][j]=a.v[i][j]-b.v[i][j];
}
}
return c;
}
matrix operator*(matrix a,matrix b){
matrix c;
if(a.y!=b.x)return c;
long long x=a.x,y=b.y,z=a.y;
c.x=x;c.y=y;
for(long long i=0;i
for(long long j=0;j
c.v[i][j]=0;
for(long long k=0;k
c.v[i][j]=(c.v[i][j]+a.v[i][k]*b.v[k][j]+mod)%mod;
}
}
}
return c;
}
void init(matrix &a){
for(long long i=0;i
for(long long j=0;j
a.v[i][j]=base[i][j];
}
}
}
ostream& operator<<(ostream& ous,matrix a){
for(long long i=0;i
for(long long j=0;j
ous<' ';
}
ous<<endl;
}
return ous;
}
long long n;
matrix& operator *=(matrix &a,matrix n){
a=a*n;
return a;
}
matrix a,ans;
int main(){
cin>>n;
a.x=a.y=7;
init(a);
ans.x=7;ans.y=1;
ans.v[0][0]=6;
ans.v[1][0]=5;
ans.v[2][0]=1;
ans.v[3][0]=4;
ans.v[4][0]=2;
ans.v[5][0]=3;
ans.v[6][0]=1;
if(n==1){
cout<<2<<endl<<3;
}else if(n==2){
cout<<1<<endl<<4;
}else if(n==3){
cout<<6<<endl<<5;
}
if(n<4)return 0;
n-=3;
while(n){
if(n&1)ans=a*ans;
a*=a;
n>>=1;
}
cout<0][0]<<endl<1][0];
return 0;
}

How do computers work?

2020-03-04T04:53:05.000Z

This page is locked

Introduction

We all know computers, and we basically know how to use it, but we have no idea about how does it work.

Well…

If I can present well, and you can understand well, We can watch a video!

Deep inside the computer

Inside the computer, there are loads of parts, and the most important one is the CPU(Central Processing Unit).

The CPU contains basic modules, which contains logic gates, which contains transistors.

Transistor

What is a transistor?
Transistor is the most basic part of a computer. It is just an electronic switch, but without it, your computer cannot compute anything.

The transistor has three pins, collector, base, and emitter, also, C, B, E for short. You must be familiar with this because we’ve met it before.
Transistor processes information and the information is called BITS, which can be set to either 0 or 1.

Logic Gate

Combining transistors, you will get logic gates, which can get some input and create some output. For example, an AND gate produces an output of 1 if all its inputs are one, and output of 0 otherwise.

Compute Modules

Combining logic gates, you will get compute modules, which can do some basic calculating, such as $a+b (a<3,b<3)$ .

Breaking change

Once you can add small numbers, you can add multiple times to add big numbers. And once you can add, you can also multiply, once you can multiply, you can basically do anything.

Hide content

Show content

Pop quiz

What is the simplest component of a data processor?
What can it do?
What is the most imprortant part in a conputer?
Why these simple modules can do things complicated?
Show answer!
Hide answer!

A transistor
It is an electronic switch
CPU
Transistor forms logic gates, and then forms compute module, which can add, and by cleverly adding, you can do anything.

Video

A video downloaded from YouTube, which is the reference for this article.

your browser does not support the video tag

Download Here

线段树

2020-03-02T03:37:36.000Z

前置知识

数组，结构体，二叉树

引入

有时候我们会遇到一些大规模的区间查找和区间修改问题，比如让你维护一个 $10^5$ 长度的数列，要求操作有区间求和、区间加（区间每个数加上一个值），让你在一秒内完成 $10^5$ 次操作。
暴力是肯定不行的，数据范围太大，操作太多，会超时。
所以我们就有一种专门解决大范围区间修改查询的数据结构：线段树。

线段树

线段树本质上是把整个数列拆分了，用一个一个区间来表示。

比如有 $n$ 个节点，根节点代表整个数列的区间 $[1,n]$ ，根节点的两个子节点代表根区间二分成两部分，也就是 $[1,\operatorname{mid}]$ 和 $[\operatorname{mid},n]$ 。
而子节点也是一棵线段树。
一直往下延伸，叶子结点就代表着单一位置 $[a,a]$ 。
下图是一个 $n=7$ 的示例：

每一个节点都存储着它所代表的区间的信息，比如这个区间的和。

查找

解释

如查找 $[l,r]$ ，则执行以下步骤：

首先在根节点查找 $[l,r]$
判断当前所在区间是否在当前查找的区间内部，若在内部则直接返回当前区间数据。
若当前区间的右子节点区间的左边界在当前查找的区间的左边界的右侧，说明当前查找区间完全在右子节点一侧，则返回在右子节点查找 $[l,r]$ 的结果。
否则，若当前区间的左子节点区间的右边界在当前查找区间的右边界的左侧，说明当前查找区间完全在左子节点一侧，则返回在左子节点查找 $[l,r]$ 的结果。
否则，说明当前查找区间横跨左右子节点，那么返回：在左子节点查找当前查找区间的左边界-左子节点区间的右边界与在右子节点查找右子节点的左边界-当前查找区间的右边界结果的和。

举例

设若查找区间 $[3,6]$ ，首先从根节点开始：
-当前区间 $[1,7]$ 不在 $[3,6]$ 内部，经过判断 $[3,6]$ 横跨左右子节点，分别在左右子节点查找查找： $[3,3]$ 和 $[4,6]$ 。
-于是在 $[1,3]$ 内查找 $[3,3]$ ，经过两次下放到右子树最终返回。
-接着在 $[4,7]$ 内查找 $[4,6]$ ， $4,6$ 横跨左右子树，继续查找： $[4-5]$ 和 $[6-6]$ 。
-进入 $[4,5]$ ，在区间内部，直接返回。由 $[6,7]$ 进入 $[6,6]$ 后返回，查找完毕。

修改

我们会发现，修改时如果像查找一样做，那么有一些细小的叶子修改就改不到，如刚才举例的 $[4,5]$ ，如果只修改 $[4,5]$ 区间，那么单独查询 $[4,4]$ 和 $[5,5]$ 的时候就会出错。要是每一个修改都下放到叶子节点，那这个算法就和暴力一样了。所以我们需要一些巧妙地解决办法。

lazy

我们在树的节点上加一个标记： $\texttt{lazy}$ 。

所谓 $\texttt{lazy}$ ，就是要懒，就是要在事情迫不得已要做的时候把它做了，所以我们每次那些细小的叶子修改就不做他，直接记录在 $\texttt{lazy}$ 标记上，等到要查询的时候，再从标记上下放到子结点上，查询到哪里就下放到哪里。

注意

修改后的结点，需要同时把所有祖先结点全部更新。

优势

暴力算法的复杂度是 $O(nm)$ 的，而线段树的复杂度是 $O(n\log m)$ 的，因为每次树深入一层，区间长度都会减半。

代码(luogu P3372)

#include "iostream"
using namespace std;
#define N 1000010
#define lson id<<1 //此处偷了懒，因为完全二叉树的性质可以推出，左子树编号是根节点的一倍，右子树是根节点一倍加一，
#define rson id<<1|1 //使用位运算提高速度。
int a[N],n,m,op,x,y,k;
struct node {
int l,r,sum,lazy;
}t[2*N];
void update(int id){//更新函数
t[id].sum=t[lson].sum+t[lson].lazy*(t[lson].r-t[lson].l+1)+
t[rson].sum+t[rson].lazy*(t[rson].r-t[rson].l+1);
}
void pushdown(int id){//下推函数
if(t[id].lazy){
t[lson].lazy+=t[id].lazy;
t[rson].lazy+=t[id].lazy;
t[id].sum+=t[id].lazy*(t[id].r-t[id].l+1);
t[id].lazy=0;
}
}
void buildtree(int id,int l,int r){//建树
t[id].l=l;
t[id].r=r;
t[id].lazy=0;
if(l==r){
t[id].sum=a[l];
return;
}
int mid=(l+r)>>1;
buildtree(lson,l,mid);
buildtree(rson,mid+1,r);
update(id);
}
void change(int id,int l,int r,int c){//修改
if(t[id].l>=l&&t[id].r<=r){
t[id].lazy+=c;
return;
}
pushdown(id);
if(t[lson].r>=r)change(lson,l,r,c);
else if(t[rson].l<=l)change(rson,l,r,c);
else{
change(lson,l,t[lson].r,c);
change(rson,t[rson].l,r,c);
}
update(id);
}
int query(int id,int l,int r){//求和
if(t[id].l>=l&&t[id].r<=r){
return t[id].sum+t[id].lazy*(t[id].r-t[id].l+1);
}
pushdown(id);
if(t[lson].r>=r)return query(lson,l,r);
else if(t[rson].l<=l)return query(rson,l,r);
else{
return query(lson,l,t[lson].r)+query(rson,t[rson].l,r);
}
update(id);
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>a[i];
}
buildtree(1,1,n);
for(int i=1;i<=m;i++){
cin>>op;
if(op==1){
cin>>x>>y>>k;
change(1,x,y,k);
}
else{
cin>>x>>y;
cout<1,x,y)<<endl;
}
}
return 0;
}

斐波那契数列-O(1)

2020-03-02T03:35:44.000Z

引自：《信息学奥赛之-数学一本通》
揍是这样：

\operatorname{F}(n)=\dfrac{\sqrt{5}}{5}\cdot\left[\left(1+\sqrt{5}\right)^n-\left(1-\sqrt{5}\right)^n\right]

代码揍这么简单：

1
2
3

int fibo(int n){
return (sqrt(5)/5)*(pow((1+sqrt(5))/2,n)-pow((1-sqrt(5))/2,n));
}

要是再加个快速幂就更棒了（够快了，懒得写）

网络最大流-Dinic

2020-03-02T03:31:22.000Z

前置知识

存图方式（邻接表，邻接矩阵）,图的遍历（dfs，bfs）

引入

我们举个例子吧：
有一个毒瘤水管工，他会造水管，有一天他造了一个水管网络，就像一个图。其中有一个点只有出边，就是起点，还有一个点只有入边，是终点。
点之间有一些管子，这些管子都有单位时间内的容量，现在毒瘤水管工想知道，他的管子在单位时间内在起点终点之间最多能流多少水。

概念

源点：顾名思义，起点，一般用s表示
汇点：顾名思义，终点，一般用t表示。。。
容量：顾名思义。。。一条边单位时间内的的容量
残余网络：进行增广后剩余的网络
増广：

増广就是在残余网络中寻找从源点到汇点的可行路径（増广路），并将该路径上的所有边的容量减去路径中的最小容量，形成新的残余网络，人话就是找一条能走的路，然后把路走掉。
例如：

如果当前有这样一个残余网络，那么 $s\rightarrow4\rightarrow1\rightarrow t$ 就是一条増广路，最小容量是4，进行増广过后就形成了这样一张图：

如何寻找増广路？直接dfs即可。

反向边：

有时候，程序増广的时候会出现爆炸性错误，例如还是那个图：

有两条増广路，万一程序选错了怎么办？
这时就要请出反向边了。
每次増广的时候，在残余网络上逆着増广路径建容量与増广路径最小容量相等的反向边，比如刚才那张图，就顺着 $t\rightarrow1\rightarrow4\rightarrow s$ 建容量为4的边。相当于把原来的那条路抵消掉了，如果増广时走过了反向边，就相当于把原来的増广撤回去了。
这就给了程序一个反悔的机会。

朴素算法

増广
沿着増广路径建反向边
如果源点与汇点依然连通，回到1

Dinic优化

Dinic的优化就是用bfs建立了由s开始的一个分层图，每次寻找増广路时必须让边上的层数严格递增，就可以确保每一步都离汇点近了一些这样就不会陷入毒瘤数据卡成的死循环，比如这样的著名毒瘤数据：
![](file://C:/Users/liangliang/Documents/Gridea/post-images/1582894458914.png)在这个数据中，如果用朴素算法，就会让中间容量为1的边上下抖动抽搐，等到他抽了999次的时候才把上面和下面的999减没。如果用Dinic，两次直接求出999+999。

代码

404 Not Found(Click for more information)
完结！

最小生成树

2020-03-01T14:45:44.000Z

前置知识

存图方式（邻接表，邻接矩阵），并查集。
不会的快进入链接学习吧！

引入

生成树，就是从一个图中选中 $n-1$ 条边，使得这些边构成一棵树，并包含图中的所有节点。
最小生成树，就是找到一种生成树，使得这个生成树的边权和最小。

生成方式一：prim

这种方法有点类似Dijstra，就是每次从所有 $vis$ 过的点遍历能达到的边，从其中选择一条最小的，加入生成树。

假设我们有这么一张图：

就从0号点开始吧：

找到从 $0$ 出发的最小的边： $[0,2]$ ,边权为 $3$ ，那么对 $2$ 号点进行标记。

然后从 $0$ 号和 $2$ 号节点继续找，发现最小的是 $[2,4]$ 边，那么就标记 $4$ 号节点。

然后是 $[4,1]$ ， $1$ 号。

以此类推，最后就生成出来了这样一个图：

把没有标记的边删掉，就是最小生成树。

这就是prim算法 ~~，代码我不会写~~在后面。

生成方式二：kruskal

这个算法本质上就是把所有边按照边权排序，然后直接爆炸按顺序判断要不要加进生成树里。
kruskal算法使用了一种极速闪电致命又自杀的东西：并查集。
他有多快呢？

好了我们在建一个图模拟一下吧

先给边排序。最小的是 $[2,3]$ ，把他拿出来，判断一下。怎么判断呢？首先访问一下并查集看一看，这个边连接的两个点在不在同一个集合内，不在的话就把这条边加入生成树，然后把两个点合并。否则忽略这一条变，继续。这一条边符合要求，加进并查集里，现在 ${2,3}$ 是一个集合，剩下都是独立的。

现在最小的有 $[1,4]$ 和 $[4,5]$ ，我们都判断一下，都可以。

然后就是 $[0,4]$ 和 $[2,4]$ ，依然都是可以的。

这样，一颗活灵活现的生成树就出现了。

好了！

代码（luoguP3366）

kruskal的代码又短又易于理解，甚至可以直接用数组存边，所以他非常好写，推荐。

prim

#include "iostream"
#include "queue"
#include "cstring"
using namespace std;
#define maxm 5000010
#define maxn 1000010
#define inf 0x3f3f3f3f
int ans=0;
struct node{
    int v,next,c;
}e[maxm<<1];
int h[maxn],tot,n,m;
void adde(int u,int v,int c){
    tot++;
    e[tot].v=v;
    e[tot].c=c;
    e[tot].next=h[u];
    h[u]=tot;
}
int dis[maxn];
bool vis[maxn];
struct qu{
    int id,dis;
    bool operator < (const qu t)const{
        return dis>t.dis;
    }
};
priority_queue q;
void dijk(int s){
    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    while(!q.empty())q.pop();
    qu t;
    t.dis=0;
    t.id=s;
    dis[s]=0;
    q.push(t);
    while(!q.empty()){
        t=q.top();q.pop();
        if(vis[t.id])continue;
        vis[t.id]=true;
        ans+=t.dis;
        for(int j=h[t.id];j;j=e[j].next){
            int v=e[j].v;
            if(!vis[v]&&dis[v]>e[j].c){
                dis[v]=e[j].c;
                qu now;
                now.id=v;
                now.dis=dis[v];
                q.push(now);
            }
        }
    }
}
int main(){
    int s=1;
    cin>>n>>m;
    int u,v,c;
    for(int i=1;i<=m;i++){
        cin>>u>>v>>c;
        adde(u,v,c);
adde(v,u,c);
    }
    dijk(s);
cout<endl;
    return 0;
}

kruskal

#include "iostream"
#include "algorithm"
using namespace std;
int n,m,tot,sum,f[5001];
struct node{
int u,v,c;
}a[200010];
int cmp(const node &u,const node &v){
return u.c
}
int getf(int u){
if(f[u]==u)return u;
return f[u]=getf(f[u]);
}
int main(){
cin>>n>>m;
if(m-1){cout<<"orz"<<endl;return 0;}
for(int i=1;i<=m;i++)cin>>a[i].u>>a[i].v>>a[i].c;
for(int i=1;i<=n;i++)f[i]=i;
sort(a+1,a+m+1,cmp);
for(int i=1;i<=m;i++){
int fu=getf(a[i].u),fv=getf(a[i].v);
if(fu!=fv){
            f[fu]=fv;
sum++;
tot+=a[i].c;
}
if(sum==n-1)break;
}
cout<endl;
}

并查集

2020-03-01T14:44:33.000Z

前置知识

哈哈，简单到爆，没有。

引入

并查集是一种快到爆炸的集合算法，可以进行两项基本操作：合并两个集合（并）、查询两个参数是否在一个集合内（查）。这也是它名字的由来。

速度

他有多快呢？
$O(*log n)$
$*log$ 有多可怕：

$n$	$*log n$
$(1,2]$	$1$
$(2,4]$	$2$
$(4,16]$	$3$
$(16,65536]$	$4$
$(65536,2^{65536}]$	$5$

所以n是 $2^{65536}$ 的时候复杂度还只有5。
$2^{65536}$ 有多大，我把他拷进来的时候整个电脑卡死了。我不得不强制重启，然后重新写一遍这段。他有19729位。想通了吧？

如何实现

这么高端的算法，是怎么实现的呢？
其实

它的本质就是一个数组 $f[]$ ，和一个函数 $getf()$
$f[]$ 存的实际上就是几棵树。
$f[i]$ 就是 $i$ 的父亲。
$getf(i)$ 做的操作就是递归顺着 $f[i]$ 找 $i$ 所在的树的根。
$getf()$ 代码：

int getf(int x){
if(f[x]==x)return x;
else return getf(f[x]);
}

$...$

那这个算法就很低端了 $...$

那还讲个鬼啊 $...$

所以

超级优化

我们首先随机造出一些操作：

10
merge 1 5
merge 5 2
merge 1 3
check 2 3
merge 3 4
merge 6 7
check 1 7
merge 7 8
merge 8 9
merge 1 9
check 7 4

其中，merge代表合并，check代表查询。
如果按照刚才所的算法，那么在第一次查询之前，就会出来这样的森林：
到最后，就形成了这样一个繁杂的森林，要找到一个点的根，就需要走很长一段路。这就拉长了时间。

为了缩减时间，超级优化就出现了：路径压缩。
路径压缩其实也很简单：在 $getf()$ 查找根节点的同时，把自己也链接到根节点上，使得树的深度不超过2。
代码：

int getf(int x){
if(f[x]==x)return x;
else return f[x]=getf(f[x]);
}

发现没有，和之前的代码相比，只改了一个地方，就让时间大大压缩。
这时我们在模拟一下。
第一次合并：
第二次合并时，首先寻找2,5两个节点的根节点，2的根就是2，5的根是1，于是直接把2链接到1上。

第三次，第四次合并把3链接到了1上，然后把4顺着3也链接到了1上，第五次连接了6和7。

第七次第八次链接成了 $9\rightarrow8\rightarrow7\rightarrow6$ 一长串，然后经过路径压缩都链接到6上了。

最后一次，把9和1链接起来了，这时深度又超过了2，一下还压缩不下去，不过没关系，查询的时候就会把它压缩的。
比如查询7和4的时候就会分别寻找7和4的根节点，一路递归找上去的时候就直接把路径压缩好了，除了8还链接在6上，其他全部链接到1上了。

多么有趣啊！

代码

自己想去吧，核心代码和思路都给出来了。
有一个巨大的坑，就是 $f[i]$ 要预设成 $i$ ，不然会爆炸。
加油！~~克服恐惧的最好办法就是面对恐忄~~快去写吧！

树链剖分

2020-03-01T14:41:02.000Z

前置知识

必备：存图方式（邻接表，邻接矩阵），dfs序。
维护：线段树、树状数组、BST。
不会的快进入链接学习吧！

引入

树链剖分，简单来说就是把树分割成链，然后维护每一条链。一般的维护算法有线段树，树状数组和BST。复杂度为 $O(log n)$ 。

剖分方式

对于每一个节点，它的子节点中子树的节点数最大的为重儿子，连接到重儿子的边称为重边。例如：

加粗节点为重儿子。 $4$ $5$ $6$ 节点的重量都一样，所以你想上哪个成为重儿子那个就是重儿子。除重儿子和重边外的节点和边均为轻儿子或轻边。根不是重儿子也不是轻儿子 ~~，有脑子的人都会想一想，它根本就不是什么儿子！~~ 。
以轻儿子或者根为起点的，由重边连接的一条连续的链称为重链。特别地，若一个叶子结点是轻儿子，那么便有一条以该叶子结点为起点的长度为1的重链。上图中， $1-3-7-9$ 是一条重链， $6$ 一个节点也是一条重链。

预处理

树链剖分的预处理本质上就是2个dfs。

dfs NO.1

一共完成四项任务。

标记节点深度： $dep[]$
标记节点的父节点： $fa[]$
标记节点的子树大小： $siz[]$
标记节点的重儿子编号： $son[]$

代码：

void dfs_1(int u,int f){
    siz[u]=1;
    int maxson=-1;
    for(int i=head[u];i!=-1;i=edge[i].nxt){
int v=edge[i].v;
        if(v==f) continue;
fa[v]=u;
dep[v]=dep[u]+1;
dfs_1(v,u);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]])son[u]=v;
    }
}

dfs NO.2

完成三项任务。

标记dfs序（先重后轻）： $idx[]$
标记dfs序对应的节点： $rnk[]$
标记节点所在重链的顶端： $top[]$

代码：

void dfs_2(int u,int tp){
    idx[u]=++dfn;
    rnk[dfn]=a[u];
    top[u]=tp;
    if(!son[u])return;
    dfs_2(son[u],tp);
    for(int i=head[u];i!=-1;i=edge[i].nxt){
        if(!idx[edge[i].v]){
            dfs_2(edge[i].v,edge[i].v);
}
}
}

维护

这里以洛谷的P3384为例
要求维护四种操作：

操作1：格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z
操作2：格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和
操作3：格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z
操作4：格式： 4 x 表示求以x为根节点的子树内所有节点值之和

要处理两点间的路径时：
首先找到两个节点中较深的那个点，然后将对该店所在链进行处理，并将该点移动至所在链顶端节点的父节点。因为是按照轻重边为优先级做的dfs，所以一条链上的编号一定是连续的。
循环执行直到两个点在一条链上，这时再处理两个点之间的区间即可。
要处理一个点的子树时：
因为是dfs序，所以子树的dfs序一定是连续的区间，直接处理该区间即可。

因为都是处理区间，所以用线段树维护。

完整代码

因为题目中还有一个毒瘤%p，所以代码显得很繁杂。

#include "bits/stdc++.h"
using namespace std;
const int N=2000100;
#define lson id<<1
#define rson id<<1|1
inline int read(){
    int c=1,q=0;char ch=' ';
    while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
    if(ch=='-')c=-1,ch=getchar();
    while(ch>='0'&&ch<='9')q=q*10+ch-'0',ch=getchar();
    return c*q;
}
struct node{
    int u,v,nxt;
}e[N];
int head[N];
int tot=1;
struct Tree{
    int l,r,c,siz,f;
}t[N];
int n,m,root,p,dfn=0,rnk[N],a[N];
inline void add(int x,int y){
    e[tot].u=x;
    e[tot].v=y;
    e[tot].nxt=head[x];
    head[x]=tot++;
}
int dep[N],fa[N],son[N],siz[N],top[N],idx[N];
void dfs_1(int u,int f){
    siz[u]=1;
    for(int i=head[u];i;i=e[i].nxt){
int v=e[i].v;
        if(v==f) continue;
fa[v]=u;
dep[v]=dep[u]+1;
dfs_1(v,u);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]])son[u]=v;
    }
}
void update(int id){
    t[id].c=(t[lson].c+t[rson].c+p)%p;
}
void Build(int id,int L,int R){
    t[id].l=L;t[id].r=R;t[id].siz=R-L+1;
    if(L==R){
        t[id].c=rnk[L];
        return;
    }
    int mid=(L+R)>>1;
    Build(lson,L,mid);
    Build(rson,mid+1,R);
    update(id);
}
void dfs_2(int u,int tp){
    idx[u]=++dfn;
    rnk[dfn]=a[u];
    top[u]=tp;
    if(!son[u])return;
    dfs_2(son[u],tp);
    for(int i=head[u];i;i=e[i].nxt){
        if(!idx[e[i].v]){
            dfs_2(e[i].v,e[i].v);
}
}
}
void pushdown(int id){
    if(!t[id].f) return ;
    t[lson].c=(t[lson].c+t[lson].siz*t[id].f)%p;
    t[rson].c=(t[rson].c+t[rson].siz*t[id].f)%p;
    t[lson].f=(t[lson].f+t[id].f)%p;
    t[rson].f=(t[rson].f+t[id].f)%p;
    t[id].f=0;
}
void addroute(int id,int L,int R,int c){
    if(L<=t[id].l&&t[id].r<=R){
        t[id].c+=t[id].siz*c;
        t[id].f+=c;
        return;
    }
    pushdown(id);
    int mid=(t[id].l+t[id].r)>>1;
    if(L<=mid)addroute(lson,L,R,c);
    if(R>mid)addroute(rson,L,R,c);
    update(id);
}
void addtree(int x,int y,int c){
    while(top[x]!=top[y]){
        if(dep[top[x]]
        addroute(1,idx[top[x]],idx[x],c);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])swap(x,y);
    addroute(1,idx[x],idx[y],c);
}
int sumroute(int id,int L,int R){
    int ans=0;
    if(L<=t[id].l&&t[id].r<=R)
        return t[id].c;
    pushdown(id);
    int mid=(t[id].l+t[id].r)>>1;
    if(L<=mid) ans=(ans+sumroute(lson,L,R))%p;
    if(R>mid)  ans=(ans+sumroute(rson,L,R))%p;
    return ans;
}
void treesum(int x,int y){
    int ans=0;
    while(top[x]!=top[y]){
        if(dep[top[x]]
        ans=(ans+sumroute(1,idx[top[x]],idx[x]))%p;
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    ans=(ans+sumroute(1,idx[x],idx[y]))%p;
    printf("%d\n",ans);
}
int main(){
    n=read();m=read();root=read();p=read();
    for(int i=1;i<=n;i++) a[i]=read();
    for(int i=1;i<=n-1;i++){
        int x=read(),y=read();
        add(x,y);add(y,x);
    }
    dfs_1(root,root);
    dfs_2(root,root);
    Build(1,1,n);
    while(m--){
        int op=read(),x,y,z;
        if(op==1){    
            x=read();y=read();z=read();z=z%p;
            addtree(x,y,z);
        }
        else if(op==2){
            x=read();y=read();
            treesum(x,y);
        }
        else if(op==3){
            x=read(),z=read();
            addroute(1,idx[x],idx[x]+siz[x]-1,z%p);
        }
        else if(op==4){
            x=read();
            printf("%d\n",sumroute(1,idx[x],idx[x]+siz[x]-1));
        }
    }
    return 0;
}

完结撒花~~

plan

2020-03-01T14:36:07.000Z

This page is locked.

薄弱项

作文
1. 写日记
  - 每天固定 9:00-9:30
  - 内容不必精美
  - 一周写五天，两天机动
2. 读书
  - 作文辅导书为主 作文大全等
  - 其他书籍为辅
3. 录音
阅读题
1. 读书
  - 文学性书籍
  - 名著阅读课程化丛书
2. 做练习
  - 现代文阅读技能训练 $\color{red}\texttt{100}$ 篇
文学常识
1. 上课时记文常笔记，每篇课文前均有
2. 文常辅导书 待购买
文言文
1. 阅读
  - 世说新语
  - 论语
2. 做练习 待购买
备注
- 日记 100 字起步，逐渐提升
- 阅读每天至少 30 min
- 录音每日 $5\to10$ min

每月考核

作文
1. 日记完成率 $80\%$ 以上
2. 考试作文分数尽量 $\uparrow$
3. 学习一项作文技能
阅读题
1. 读完一本长篇的 $30\%\to50\%$ 或一本短篇
2. 现代文阅读完成至少5篇
文学常识
1. 文常笔记检查
2. 辅导书 待购买
文言文
1. 一周背一篇短篇文言文
2. 辅导书 待购买

三月考核

由 $3$ 月到 $4$ 月，喜马拉雅《人类群星闪耀时》录制共 $11$ 篇，完成率 $33\%$ 。朗读至第三章：亨德尔的复活。

日记由 $3/1$ 坚持记录至 $3/17$ ，其中 $12$ 日至 $16$ 日停顿。

文言文学习未坚持，只完成了两三次。

对《人类群星闪耀时》的阅读进行到了第五章，前四章内容分别为：巴尔沃亚发现大西洋，君士坦丁堡被攻陷，亨德尔被中风击倒后重回音乐生涯，以及拿破仑的失败。

四月考核

五月考核

六月考核

七月考核

八月考核

test

2020-03-01T03:06:43.000Z

$\texttt{Is KaTeX working?-IT WORKED!NICE!}$

a^b

\left(\dfrac{a}{b}\right)