Wyxoi's Blog

数论函数一丢题解

2016-04-22T06:16:03.000Z

省选二试之前刷数论~~(水)~~，来写一写题解。

Aimer女神的新歌，三天4000+的评论，期待完整版
突然想起来我是不是还有一个主席树的坑。。(:з」∠) 。。算了不管他了。。

BZOJ 2301: [HAOI2011]Problem b

点击这里去虐题
题意要求$\sum_{i=a}^{b}\sum_{j=c}^{d}e(gcd(i,j)=k)$
首先我们可以利用容斥，将二维区间的询问改为四个二维前缀的询问。
然后显然的$\sum_{i=1}^{n}\sum_{j=1}^{m}e(gcd(i,j)=k)=\sum_{i=1}^{\lfloor\frac{n}{k}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{k}\rfloor}e(gcd(i,j))$
然后尝试化简
$$
\begin{align}
& \ \sum_{i=1}^{n}\sum_{j=1}^{m}e(gcd(i,j)) \\
= & \ \sum_{i=1}^{n}\sum_{j=1}^{m}\sum_{d|gcd(i,j)}\mu(d) \\
= & \ \sum_{d}\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}\mu(d) \\
= & \ \sum_{d}\mu(d)\lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor \\
\end{align}
$$
对于$\lfloor\frac{n}{d}\rfloor$的值，只有$\sqrt{n}$种，预处理莫比乌斯函数前缀和之后分段处理。

BZOJ 2005: [Noi2010]能量采集

点击这里去虐题
题意要求
$$
\begin{align}
& \ \sum_{i=1}^{n}\sum_{j=1}^{m}(gcd(i,j)*2-1) \\
= & \ 2*\sum_{i=1}^{n}\sum_{j=1}^{m}gcd(i,j)-n*m \\
\end{align}
$$
然后就如同上题一样求出$\sum_{i=1}^{n}\sum_{j=1}^{m}gcd(i,j)$即可

BZOJ 2820: YY的GCD

点击这里去虐题
题意要求$\sum_{i=1}^{n}\sum_{j=1}^{m}1(gcd(i,j)是质数)$
我们设$f(n)=
\begin{cases}
1\ \ \ n是质数 \\
0\ \ \ n不是质数 \\
\end{cases}
$
于是问题就变成了求$\sum_{i=1}^{n}\sum_{j=1}^{m}f(gcd(i,j))$了
$$
\begin{align}
& \ \sum_{i=1}^{n}\sum_{j=1}^{m}f(gcd(i,j)) \\
= & \ \sum_{d}\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}f(d)e(gcd(i,j)) \\
= & \ \sum_{d}f(d)\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}\sum_{d’|gcd(i,j)}\mu(d’) \\
= & \ \sum_{d}\sum_{d’}f(d)\mu(d’)\sum_{i=1}^{\lfloor\frac{n}{dd’}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{dd’}\rfloor} \\
= & \ \sum_{d}\sum_{d’}f(d)\mu(d’)\lfloor\frac{n}{dd’}\rfloor\lfloor\frac{m}{dd’}\rfloor \\
\end{align}
$$
设$g(n)=\sum_{d|n}f(d)\mu(\frac{n}{d})$
$$
\begin{align}
& \ \sum_{d}\sum_{d’}f(d)\mu(d’)\lfloor\frac{n}{dd’}\rfloor\lfloor\frac{m}{dd’}\rfloor \\
= & \ \sum_{i=1}^{n}g(i)\lfloor\frac{n}{i}\rfloor\lfloor\frac{m}{i}\rfloor \\
\end{align}
$$
然后与上题类似预处理g的前缀和，对函数分段计算。

BZOJ 3309: DZY Loves Math

点击这里去虐题
将上题中的函数f的定义换一下就可以。

BZOJ 2154: Crash的数字表格

点击这里去虐题
题意要求$\sum_{i=1}^{n}\sum_{j=1}^{m}lcm(i,j)$
尝试转化成枚举Gcd的形式
$$
\begin{align}
& \ \sum_{i=1}^{n}\sum_{j=1}^{m}\left(\frac{i*j}{gcd(i,j)}\right) \\
= & \ \sum_{d}\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}\left(\frac{id*jd}{d}\right)e(gcd(i,j)) \\
= & \ \sum_{d}d\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}i*j\sum_{d’|gcd(i,j)}\mu(d’) \\
= & \ \sum_{d}\sum_{d’}d*d’^2*\mu(d’)\sum_{i=1}^{\lfloor\frac{n}{dd’}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{dd’}\rfloor}i*j \\
\end{align}
$$
很显然的可以得到$\sum_{i=1}^{n}\sum_{j=1}^{m}i*j=\frac{1}{4}nm(n+1)(m+1)$
与上题类似地设$g(n)=\sum_{d|n}d^2*\mu(d)*\frac{n}{d}$
$$
\begin{align}
& \ \sum_{d}\sum_{d’}d*d’^2*\mu(d’)\sum_{i=1}^{\lfloor\frac{n}{dd’}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{dd’}\rfloor}i*j \\
= & \ \sum_{i}g(i)\sum_{i=1}^{\lfloor\frac{n}{i}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{i}\rfloor}i*j
\end{align}
$$
因为g是积性函数，所以可以做到$O(n)$预处理。

BZOJ 2693: jzptab

点击这里去虐题
与上题相同，多组数据

BZOJ 3560: DZY Loves Math V

点击这里去虐题
题意要求$\sum_{i_1|a_1}\sum_{i_2|a_2}\cdots\sum_{i_n|a_n}\varphi(i_{1}i_{2}\cdots i_n)$
我们知道$\varphi$是一个积性函数，考虑通过积性函数的性质进行计算
考虑分解质因子计算，求出每一种质因子的$\varphi$值即可，先计算出所有的组合情况
设$q_i$为$p$因子在$a_i$中出现的次数，那么就是要求$$sum=\prod_{i=1}^{n}\sum_{k=0}^{q_i}p_i$$
只有不含$p$因子的那一项不乘$\frac{p-1}{p}$，单独处理即可，易得对答案的贡献为$$\frac{p-1}{p}(sum-1)+1$$
当$a_i$较大的时候需要使用rho等高效的分解质因数方法。

BZOJ 3561: DZY Loves Math VI

点击这里去虐题
题意要求$$\sum_{i=1}^{n}\sum_{j=1}^{m}lcm(i,j)^{gcd(i,j)}$$
考虑改为枚举gcd的形式
$$
\begin{align}
& \ \sum_{i=1}^{n}\sum_{j=1}^{m}(\frac{i*j}{gcd(i,j)})^{gcd(i,j)} \\
= & \ \sum_{d}\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}(\frac{id*jd}{d})^{d}e(gcd(i,j)) \\
= & \ \sum_{d}d^{d}\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{d}\rfloor}(i*j)^{d}\sum_{d’|gcd(i,j)}\mu(d’) \\
= & \ \sum_{d}d^{d}\sum_{d’}\mu(d’)\sum_{i=1}^{\lfloor\frac{n}{dd’}\rfloor}\sum_{j=1}^{\lfloor\frac{m}{dd’}\rfloor}(id’*jd’)^{d} \\
= & \ \sum_{d}d^{d}\sum_{d’}\mu(d’)d’^{2d’}\sum_{i=1}^{\lfloor\frac{n}{dd’}\rfloor}i^d\sum_{j=1}^{\lfloor\frac{m}{dd’}\rfloor}j^d \\
\end{align}
$$
对于每一个$d$暴力维护一下$\sum_{d’}\mu(d’)d’^{2d’}$和$\sum_{i=1}^{\lfloor\frac{n}{dd’}\rfloor}i^d$即可

BZOJ 3739: DZY loves math VIII

点击这里去虐题
题意要求$$\sum_{i=1}^{n}\sum_{j=1}^{i}\mu(lcm(i,j)^{gcd(i,j)})$$

有错误请指出$$Continue…$$

三月走了啊

2016-03-31T11:53:29.000Z

本来还没有什么感觉，晚上翻博客的时候看到了一个月前发癫的时候写的博客，才意识到已经一个月过去了。

一个月过去了，天气已经越来越暖和了。绍一的樱花落了，取而代之的美丽是慢慢葱郁的爬山虎。一切都在悄无声息地改变着。而一个月后的我呢。还是这样的无力。

省一以后机房里少了好多人，外省的神犇走了。高二的一些学长也不来了。又一年的省选季。不如说是又一年的退役季吧。去年也是今年也是，看着一些学长胸怀梦想来到这里，然后失落地离去。

明年这个时候。应该就是我离去的时候了吧。离开这个逃避现实的避风港。是啊我一直在逃避着。一直想着，还有一年多吧，时间还有啊。什么时候励励志就能追上去的吧。

明明已经是被甩在身后的爬虫，却每天生活在幻想里。为一些没有意义的事情浪费时间，还沾沾自喜着。庸庸碌碌地过着每一天，就像现在这样一个月来毫无进步。

是我不适合OI吧，只能这样安慰自己了。也许一心一意搞文化课会有点成绩呢。可是我怎么又会不知道呢，只要是石头，到哪里都不会发光的。

不想写一些励志的话。我做不到的。爬虫还是继续活在自己的世界里好吧。

谁も仆を望まない

そんな世界だったらいいのかな

主席树预习与整理

2016-03-31T10:47:23.000Z

这几天在看主席树的题目，发现我数据结构能力缺失严重，主席树几~~(根)~~乎~~(本)~~忘~~(不)~~了~~(会)~~。于是来整理复~~(预)~~习一下主席树相关的内容。

这几天好像洛天依的歌听上瘾了。。(:з」∠)

关于主席树是什么，通俗的来说就是对于一个序列每一个前缀建一颗线段树，利用区间减法的性质快速维护一段区间的信息。

$$\mathcal {Loading\ldots}$$

有错误请指出$$\mathcal {Continue\ldots}$$

一道题目引发的惨案

2016-03-30T09:27:44.000Z

这是一个因为插比利而发生的惨案，进而引出了一堆坑。_(:з」∠)_

一切罪恶的根源啊呸没有罪恶BZOJ3236
事情是怎么样发生的呢。。。当时我听到比利和qiancl在讨论3236，大概的题目是一个序列，求l，r间属于[a,b]的颜色种数。当时我这道题目是用莫队套分块过去的，复杂度是$O(N\cdot \sqrt{N})$的。然后这道题目想一想应该是可以用树套树什么的$log^2N$做的，但是时间和编程复杂度不一定比莫队优。

这个时候比利就开始口胡了，说有一只$log$的做法，他说可以把询问区间插成前缀和，排序后就可以一只$log$维护答案了。一听感觉有点道理，但是好像维护的是颜色种类不满足减法，妈的智障。

然后比利又开始口胡，既然拆区间拆不了可以把询问的颜色范围拆成两个，然后前缀和，现在总满足减法了吧。突然感觉好有道理。然后细想询问排序之后的插入还是需要一个数据结构维护，所以复杂度还是两只$log$的。妈的智障，并没有什么区别。

事情还并没有结束，晚自修的时候，比利走过来和我说他在PoPoQQQ的blog上看到了一只$log$的做法，好像是用主席树在线维护区间颜色种类。感觉很高端的样子，一翻BZOJ翻出来一堆类似的题目。(:з」∠)

我看到这些题目的第一反应就是，奥这道题目啊不是莫队吗，奥这个不是带修改莫队吗，奥这道题我好像以前是用莫队水过去的。。(:з」∠)

感觉我数据结构能力缺失得有点严重，还是补一下比较好。

所以上面写了一堆废话，让我们来总结一下这篇博文的主题是什么。

用主席树求区间颜色种类的在线带修改算法。（怎么这么绕呢）

如果不会主席树可以去这里学习。

序幕：离线求不带修改区间颜色种类

例题：1878: [SDOI2009]HH的项链
~~（很多题解里都提到了这道题的树状数组离线做法，然而我一点印象都没有，后来才发现我写的是莫队，妈的智障）~~
这道题主要的问题是要求区间的颜色种数，一种颜色只能被计算一次。我们可以对序列预处理一下，处理出每一个点之前的第一个与他相同的点的位置，记为next[i]。然后对于一个区间[l,r]里只出现一次的点，显然满足next<l。
然后我们把询问离线，按照r排序，按照顺序插入节点，树状数组维护next小于l的数量，就可以在log的时间内处理问题了。

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 1000010;
using namespace std;
int S[N],val[N],head[N],next[N],n,m,now,ans[N];
struct data{int x,y,id;} q[N];
int read(){
	int x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
int lowbit(int x){return x&-x;}
int Query(int pos){
	int res = 0;
	for (int i=pos;i;i-=lowbit(i)) res+=S[i];
	return res;
}
void Update(int pos,int val) {for (int i=pos;i<=n+2;i+=lowbit(i)) S[i]+=val;}
bool cmp(data a,data b){return a.y<b.y;}
int main(){
	n = read();
	for (int i=1;i<=n;i++) {
		val[i] = read();
		next[i] = head[val[i]];
		head[val[i]] = i;
	}
	m = read();
	for (int i=1;i<=m;i++) q[i].x = read(),q[i].y = read(),q[i].id = i;
	sort(q+1,q+1+m,cmp);
	for (int i=1;i<=m;i++) {
		while (now<q[i].y) {
			now++;
			Update(next[now]+1,1);
			Update(now+1,-1);
		}
		ans[q[i].id] = Query(q[i].x);
	}
	for (int i=1;i<=m;i++) printf("%d\n",ans[i]);
}

发展：在线求不带修改区间颜色种类

例题：1878: [SDOI2009]HH的项链（找不到强制在线的模板题了，可以把它当成在线做(:з」∠)）
和上一道题目的想法相似，稍微改变一下next[i]为一个点之后与他相同的点的位置，然后也是可以显然的知道在区间[l,r]之间只出现一次的点的next>r。然后我们可以发现这个东西是满足区间减法的。
于是可以想到用主席树求解。对于第i颗线段树在next[i]的位置+1。这样我们就可以容易地求出1~x中next>y的点的数量（在第x颗线段树上对y+1~n+1求和），求区间可以转化成前缀相减的形式。然后就可以在线了。

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 100010;
using namespace std;
int read(){
	int x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
struct Tree{int ls,rs,sum;} tree[3000010];
int next[1000010],head[1000010],val[N],x,y,n,m,treesize,root[N];
void Update(int l,int r,int x,int &y,int val){
	y = ++treesize;tree[y].sum = tree[x].sum+1;
	if (l==r) return;
	int mid = (l+r)>>1;
	tree[y].ls = tree[x].ls;tree[y].rs = tree[x].rs;
	if (val<=mid) Update(l,mid,tree[x].ls,tree[y].ls,val);
	else Update(mid+1,r,tree[x].rs,tree[y].rs,val);
}
int Query(int L,int R,int pos,int l,int r){
	if (L==l && R==r) return tree[pos].sum;
	int mid = (L+R)>>1;
	if (r<=mid) return Query(L,mid,tree[pos].ls,l,r);
	else if (l>mid) return Query(mid+1,R,tree[pos].rs,l,r);
	else return Query(L,mid,tree[pos].ls,l,mid)+Query(mid+1,R,tree[pos].rs,mid+1,r);
}
int main(){
	n = read();
	for (int i=1;i<=n;i++) val[i] = read();
	for (int i=n;i;i--) {
		if (head[val[i]]==0) next[i] = n+1;
		else next[i] = head[val[i]];
		head[val[i]] = i;
	}
	for (int i=1;i<=n;i++) Update(1,n+1,root[i-1],root[i],next[i]);
	m = read();
	for (int i=1;i<=m;i++) {
		x = read();y = read();
		printf("%d\n",Query(1,n+1,root[y],y+1,n+1)-Query(1,n+1,root[x-1],y+1,n+1));
	}
}

一道相似的题目BZOJ4026: dC Loves Number Theory
题面是求一段区间内数乘积的$\varphi$，考虑$\varphi$的值，设$n=p_1^{q_1}\cdot p_2^{q_2}\ldots p_k^{q_k}$,$\varphi(n)=n\cdot \Pi_{i=1}^{k} \frac {p_i-1}{p_i}$
我们发现只与不相同的素数有关，就转化成了求一段区间内的不相同素数的$\frac {p_i-1}{p_i}$的值的积了。因为是对1e6+777取模，所以数的范围很小，可以直接暴力分解质因数，然后类似上一题的用主席树维护。（注意因为这个是乘积，所以要初始化第一棵树）。

#include <cstdio>
#include <cstring>
#include <algorithm>
const int RXD = 1e6+777;
const int N = 1000010;
using namespace std;
int inv[RXD+10],prime[RXD+10],vis[RXD+10],a[N],S[N],A[N],L[N],R[N],n,m,treesize,cnt,l,r,ans,last,tot,head[N],next[N],root[N];
int read(){
	int x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
struct Tree{int ls,rs,val;} tree[5000010];
void Prep(){
	inv[0] = inv[1] = 1;
	for (int i=2;i<=RXD;i++) inv[i] = ((1ll*RXD-RXD/i)*inv[RXD%i]+RXD)%RXD;
	for (int i=2;i<=RXD;i++){
		if (!vis[i]) prime[++tot] = i;
		for (int j=1;j<=tot && prime[j]*i<=RXD;j++) {
			vis[prime[j]*i] = 1;
			if (i%prime[j]==0) break;
		}
	}
}
void Build(int pos,int l,int r){
	tree[pos].val = 1;if (l==r) return; int mid = (l+r)>>1;
	tree[pos].ls = ++treesize;tree[pos].rs = ++treesize;
	Build(tree[pos].ls,l,mid);Build(tree[pos].rs,mid+1,r);
}
void Update(int l,int r,int x,int &y,int val,int w){
	y = ++treesize;
	tree[y].val = 1ll*tree[x].val*(w-1)%RXD*inv[w]%RXD;
	if (l==r) return;
	int mid = (l+r)>>1; 
	tree[y].ls = tree[x].ls;tree[y].rs = tree[x].rs;
	if (val<=mid) Update(l,mid,tree[x].ls,tree[y].ls,val,w);
	else Update(mid+1,r,tree[x].rs,tree[y].rs,val,w);
}
int Query(int L,int R,int pos,int l,int r){
	if (L==l && R==r) return tree[pos].val;
	int mid = (L+R)>>1;
	if (r<=mid) return Query(L,mid,tree[pos].ls,l,r);
	else if (l>mid) return Query(mid+1,R,tree[pos].rs,l,r);
	else return 1ll*Query(L,mid,tree[pos].ls,l,mid)*Query(mid+1,R,tree[pos].rs,mid+1,r)%RXD;
}
int main(){
	n = read();m = read();Prep();S[0] = 1;
	for (int i=1;i<=n;i++) A[i] = read(),S[i] = (1ll*S[i-1]*A[i])%RXD;
	for (int i=1;i<=n;i++) {
		L[i] = cnt+1;int x = A[i];
		for (int j=1;j<=tot && prime[j]*prime[j]<=x;j++)
			if (x%prime[j]==0) {a[++cnt] = prime[j];while (x%prime[j]==0) x/=prime[j];}
		if (x!=1) a[++cnt] = x;
		R[i] = cnt;
	}
	n = cnt;
	for (int i=n;i;i--) {
		if (head[a[i]]==0) next[i] = n+1;
		else next[i] = head[a[i]];
		head[a[i]] = i;
	}
	treesize = 1;root[0] = 1;
	Build(1,1,n+1);
	for (int i=1;i<=n;i++) Update(1,n+1,root[i-1],root[i],next[i],a[i]);
	for (int i=1;i<=m;i++){
		int l = read()^last,r = read()^last;
		ans = 1ll*S[r]*inv[S[l-1]]%RXD;
		l = L[l];r = R[r];
		last=(1ll*ans*Query(1,n+1,root[r],r+1,n+1)%RXD*inv[Query(1,n+1,root[l-1],r+1,n+1)]%RXD);
		printf("%d\n",last);
	}
}

高潮：在线求带修改区间颜色种数

例题：2120: 数颜色
推广到带修改的问题上的方法和一般的主席树一样，主要使用主席树前缀相减的思想，用树状数组套权值线段树。每次询问的时候就在树状数组节点的线段树上询问，然后合并答案。修改需要修改所有包含该节点的线段树。因为这道题权值位置是在next的位置上，所以还需要记录前驱后继，可以直接用一个set维护信息。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
#define N 20010
#define M 800010
set <int> col[N];
set <int> :: iterator it;
struct xy{int x,y;char ctrl[3];}q[N];
int a[N],san[N],next[N],v[N],pre[N],c[N],L[N],R[N],root[N];
int ls[M],rs[M],sum[M];
int n,m,ne,cnt,tot,numa,numb;
char ch;
void read(int &x){
   while (ch = getchar(),ch < '0' || ch > '9');
   x = ch - '0';
   while (ch = getchar(),ch >= '0' && ch <= '9') x = x * 10 + ch - '0';
}
inline void update(int lson,int rson,int x,int k){
   sum[++ tot] = sum[x] + k,ls[tot] = lson,rs[tot] = rson;
}
inline int change(int x,int l,int r,int y,int k){
   if (l == r) {update(0,0,x,k);return tot;}
   int m = l + r >> 1;
   if (y <= m) ne = change(ls[x],l,m,y,k),update(ne,rs[x],x,k);
   else ne = change(rs[x],m + 1,r,y,k),update(ls[x],ne,x,k);
   return tot;
}
inline void bitup(int x,int p,int k){
   for (;x <= n;x += x & -x)
       c[x] = change(c[x],1,n + 1,p,k);
}
int ask(int *a,int numa,int *b,int numb,int k){
   int ans = 0,l = 1,r = n + 1,m;
   while (l < r){
       m = l + r >> 1;
       if (k >= m) {
           for (int i = 0;i < numa;i ++) a[i] = rs[a[i]];
           for (int i = 0;i < numb;i ++) b[i] = rs[b[i]];
           l = m + 1;
       }else{
           for (int i = 0;i < numa;i ++) ans -= sum[rs[a[i]]];
           for (int i = 0;i < numb;i ++) ans += sum[rs[b[i]]];
           for (int i = 0;i < numa;i ++) a[i] = ls[a[i]];
           for (int i = 0;i < numb;i ++) b[i] = ls[b[i]];
           r = m;
       }
   }
   for (int i = 0;i < numa;i ++) ans -= sum[a[i]];
   for (int i = 0;i < numb;i ++) ans += sum[b[i]];
   return ans;
}
int query(int x,int y){
   numa = numb = 0;
   int k = y;
   L[numa ++] = root[x];
   for (;x;x -= x & -x) L[numa ++] = c[x];
   R[numb ++] = root[y];
   for (;y;y -= y & -y) R[numb ++] = c[y];
   return ask(L,numa,R,numb,k);
}
int main(){
   read(n);read(m);
   for (int i = 1;i <= n;i ++) read(a[i]),san[++ cnt] = a[i];
   for (int i = 1;i <= m;i ++){
       scanf("%s",q[i].ctrl);
       read(q[i].x);read(q[i].y);
       if (q[i].ctrl[0] == 'R') san[++ cnt] = q[i].y;
   }
   sort(san + 1,san + 1 + cnt);
   cnt = unique(san + 1,san + 1 + cnt) - san - 1;
   for (int i = 1;i <= n;i ++) a[i] = lower_bound(san + 1,san + 1 + cnt,a[i]) - san;
   for (int i = 1;i <= n;i ++){
       next[i] = n + 1;
       if (!v[a[i]])
           v[a[i]] = i;
       else {
           next[v[a[i]]] = i;
           pre[i] = v[a[i]];
           v[a[i]] = i;
       }
       col[a[i]].insert(i);
   }
   for (int i = 1;i <= n;i ++) root[i] = change(root[i - 1],1,n + 1,next[i],1),c[i] = root[0];
   for (int i = 1;i <= m;i ++){
       if (q[i].ctrl[0] == 'Q')
           printf("%d\n",query(q[i].x - 1,q[i].y));
       else{
           int pos = q[i].x,val = lower_bound(san + 1,san + 1 + cnt,q[i].y) - san;
           if (pre[pos]){
               bitup(pre[pos],pos,-1);
               next[pre[pos]] = next[pos];
               bitup(pre[pos],next[pos],1);
           }
           if (next[pos] < n + 1)
               pre[next[pos]] = pre[pos];
           bitup(pos,next[pos],-1);
           col[a[pos]].erase(pos);
           
           a[pos] = val;
           it = col[val].upper_bound(pos);
           if (*it > pos){
               next[pos] = *it;
               pre[*it] = pos;
           }else next[pos] = n + 1;
           bitup(pos,next[pos],1);
           if (it != col[val].begin()){
               it --;
               bitup(*it,next[*it],-1);
               next[*it] = pos;
               pre[pos] = *it;
               bitup(*it,next[*it],1);
           }else pre[pos] = 0;
           col[val].insert(pos);
       }
   }
   return 0;
}

尾声：回到3236.

搞完了以上一系列题目以后，然我们回到一切罪恶的源泉啊呸没有罪恶3236.可以发现这是一道不带修改的区间颜色种类询问。但是！！这里的颜色有限制！！！所以。还需要一个数据结构维护，复杂度还是两只log的_(:з」∠)_。我们可以得出结论，比利的口胡能力。太强了。
至于这道题目是写根号还是$log^2$呢。

我强力推荐莫队套分块！！

莫队暴力出奇迹

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int M = 1000010;
const int N = 100010;
struct data{int l,r,a,b,id;} q[M];
int vis[N],s2[N],pos[N],l[N],r[N],n,m,blk,a[N],ans1[M],s1[N],ans2[M];
int read(){
    int x = 0,f = 1,c = getchar();
    while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
    while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
    return x*f;
}
bool cmp(data a,data b){if (pos[a.l]==pos[b.l]) return a.r<b.r;return a.l<b.l;}
void init(){
    n = read();m = read();blk = sqrt(n/2);
    for (int i=1;i<=n;i++){
        a[i] = read();
        pos[i] = (i-1)/blk+1;
        r[pos[i]] = i;
        if (!l[pos[i]]) l[pos[i]] = i;
    }
    for (int i=1;i<=m;i++){
        q[i].l = read();q[i].r = read();
        q[i].a = read();q[i].b = read();
        q[i].id = i;
    }
    sort(q+1,q+1+m,cmp);
}
int Query1(int x,int y){
    int res = 0;
    if (pos[x]==pos[y]){
        for (int i=x;i<=y;i++) if (vis[i]) res+=vis[i];
        return res;
    }
    else {
        for (int i=pos[x]+1;i<pos[y];i++) res+=s1[i];
        for (int i=x;i<=r[pos[x]];i++) if (vis[i]) res+=vis[i];
        for (int i=l[pos[y]];i<=y;i++) if (vis[i]) res+=vis[i];
        return res;
    }
}
int Query2(int x,int y){
    int res = 0;
    if (pos[x]==pos[y]){
        for (int i=x;i<=y;i++) if (vis[i]) res++;
        return res;
    }
    else {
        for (int i=pos[x]+1;i<pos[y];i++) res+=s2[i];
        for (int i=x;i<=r[pos[x]];i++) if (vis[i]) res++;
        for (int i=l[pos[y]];i<=y;i++) if (vis[i]) res++;
        return res;
    }
}
void Add(int x){if (!vis[x]) s2[pos[x]]++;vis[x]++;s1[pos[x]]++;}
void Del(int x){if (vis[x]==1) s2[pos[x]]--;vis[x]--;s1[pos[x]]--;}
void solve(){
    int l = 1,r = 0;
    for (int i=1;i<=m;i++){
        while (r<q[i].r) r++,Add(a[r]);
        while (r>q[i].r) Del(a[r]),r--;
        while (l<q[i].l) Del(a[l]),l++;
        while (l>q[i].l) l--,Add(a[l]);
        ans1[q[i].id] = Query1(q[i].a,q[i].b);
        ans2[q[i].id] = Query2(q[i].a,q[i].b);
    }
}
void write(int x){
    if (x<0) putchar('-'),write(-x);
    if (x>=10) write(x/10);
    putchar(x%10+'0');
}
int main(){
    init();
    solve();
    for (int i=1;i<=m;i++) write(ans1[i]),printf(" "),write(ans2[i]),puts("");
}

后记：通过了这一系列题目的研究我们知道了口胡的危害

有错误请指出$$\mathcal {FIN}$$

省选与之前数论函数讲课的搬运和整合

2016-03-25T11:51:36.000Z

感觉这次省选讲课里好像只有洲爷的课正常，于是就来写一写

好像找不到歌了。。(:з」∠)换一种风格的发发
突然想起来好像给初三讲数论函数的是我。。(:з」∠)，我自己都不会怎么讲。要出事了。
以下内容中涉及函数均为数论函数，即定义域为正整数的函数。
以下内容纯属搬运与口胡，若有错误，欢迎指出~~(请当做没看见)~~。

积性函数
Dirichlet卷积
莫比乌斯反演
一类积性函数求前缀和问题
And more…(这里没有链接，不要点!!)

积性函数

积性函数：$\forall a,b \in N^+,\ gcd(a,b)=1,\ f(a\cdot b)=f(a)\cdot f(b)$
一些常见的积性函数:
欧拉函数：

$\varphi(n)$表示$n$以内与$n$互质的数的个数。
设$n=p_1^{q_1}\cdot p_2^{q_2}\ldots p_k^{q_k}$,$\varphi(n)=n\cdot \Pi_{i=1}^{k} \frac {p_i-1}{p_i}$

莫比乌斯函数：

如果$n$有平方因子，则$\mu (n)=0$
如果$n$没有平方因子，则设$n=p_1^{q_1}\cdot p_2^{q_2}\ldots p_k^{q_k}$，$\mu (n)=(-1)^k$

除数函数：

$\sigma _k(n)$表示$n$的所有正因子的$k$次幂的和。
特别的
- $d(n)=\sigma _0(n)$表示$n$的正因子个数。
- $\sigma(n)=\sigma_1(n)$表示$n$的所有正因子之和。

最大公因数函数：

$gcd(n,k)$在$k$为固定时，$n,k$的最大公因数。

完全积性函数：$\forall a,b \in N^+\ ,f(a\cdot b)=f(a)\cdot f(b)$
一些常见的完全积性函数：
幂函数：

$ld_k(n)=n^k$
特别的
- $1(n)=ld_0(n)=1$
- $ld(n)=ld_1(n)=n$

单位函数：

$\rm e(n)=\epsilon (n)=\begin{cases}1 & n=1 \\0 & n>1\end{cases}$

积性函数的一些性质
性质一：

设$n=p_1^{q_1}\cdot p_2^{q_2}\ldots p_k^{q_k}$，$f(n)=\Sigma_{i=1}^{k} f(p_i^{q_i})$
所以如果可以快速求出$f(p_k^{q_k})$的值，就可以用Euler筛法$O(n)$求出所有$f(i)(i\leq n)$的值。

性质二：

若$f，g$为积性函数，那么
- 它们的点积$(f\cdot g)(i)=f(i)\cdot g(i)$也是积性函数
- 它们的商$(\frac {f}{g})(i)=\frac {f(i)}{g(i)}$也是积性函数

Back To Menu

$Dirichlet$卷积

定义：

两个数论函数$f,g$的$Dirichlet$卷积为：$$(f*g)(n)=\sum_{d|n} f(d)\cdot g(\frac {n}{d})$$

性质：

交换律：$f*g=g*f$
结合律：$(f*g)*h=f*(g*h)$
分配律：$f*(g+h)=f*g+f*h$
单位元：$\epsilon*f=f$
若$f,g$为积性函数，则$f*g$也为积性函数

一些常见的$Dirichlet$卷积：

$d(n)=\sum_{d|n} 1\Leftrightarrow d=1*1$
$\sigma(n)=\sum_{d|n} d\Leftrightarrow \sigma=1*ld$
$\epsilon(n)=\sum_{d|n}\mu(d)\Leftrightarrow \epsilon=1*\mu$
$\varphi(n)=\sum_{d|n}\mu(d)\cdot \frac {n}{d} \Leftrightarrow \varphi=\mu*ld$
$n=\sum_{d|n}\varphi(d)\Leftrightarrow ld=1*\varphi$

Back To Menu

莫比乌斯反演

莫比乌斯反演公式：

如果两个数论函数$f,g$满足$$f(n)=\sum_{d|n}g(d)$$
则它们满足$$g(n)=\sum_{d|n}\mu(d)\cdot f(\frac{n}{d})$$
反之亦然
写成$Dirichlet$卷积形式为$f=g*1\Leftrightarrow g=\mu*f$

证明：

设，$f=g*1$
两边都卷上，$\mu$,得$\mu*f=\mu*g*1$
整理得，$\mu*f=\epsilon*g=g$
两边都卷上1，$g*1=\mu*f*1=\epsilon*f=f$
证毕

莫比乌斯等式：

$${\rm e}(n)=\sum_{d|n}\mu(d)$$
设$$n=\sum_{i=1}^{k} p_i^{q_i}，\ n’=\sum_{i=1}^{k}p_i，\ S=\lbrace 1,2,\ldots ,k\rbrace $$
那么$$\sum_{d|n}\mu(d)=\sum_{d|n’}\mu(d)=\sum_{I\subseteq S}(-1)^I=\sum_{i=0}^{k}{k \choose i}(-1)^i=(1-1)^k$$
证毕

简单的应用：

$$\varphi=\mu*ld\Leftrightarrow ld=\varphi*1$$
$$\varphi(n)=\sum_{d|n}\mu(d)\cdot \frac{n}{d}\Leftrightarrow n=\sum_{d|n}\varphi(d)$$

另一种形式：

在整数集$D$中，$$f(x)=\sum_{x|d,d\in D}g(d)\Leftrightarrow g(x)=\sum_{x|d,d\in D}\mu(d)f(\frac{d}{x})$$
两种形式的本质都是容斥原理

Back To Menu

一类积性函数求前缀和问题

4.22 这个坑不知道已经在这里多久了。。(:з」∠) 。。终于要来填掉了。。

我们知道一般的积性函数可以用欧拉筛$O(n)$求值，但是在一些题目里要求在低于线性的复杂度下求积性函数的前缀和。这个时候我们就需要一种更加高效的求前缀和的算法。

现在OI圈里比较常见的方法是杜教筛，可以做到在$O(n^{\frac{3}{4}})$或$O(n^{\frac{2}{3}})$的时间内求出积性函数的前缀和。

杜教筛：

现在我们要求$S(n)=\sum_{i=1}^{n}f(i)$
我们可以找出另一个函数g，然后考虑$(g*f)(n)$的前缀和
$$
\begin{align}
&\ \sum_{i=1}^{n}(f*g)(i) \\
= &\ \sum_{i=1}^{n}\sum_{j|i}f(j)g(\frac{i}{j}) \\
= &\ \sum_{\frac{i}{j}}^{n}\sum_{j=1}^{\left\lfloor\cfrac{n}{\frac{i}{j}}\right\rfloor}f(j)g(\frac{i}{j}) \\
= &\ \sum_{i=1}^{n}g(i)\sum_{j=1}^{\lfloor\frac{n}{i}\rfloor}f(j) \\
= &\ \sum_{i=1}^{n}g(i)S(\lfloor\frac{n}{i}\rfloor) \\
\end{align}$$
然后我们就可以得到一个关于$S(n)$的递推式$$g(1)S(n)=\sum_{i=1}^{n}(f*g)(i)-\sum_{i=2}^{n}g(i)S(\lfloor\frac{n}{i}\rfloor)$$
所以如果我们可以快速的求出$g$和$(f*g)$的前缀和，那就可以用记忆化搜索做到$O(n^{\frac{3}{4}})$的复杂度。如果原函数也可以快速求前缀和，那我们可以预处理$\sqrt{n}$以内的结果，这样就可以做到$O(n^{\frac{2}{3}})$的复杂度.
现在我们已经可以很轻松的求出简单的积性函数如$\varphi\ \mu$的前缀和了
但是对于一些比较复杂的函数，想要找一个合适的g是比较困难的。对于较复杂的函数一般有两个比较基本的形式
- 求$S(n)=\sum_{i=1}^{n}(f*g)(i)$的值，$g(i)$为完全积性函数，这时有$$S(n)=\sum_{i=1}^{n}[(f*1)\cdot g](i)-\sum_{i=2}^{n}S(\lfloor\frac{n}{i}\rfloor)$$
- 求$S(n)=\sum_{i=1}^{n}(f*g)(i)$的值，这时有$$S(n)=\sum_{i=1}^{n}g(i)\sum_{ij<=n}(f*1)(j)-\sum_{i=2}^{n}S(\lfloor\frac{n}{i}\rfloor)$$
有了这些性质我们就可以较容易地求出积性函数的前缀和了

Back To Menu

有错误请指出$$\mathcal {FIN.}$$

又到一年省选季

2016-03-20T12:03:27.000Z

时间过得好快啊，马上我就要以高一选手的身份参加省选了

Day -1

下午回到学校，看到了一个已经退役的高二学长出现在了机房里。然后机房里的气氛就变得浪了起来虽然我本来就很浪(:з」∠)
听说他们已经凑好了省选时dota五人黑的队伍，想去围观然后意识到我的电脑上已经什么都没有了。。难道省选的时候我只能默默地刷唐顿了吗。。(:з」∠)
占了一晚上网速下完了全集唐顿感觉爽爽哒。。幸好我回寝室之前打开来看了一下，妈的下载的又是生肉。

Day 0

上午浪啊浪啊。码完了第一道非旋转Treap，然后并不敢调，肉眼调试~~（发呆）~~着，就到了中午了。
下午一点半就到学军了，感觉去年好像并没有这么快，是我的错觉吗。
这次的宾馆竟然在浙外学校里面！里面！！！走进学校的时候我还以为要住学生宿舍了，又要过上没电没网的生活了。。(:з」∠)妈的吓死了
晚上还没浪起来就开始头痛了，莫名其妙的就痛了。上次冬令营的时候也一样。难道杭州也会水土不服吗(:з」∠)。对我的适应能力无语了。先去睡了一觉，醒来的时候已经十一点了。中间好像错过了很多事情~~(比如AK爷吃完了所有的KFC)~~。
浪着浪着就一点多了。感觉第一天就这样不是很好。于是就睡了。~~后来得知原来还有没睡的@大圣

Day 1

不到五点就醒来了，果然是我昨天睡太多了吗。去吃早饭的时候发现东西都还没有，随便吃了一点粥面包什么的就算了。
上午洲爷来讲数论，感觉很可听的样子。事实上洲爷讲得也很好，一直到九点半的时候都可以听懂的样子。然后莫名其妙被一道题卡主。看懂之后发现断线太久好像连不回去了。。(:з」∠)。省选讲课就是如此凶残。
然而好像也就洲爷的讲课比较凶残。下午的动态规划和树分治都是从基础开始讲起的，最后也没有特别难。让人感觉这不像是省选讲课。（去年来的时候好像是全程睡觉的节奏呀，为什么今年画风变得这么突然）
晚上本来想好要写完博客的。然后看到大圣和AKY在看动漫，我也忍不住去看了一会儿唐顿。就一直看到了十一点多。(:з」∠)

Day 2

吃早饭的时候听说今天要讲量子计算机，感觉好厉害~~（好怕怕）~~。然而事实是上午一直在讲计算机整数和浮点运算~~(初赛基础知识)~~。上到一半的时候很多神犇都退场了。
这种事以前真的发生过吗。。
感觉有一种不好的预感。果真下午的时候神犇们又都没有出现。。(:з」∠)。期待已久的量子计算机也出现了。然而我只听了十分钟就弃疗了。智商问题并没有办法。。(:з」∠)
晚上看片推白2吃披萨，颓废的人生。

Day 3

比赛日，太悲伤就不说了。我还是去考虑退役的事情吧。、

$${\mathcal {FIN}}$$

闲来无事学数据结构——非旋转Treap

2016-03-20T03:12:28.000Z

星期六的模拟赛里的在线段树上打可持久化Treap的标记感觉好神的样子，就想去学一学。然后Memphis的blog一直崩一直崩woc，要么刷不出图片要么刷不出代码，is-programmer服务器真是妈的智障。

好吧让我先来口胡一下Treap是什么~~(然而我并不会Treap233,从来都是写Spaly的233)~~,顾名思义Treap就是tree+heap.所以Treap就是拥有堆性质的二叉树.对于Treap里的每一个节点拥有两个值,fix和key.对于fix满足堆性质,在任意一颗子树中,根节点的fix为最小值.对于key,满足中序遍历有序.
对于插入删除节点的操作可以用旋转来维护Treap的性质，至于怎么旋转嘛。。我不知道，应该和Splay差不多的吧。

好上面的都不是重点，并没有什么用处~~(其实只是我编不下去了)~~
旋转Treap相较与Splay优点是常数小，但是，好像并不能方便地实现区间的操作。~~(所以还是Splay大法好啊233)~~

所以需要一种可以支持区间操作的Treap，于是非旋转Treap就出现了。
非旋转Treap可以做什么：

Build建树
Split分裂
Merge合并

好像没什么用啊。
但是通过分裂合并就可以提取出一段区间，然后就可以进行区间操作，下传标记等一系列操作。

具体操作的分析

Build

Treap可以实现O(N)建树，具体方法就是用栈维护树右边的一条链，然后每次在树右下角加一个点，维护Treap的性质。
如果栈顶的元素fix值大于插入点的fix，就将栈顶元素弹出。
直到站栈中元素fix满足递增，将弹出的点接在新插入点的左儿子。
复杂度分析：因为每一个点只被弹出一次，所以复杂度为O(N)的。

node *Build(){
	static node *stk[N],*x,*last = null;
	int top = 0;
	for (int i=1;i<=n;i++){
		tot++;x = Nd+tot;x->val = i;last = null;
		while (top && stk[top]->fix>x->fix) {
			stk[top]->Update();
			last = stk[top];
			stk[top--] = null;
		}
		if (top) stk[top]->R = x;
		x->L = last;
		stk[++top] = x;
//		print(stk[1]);puts("");
	}
	while (top) stk[top--]->Update();
	return stk[1];
}

Split

将一颗Treap按照第K位分裂成两半。
就像找第K位一样递归下去，返回的时候合并一下就好了。
复杂度分析：因为Treap期望的树高为Log的，所以Split一次的复杂度为O(LogN)

Droot Split(node *x,int k) {
	if (x==null) return Droot(null,null);
	Droot y;
	x->Down();
	if (x->L->S>=k) {
		y = Split(x->L,k);
		x->L = y.second;
		x->Update();
		y.second = x;
	}
	else {
		y = Split(x->R,k-x->L->S-1);
		x->R = y.first;
		x->Update();
		y.first = x;
	}
	return y;
}
为了可以看清楚没有缩行，其实代码是很短的。

Merge

将两颗相对有序的Treap合并，注意是相对有序，即第一棵Treap的右下角的值要小于第二棵Treap的左下角值。如果不是相对有序的Treap只能通过启发式合并。
合并的时候因为要考虑fix值满足堆性质，可以像可并堆一样地合并，比较根节点的fix，然后递归合并儿子。不过因为要满足Treap的性质，不能交换左右儿子。

node *Merge(node *A,node *B){
	if (A==null && B==null) return null;
	if (A==null) return B;
	if (B==null) return A;
	if (A->fix<B->fix){
		A->Down();
		A->R = Merge(A->R,B);
		A->Update();
		return A;
	}
	else {
		B->Down();
		B->L = Merge(A,B->L);
		B->Update();
		return B;
	}
}

有了这些操作就可以很方便的实现大部分区间操作和删除插入操作。

我们发现这些操作都是从上向下的，所以不需要记父亲。于是，Treap就可以实现可持久化了。
至于怎么实现。我并不知道。学习ing

最后贴一道BZOJ3223的代码，区间翻转.

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 100010;
using namespace std;
int read(){
	int x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
int n,m,l,r,tot;
struct node *null,*rt;
struct node{
	node *L,*R;int S,fix,val,rev;
	void Update(){if (this==null) return;S = L->S+R->S+1;}
	void Setrev(){if (this==null) return;rev^=1;swap(L,R);}
	void Down(){if (this==null) return;if (rev){rev = 0;L->Setrev();R->Setrev();}}
} Nd[N];
typedef pair<node*,node*> Droot;
void print(node *x){if (x==null) return;x->Down();print(x->L);printf("%d ",x->val);print(x->R);}
node *Build(){
	static node *stk[N],*x,*last = null;
	int top = 0;
	for (int i=1;i<=n;i++){
		tot++;x = Nd+tot;x->val = i;last = null;
		while (top && stk[top]->fix>x->fix) {stk[top]->Update();last = stk[top];stk[top--] = null;}
		if (top) stk[top]->R = x;x->L = last;stk[++top] = x;
	}
	while (top) stk[top--]->Update();
	return stk[1];
}
node *Merge(node *A,node *B){
	if (A==null && B==null) return null;
	if (A==null) return B;if (B==null) return A;
	if (A->fix<B->fix){A->Down();A->R = Merge(A->R,B);A->Update();return A;}
	else {B->Down();B->L = Merge(A,B->L);B->Update();return B;}
}
Droot Split(node *x,int k) {
	if (x==null) return Droot(null,null);
	Droot y;x->Down();
	if (x->L->S>=k) {y = Split(x->L,k);x->L = y.second;x->Update();y.second = x;}
	else {y = Split(x->R,k-x->L->S-1);x->R = y.first;x->Update();y.first = x;}
	return y;
}
void Reverse(int l,int r){
	if (l==1 && r==n) {rt->Setrev();return;}
	if (l==1) {Droot x = Split(rt,r);x.first->Setrev();rt = Merge(x.first,x.second);return;}
	if (r==n) {Droot x = Split(rt,l-1);x.second->Setrev();rt = Merge(x.first,x.second);return;}
	Droot x = Split(rt,l-1);
	Droot y = Split(x.second,r-(l-1));
	y.first->Setrev();
	rt = Merge(Merge(x.first,y.first),y.second);
}
int main(){
	n = read();m = read();null = Nd;
	for (int i=0;i<=n;i++) Nd[i] = (node){null,null,1,rand(),0};
	null->S = 0;rt = Build();
	for (int i=1;i<=m;i++) {l = read();r = read();Reverse(l,r);}
	print(rt);
}

代码长度和Splay差不了多少，至于常数嘛。。这道题上好像也看不出来什么。差了200ms也算还能够接受。

有错误请指出$$\mathcal {FIN}$$

数论入门知识整理

2016-03-18T06:44:34.000Z

整理一下初等数论的基础知识。。

今天听狄拉克(贱贱)神犇给初三讲课。见证了我旁边的初三爷从茫然到一脸懵逼到崩溃的全过程，据他讲述，这是他至今为止唯一一次完全没有听懂的讲课。

好这些都不是重点
让我们来理一下重点是什么:

逆元
扩展欧几里得
欧拉筛法
中国剩余定理
组合数
Lucas定理

逆元

关于逆元是什么,讲课的时候我给刚才那位当时还是处在茫然状态的初三爷讲了一下,然后结果是他没有听懂.讲道理逆元有这么难吗!!
对于$a\cdot b\equiv1(mod\ P)$我们就称b为a在模P域下的逆元,记a的逆元为$a^{-1}$(逆元要在模域下才有意义!!)
逆元有什么用呢？对于在模域下的除法$\frac{a}{b}\equiv a\cdot b^{-1}(mod\ P)$
怎么求逆元？
首先对于在模P域下的a,存在逆元的条件是$gcd(a,P)=1$
当a存在逆元时根据欧拉定理可得$a^{-1}\equiv a^{\phi(P)-1}(mod\ P)$
然后使用快速幂就可以在log的时间内求出单个元素的逆元了
如何快速求1~n所有数的逆元(这里的条件是P为素数)?
设$P\div a=q…r$即$P=qx+r$
然后可以将其放到模域下
\begin{align}
P & = qx+r \\
0 & \equiv qx+r (mod\ P) \\
-r & \equiv qx(mod\ P) \\
-rq^{-1} & \equiv x(mod\ P) \\
x^{-1} & \equiv -qr^{-1}(mod\ P) \\
x^{-1} & \equiv -\lfloor\frac{P}{x}\rfloor\cdot (P\ mod\ x)^{-1}(mod\ P)
\end{align}
然后就可以O(n)递推了
Back to menu

扩展欧几里得

第一个问题。。欧几里得算法是什么..其实就是辗转相除求GCD。。
那么扩展欧几里得是什么呢？
扩展欧几里得用来解决一类$a\cdot x+b\cdot y=c$的问题，可以求x的最小正整数解。当这个方程有解的时候，我们可以得知$gcd(a,b)|a$,$gcd(a,b)|b$,所以$gcd(a,b)|a\cdot x,gcd(a,b)|b\cdot y$，所以$gcd(a,b)|c$.然后可以把原方程化为$a\cdot x+b\cdot y=gcd(a,b)$求出解以后再乘上一个$c/gcd(a,b)$就可以了
对于怎么求解这个方程呢？
设$A=b,B=a\%b$
将原方程化为$A\cdot x_0+B\cdot y_0=gcd(a,b)$,也就是$b\cdot x_0+(a\%b)\cdot y_0=gcd(a,b)$
假设我们已经求出了这个方程，那么我们怎么推得原来方程的解呢?
\begin{align}
b\cdot x_0+(a\%b)\cdot y_0 & = gcd(a,b) \\
b\cdot x_0+(a-\lfloor\frac{a}{b}\rfloor\cdot b)\cdot y_0 & = gcd(a,b) \\
b\cdot x_0+a\cdot y_0-b\cdot\lfloor\frac{a}{b}\rfloor\cdot y_0 & = gcd(a,b) \\
a\cdot y_0+b\cdot(x_0-\lfloor\frac{a}{b}\rfloor\cdot y_0) & = gcd(a,b)
\end{align}然后我们就可以知道$x=y_0,y = x_0-\lfloor\frac{a}{b}\rfloor\cdot y_0$。
然后我们只要对原方程每次这样递归下去，然后就可以求出原方程的解了。

代码也很简单

int Exgcd(int a,int b,int &x,int &y){
	if (b==0) {x = 1;y = 0;return;}
	Exgcd(b,a%b,x,y);
	int tmp = x;x = y;y = tmp-(a/b)*y;
}

Back to menu

欧拉筛法

对于筛法我最先知道的是NlogN的倍增筛质数，原来感觉这么一个东西应该就够了。有些题目只能放O(N)过，觉得这个东西越来越没用~~确实没用~~。
欧拉筛法是什么呢？
欧拉筛法可以用来O(n)的时间里筛大部分（还是全部？并不清楚）积性函数。
什么是积性函数？
积性函数：任取p，q且$gcd(p,q)=1$，若$f(xy)=f(x)f(y)$，则f是一个积性函数
完全积性函数：任取p,q，若$f(pq)=f(p)f(q)$，则f是一个完全积性函数
欧拉筛法怎么做呢？
从2~n枚举一个数i，然后枚举小于i的质数j。如果j不是i的因子，那么j就是i*j的最小质因子，然后可以计算出f(i*j)的值。当j|i时，j是i的最小质因子，对于之后的所有质数k，i*k的最小质因子都不是k，而是j，所以直接跳出循环。这样我们可以发现每一个数都只被它的最小质因子筛到一次，所以整个算法的复杂度是O(n)的。

欧拉筛素数代码

void Getprime(){
	for (int i=2;i<=n;i++){
		if (!vis[i]) prime[++sum] = i;
		for (int j=1;j<=sum && i*prime[j]<=n;j++){
			vis[i*prime[j]] = j;
			if (i%prime[j]==0) break;
		}
	}
}

Back to menu

中国剩余定理(CRT)

中国剩余定理，用来解决一类一元线性同余方程组
一元线性同余方程组问题最早可见于中国南北朝时期（公元5世纪）的数学著作《孙子算经》卷下第二十六题，叫做“物不知数”问题，原文如下：
有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二。问物几何？
即，一个整数除以三余二，除以五余三，除以七余二，求这个整数。《孙子算经》中首次提到了同余方程组问题，以及以上具体问题的解法，因此在中文数学文献中也会将中国剩余定理称为孙子定理。
宋朝数学家秦九韶于1247年《数书九章》卷一、二《大衍类》对“物不知数”问题做出了完整系统的解答。明朝数学家程大位将解法编成易于上口的《孙子歌诀》：三人同行七十希，五树梅花廿一支，七子团圆正半月，除百零五使得知这个歌诀给出了模数为3、5、7时候的同余方程的秦九韶解法。意思是：将除以3得到的余数乘以70，将除以5得到的余数乘以21，将除以7得到的余数乘以15，全部加起来后除以105，得到的余数就是答案。比如说在以上的物不知数问题里面，按歌诀求出的结果就是23.（以上摘自某谋财害命网站）
然后把上面乱七八糟的东西整理一下就是求满足
\begin{align}
x & \equiv a_1(mod\ b_1) \\
x & \equiv a_2(mod\ b_2) \\
& . \\
& . \\
x & \equiv a_n(mod\ b_n)
\end{align}的最小x的值
这个方程是一定存在解的吗？
如果$a_1\ mod\ gcd(b_1,b_2)\not=a_2\ mod \ gcd(b_1,b_2)$,那么原方程组没有解
对于有解的方程
我们设$$M=\prod_{i=1}^{n} b_i$$$$D_i=\frac{M}{b_i}$$对于每一个方程，求出$$D_ix\equiv 1 (mod\ b_i)$$我们用求逆元的方法解出x，并把$D_i\cdot x$记为$X_i$
那么$X_i\cdot a_i$对其他所有b模的结果都为0，且对于模$b_i$的结果为$a_i$
那么$(\Sigma_{i=1}^{n} X_i\cdot A_i)mod M$就是答案
Back to menu

组合数

一些比较常见的性质
$$A_{n}^{m}=C_{n}^{m}\cdot m!$$$$C_{n}^{m}=C_{n}^{n-m}$$$$C_{n}^{m}=C_{n-1}^{m}+C_{n-1}^{m-1}$$$$\sum_{i=0}^{n} C_{n}^{i}=2^n$$恩其他的应该没有什么好写的
Back to menu

Lucas定理，组合数取模

lucas定理用来计算$C_{n}^{m}\ mod \ P$的问题，其中P为质数，如果P不是质数就要用CRT进行合并。$$Lucas:C_{m}^{n} \equiv C_{m\ mod\ P}^{n\ mod\ P}\cdot C_{m/P}^{n/P}\ mod\ P$$

#include <cstring>
#include <cstdio>
using namespace std;
typedef long long LL;
LL n,m,p;
LL ksm(LL a,LL k){
    LL res = 1;
    for (;k;k>>=1,a=a*a%p) if (k&1) res = res*a%p;
    return res;
}
LL C(LL n,LL m){
    if(m>n)return 0;
    LL ans=1;
    for(int i=1;i<=m;i++){
        LL a=(n+i-m)%p;
        LL b=i%p;
        ans=ans*(a*ksm(b,p-2)%p)%p;
    }
    return ans;
}
LL Lucas(LL n,LL m){
    if(m==0)return 1;
    return C(n%p,m%p)*Lucas(n/p,m/p)%p;
}
int main(){
    scanf("%d",&T);
    scanf("%lld%lld%lld",&n,&m,&p);
    printf("%lld\n",Lucas(n,m));
}

Back to menu

有错误请指出$$\mathcal{FIN.}$$

用CDQ分治维护凸壳

2016-03-17T23:03:43.000Z

为什么会想到写这么一篇文章呢。。。
~~我怎么知道为什么!!~~

先从昨天模拟赛的题目开始吧
为什么现在的模拟赛里竟然会有ACM World Final的原题，这题以前在讲CDQ分治的时候在课件上看到过。。
然后我当时没有好好看。。(:з」∠)。。
导致我看到题面的时候的反应就是：
哇原题!
哇槽被我弃了的原题(:з」∠)

于是考场上的我只能自己YY了…

##Machine Works
你是任意性复杂机器公司(Arbitrarily Complex Machines, ACM)的经理,公司使用更加先进的机械设备生产先进的机器。原来的那一台生产机器已经坏了,所以你要去为公司买一台新的生产机器。你的任务是在转型期内尽可能得到更大的收益。在这段时间内,你要买卖机器,并且当机器被 ACM公司拥有的时候,操控这些机器以获取利润。因为空间的限制,ACM 公司在任何时候都只能最多拥有一台机器。在转型期内,有若干台可能卖出的机器。作为先进机器的专家,对于每台机器 M i ,你已经知道了其价格 P i 和可以买入的日期 D i 。注意,如果不在第 D i 天买入机器 M i ,那么别的人也会买走这一台机器,也就是说,以后你将没有机会购买这台机器了。如果 ACM 的钱低于一台机器的价格,那么你显然不可能买到这一台机器。如果你在第 D i 天买入了机器 M i ,那么 ACM 公司可以从第 D i + 1 天开始使用这一台机器。每使用这台机器一天,就可以为公司创造出 G i 美元的收益。你可以决定要在买入之后的某一天,以一定的折扣价卖出这一台机器。收购市场对于每一台机器,都有一个折扣价 R i。你不能在卖出的那一天使用机器,但是你可以在卖出的那一天再买入一台新的。在转型期结束后,ACM 公司会卖掉当前所拥有的机器。你的任务就是最大化转型期间ACM 公司可以得到的收入。
【输入格式】
输入包含若干组测试用例。每一组测试用例的第一行有 3 个正整数 N,C 和 D。N 是将会卖出的机器的台数(N ≤ 10 5 ),C 是在转型期开始时公司拥有的美元数量(C ≤ 10 9 ),D 是转型期持续的天数(D ≤ 10 9 )。之后的 N 行每一行描述了一台机器的情况。每一行有 4 个正整数 D i , P i , R i 和 G i ,分别表示这台机器卖出的时间,购买这台机器需要的美元数量,卖出这台机器的折扣价和使用这
台机器可以得到的利润。这些数字满足 1 ≤ D i ≤ D,1 ≤ R i < P i ≤ 10 9 且 1 ≤ G i ≤ 10 9 。最后一组测试用例后面的一行由 3 个 0 组成,表示输入数据结束。
【输出格式】
对于每一组测试用例,输出测试用例的编号,之后给出 ACM 公司在第 D + 1 天结束后可以得到的最大数量的美元。请依照下面给出的样例输出。

看到这道题目,很容易的想到了一个O(N^2)的DP,现将所有的机器按照买入时间排序,f[i]表示到第d[i]天时最大的收益,然后可以得到一个显然的方程$$f[i] = max (f[i-1],f[j]-p[j]+r[j]+(d[i]-d[j]-1)*g[j])(f[j]\geq p[j])$$看着这个东西好想可以斜率优化的样子..然后我就开始乱搞这个方程,对与从j和k两个位置的转移,j比k优的条件是$$f[j]-p[j]+r[j]+(d[i]-d[j]-1)*g[j]>=f[k]-p[k]+r[k]+(d[i]-d[k]-1)*g[k]$$这个式子太长了,我们发现其中的一部分只和jk自己有关,设$A[j] = f[j]-p[j]+r[j]-d[j]*g[j]-d[j]$,然后原式就可以化简为$$A[j]+d[i]*g[j]>=A[k]+d[i]*g[k]$$移项后得到$$d[i]<\frac{A[j]-A[k]}{g[j]-g[k]}$$推出来以后感觉很高兴啊,好像直接按照d排序以后斜率优化就好了..
然后开始码,码完以后一测样例过了好开心..
然后和暴力开始拍…几乎就是秒出错..(:з」∠)
调了一下数据以后发现…我忽略了g是不单调的..所以除过去以后符号可能会变..然后整个人就哔了狗了…

然后开始想怎么把这个正确性搞对呢…
突然发现!!!
这不就是用CDQ吗..
将原序列按时间分成两半,然后考虑前半段对后半段的影响的时候,可以把前半段按照g单调排序,然后就按照斜率优化的方法O(N)扫一遍,总的复杂度是O(NlogN)的..

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#define ll long long
const ll N = 100100;
using namespace std;
ll read(){
	ll x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
struct data{ll d,p,r,g;} a[N];
struct node{ll g,A;} q[N],x[N];
ll n,c,d,f[N],sum,t,h,Cas,m;
bool cmp(const data &a,const data &b){return a.d<b.d;}
bool cmp1(const node &a,const node &b){if (a.g==b.g) return a.A<b.A;return a.g<b.g;}
double Slp(node j,node k) {return (double)(j.A-k.A)/(k.g-j.g);}
node operator - (const node &a,const node &b) { return (node){a.g-b.g,a.A-b.A};}
double Cross(const node &a,const node &b) { return 1.0*a.g*b.A-1.0*a.A*b.g;}
ll work(int i ,node p) {return p.A+p.g*a[i].d;}
void solve(ll l ,ll r){
	if(l==r){f[l] = max(f[l-1] , f[l]);return ;}
	int mid = (l+r)/2;
	solve(l, mid);
	sum = t = 0;h = 1;
	for(int i=l;i<=mid;i++) if(f[i]>=a[i].p) q[++sum] = (node){a[i].g,f[i]-a[i].p+a[i].r-(a[i].d+1)*a[i].g};
	sort(q+1,q+1+sum,cmp1);
	for(int i=1;i<=sum;i++){
		while(t>1 && Cross(x[t]-x[t-1],q[i]-x[t])>=0) t--;
		x[++t] = q[i];
	}
	for(int i=mid+1;i<=r;i++){
		while(h<t && work(i,x[h+1])>=work(i,x[h])) h++;
		if (h<=t) f[i] = max(f[i],work(i,x[h]));
	}
	solve(mid+1,r);
}
int main() {
	freopen("works.in","r",stdin);
	freopen("works.out","w",stdout);
	while (~scanf("%d%d%d",&n,&c,&d)) {
		if (n+c+d==0) return 0;Cas++;
		for (int i=1;i<=n;i++) a[i].d = read(),a[i].p = read(),a[i].r = read(),a[i].g = read();
		for (int i=1;i<=n+1;i++) f[i] = 0;
		f[0] = c;a[++n].d = d+1;
		sort(a+1,a+1+n,cmp);
		solve(1,n);
		printf("Case %d: %lld\n",Cas,f[n]);
	}
}

打完以后就开始了漫长的调试之路…
让我来想一下当时发生了什么:

sort的时候莫名其妙的RE了..后来发现是一个计算函数的锅…只要这个函数被调用..然后下一次排序就会RE..然而这是什么鬼一样的姿势啊..(:з」∠)..,到现在还是不知道到底为什么..
在更新后一半答案的时候非常霸气地把mid+1打成了1…(:з」∠)..哇槽什么鬼
中间TM还炸了longlong..(:з」∠)…

感觉很高兴啊,然后发现…华丽丽地卡了常数..(:з」∠)..(不过BZOJ上是很很轻松就过了的)
想想拿几分也就够了…然后没有去管他…
然而…最后FST了…被系统杀了…自信用%d读longlong..(:з」∠)…我是不是第一个用Ubuntu然后被Ubuntu系统杀的..(:з」∠)

直到讲课前我还一直以为CDQ是标算..毕竟如果直接用平衡树动态维护凸壳的常数和CDQ也差不了多少…

然后讲课的时候说,直接斜率优化然后在栈里面二分就好了…
诶什么情况..为什么可以斜率优化…

然后我又想了一下题面…发现最优策略里面g一定是递增的…(:з」∠)
哇槽这么显然的性质我竟然现在才发现.(:з」∠)..
然后根据这个性质可以直接按照g排序..然后维护一个斜率的单调栈,每次在栈里面二分,然后..这样也是log的..但是这个常数..(:з」∠)不说了..(:з」∠)
果真智商被虐的好惨

#include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long
const ll N = 100010;
using namespace std;
struct data{ll d,p,r,g;} a[N];
ll split[N],n,c,d,f[N],ans,top,Cas;
pair <ll,ll> stk[N];
ll read(){
	ll x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
ll get(ll x) {
	if (!top) return -1ll<<60;
	ll l = 1,r = top-1,res = 0;
	if (x<=split[l]) return stk[l].first*x+stk[l].second;
	if (x>=split[r]) return stk[r+1].first*x+stk[r+1].second;
	while (l+1<r){
		ll mid = (l+r)>>1;
		if (split[mid]<x) l = mid;
		else r = mid;
	}
	return stk[r].first*x+stk[r].second;
}
bool cmp(data a,data b){return a.g<b.g;}
double Cross(double k1,double b1,double k2,double b2) {return (b2-b1)/(k1-k2);}
void Add(ll k,ll b){
	if (top && k==stk[top].first) {
		if (b<=stk[top].second) return;
		top--;
	}
	while (top>1 && Cross(stk[top-1].first,stk[top-1].second,k,b)<split[top-1]) top--;
	if (top) split[top] = Cross(stk[top].first,stk[top].second,k,b);
	stk[++top] = make_pair(k,b);
}
int main(){
	freopen("works.in","r",stdin);
	freopen("works.out","w",stdout);
	for (;;) {
		n = read();c = read();d = read();
		if (n+c+d==0) return 0;
		for (ll i=1;i<=n;i++) a[i].d = read(),a[i].p = read(),a[i].r = read(),a[i].g = read();
		ll ans = c;
		sort(a+1,a+1+n,cmp);top = 0;
		for (ll i=1;i<=n;i++) {
			f[i] = max(get(a[i].d),c)-a[i].p;
			if (f[i]>=0) {
				Add(a[i].g,f[i]+a[i].r-(a[i].d+1)*a[i].g);
				ans = max(ans,f[i]+(d-a[i].d)*a[i].g+a[i].r);
			}
		}
		printf("Case %lld: %lld\n",++Cas,ans);
	}
}

下午的时候去做了一下货币交换..感觉差不多的题目就写在一起了..

1492: [NOI2007]货币兑换Cash

点击这里去虐题

这道题是和上面一题一起出现在课件里的…
我们先考虑N^2的DP..讲道理这个dp好想并不是很好想….
显然的我们可以得到一个性质,每一次兑换货币的时候一定是全部兑换的,不会出现题面中的一部分的情况,所以我们只要知道了其中一种金券的数量就可以计算出另一种金券的数量.设f[i]表示第i天可以获得的最大价值,然后可以得到一个DP方程$$f[i] = max(f[i-1],\frac {f[j]*rate[j]*a[i]+f[j]*b[i]}{rate[j]*a[j]+b[j]})$$,其中$\frac{f[j]*rate[j]}{rate[j]*a[j]+b[j]}$表示第j天最多可以有多少A金券,我们设他为X[j],同样的$Y[j]=\frac{f[j]*rate[j]}{rate[j]*a[j]+b[j]}$,然后我们对上面的方程进行化简.对于两种转移j比k优的条件是$$f[j]*rate[j]*a[i]+f[j]*b[i]>f[k]*rate[k]*a[i]+f[k]*b[i]$$移项后得到$$\frac{f[j]-f[k]}{rate[j]*f[j]-rate[k]*f[k]}>-\frac{a[i]}{b[i]}$$然后就和上一题类似,按照$-\frac{a[i]}{b[i]}$排序,然后用CDQ分治维护凸壳..
不过这道题和上一道题有一点区别是,因为是根据$-\frac{a[i]}{b[i]}$排序的所以时间关系是乱的,分治的时候还是要按照时间分治,然后分别保证两端里要单调

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#define N 120000
#define eps 1e-9
#define inf 1e9
using namespace std;
struct query{double q,a,b,rate,k;int pos;}q[N],nq[N];
double fabs(double x){return (x>0)?x:-x;}
struct point{
	double x,y;
	friend bool operator <(const point &a,const point &b) {	
		return (a.x<b.x+eps)||(fabs(a.x-b.x)<=eps&&a.y<b.y+eps);
	}
}p[N],np[N];
int st[N]; double f[N]; int n,m;
double getk(int i,int j){
	if (i==0) return -inf;
	if (j==0) return inf;
	if (fabs(p[i].x-p[j].x)<=eps) return -inf;
	return (p[i].y-p[j].y)/(p[i].x-p[j].x);
}
void solve(int l,int r){
	if (l==r){
		f[l]=max(f[l-1],f[l]);
		p[l].y=f[l]/(q[l].a*q[l].rate+q[l].b);
		p[l].x=p[l].y*q[l].rate;
		return ;
	}
	int mid=(l+r)>>1,l1=l,l2=mid+1;
	for (int i=l;i<=r;i++)
		if (q[i].pos<=mid) nq[l1++]=q[i];
		else nq[l2++]=q[i];
	for (int i=l;i<=r;i++) q[i]=nq[i];
	solve(l,mid);
	int top=0,j = 1;
	for (int i=l;i<=mid;i++){
		while (top>=2&&getk(i,st[top])+eps>getk(st[top],st[top-1])) top--;
		st[++top]=i;
	}
	for (int i=r;i>=mid+1;i--){
		while (j<top&&q[i].k<getk(st[j],st[j+1])+eps) j++;
		f[q[i].pos]=max(f[q[i].pos],p[st[j]].x*q[i].a+p[st[j]].y*q[i].b);
	}
	solve(mid+1,r);
	l1=l,l2=mid+1;
	for (int i=l;i<=r;i++)
		if ((p[l1]<p[l2]||l2>r)&&l1<=mid) np[i]=p[l1++];
		else np[i]=p[l2++];
	for (int i=l;i<=r;i++) p[i]=np[i];
}
bool cmp(query a,query b){return a.k<b.k;}
int main(){
	scanf("%d%lf",&n,&f[0]);
	for (int i=1;i<=n;i++) {
		scanf("%lf%lf%lf",&q[i].a,&q[i].b,&q[i].rate);
		q[i].k=-q[i].a/q[i].b;
		q[i].pos=i;
	}
	sort(q+1,q+n+1,cmp);
	solve(1,n);
	printf("%.3lf\n",f[n]);
}

有错误请指出$$\mathcal {FIN}$$

From 温暖的二月 to 寒冷的三月

2016-03-14T23:40:34.000Z

其实这个标题和内容并没有任何关系，我只是不知到应该取一个什么样子的题目而已。

然而今年的天气我真的忍不住要吐槽一下，尼玛这是一个星期体验四季啊，上上星期一的时候风和日丽，气温一度飙升到30来度，让人感觉夏天都要到了。然后第二天气温瞬间下降，三天后回到零度。
~~这感觉就是刚准备好过暑假然后寒假到了。。~~

好像有点偏题了，诶我这篇博文主题是什么来着(:з」∠)

好吧既然是$From$二月，那先回忆一下我二月底到三月初都干了些什么逗比的事情。。。

在笔记本上装了Ubuntu，然后就入坑了，开始乱搞我的系统，感觉我已经深深爱上了Ubuntu，要不是这里装不上hexo我才不回windows呢。。
学习了一下gdb调试，感觉用gdb调代码还是比较舒服的，至少不!会!!崩!!!
看了一下vim编辑器，这个好像是装逼专用的 ~~好吧都是装逼用的~~
最近入坑用github提供的支持搭了一个静态博客,不要问我为什么不是动态博客，我太傻了，并不能搞懂数据库什么高端的东西。。
为了搭博客看了看html语言和js什么的。。
学了用来写文章的MarkDown,感觉MarkDown真的好厉害，语法简单还支持一堆奇怪的东西
刷水题刷水题刷水题
好像别的奇怪的事情就没了吧

感觉我好像干了好多无聊的事情。。(:з」∠)
一直从二月浪到现在也是爽爽哒。。然而再这么下去人生就没有希望了吧。。(:з」∠)马上也要回去文化课的深渊了

简单整理一下吧，在今年省选二试结束前要学完的东西

字符串相关的东西（后缀自动机。。反正还有一堆东西）
一堆和数学有关的东西
- FFT
- 高斯消元，拉格朗日插值
- 数论函数，生成函数（原来的皮毛也应该忘的差不多了吧）
- 线性代数
- 单纯形
- 微积分。。。感觉是学不会的
数据结构一块
- KD$-$tree
- 主席树好像忘得差不多了吧
- 替罪羊树和SBT有时间去学一下
置换群
然后再去看看一些国家队论文，补一下冬令营的课件什么的

还有好多东西不会啊，不能再颓下去了呀

三月已经过半了，停课的时间也越来越少了
文化课的寒风和$OI$的暴雪夹杂在一起会发生什么呢
不要让自己失望啊

有你们的陪伴和$Aimer$的歌声我不会输

教练，我要刷水题

2016-03-14T23:10:40.000Z

听说HAOI有洪水，像我这种蒟蒻最喜欢了，于是最近就开始刷HAOI了。。。

BZOJ1044 木棍分割

点这里去虐题

妈的用MarkDown贴题面真TM蛋碎
据说支持内嵌html然后我把html贴上去之前的内容就华丽丽地消失了(:з」∠)
或者说是我这个编辑器的锅吗，我还是选择稳妥的不贴题面了
好,停止吐槽

说起来这道题原来是我给初三讲课里面的题目
原来一直懒得去做，现在趁着刷水一起做了

对于第一问，感觉应该可以算是很经典的问题了，二分长度，然后贪心验证就好了
然后对于第二问，我们可以很容易地想到一个O(NM)复杂的Dp，用f[i][j]表示前j个木棍分成i段的方案数，然后就可以得到 $$f[i][j]=\sum^{k<j}_{k=0} f[i-1][k] (sum[j]-sum[k]<=len)$$ 我们可以显然的发现，这个是会华丽丽地T掉的。但是我们可以发现对与递增的j，k的位置也是递增的，所以我们可以使用队列优化DP。
然后因为空间问题，还要对第一维滚存
不过具体的复杂度我并不会证，可能还是不对的。但是至少还是过去了。。(:з」∠)
~~今天晚上听见初三爷在纠结滚存怎么滚，感觉我的作业是不是太凶残了~~

#include <cstdio>
#include <cstring>
#include <algorithm>
const int mod = 10007;
const int N = 500010;
using namespace std;
int a[N],f[2][N],sum[N],q[N],tot,n,ans2,m;
int read(){
	int x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
int Judge(int x){
	int res = 0,s = 0;
	for (int i=1;i<=n;i++) {s+=a[i];if (s>x) {res++;s = a[i];}if (res>m) return 0;if (a[i]>x) return 0;}
	return 1;
}
int main(){
	n = read();m = read();
	for (int i=1;i<=n;i++) {a[i] = read();sum[i] = sum[i-1]+a[i];}
	int l = 0,r = sum[n],Ans = 0;
	while (l<=r) {
		int mid = (l+r)>>1;
		if (Judge(mid)) {Ans = mid;r = mid-1;}
		else l = mid+1;
	}
	printf("%d ",Ans);
	f[0][0] = 1;
	for (int i=1;i<=m;i++) {
		int pre = i&1,cur = pre^1;
		int l = 1,r = 1;q[1] = 0;tot = f[cur][0];
		for (int j=1;j<=n;j++) {
			while (l<=r && sum[j]-sum[q[l]]>Ans) tot = (tot-f[cur][q[l++]]+mod)%mod;
			f[pre][j] = tot;q[++r] = j;
			tot = (tot+f[cur][j])%mod;
		}
		for (int j=n-1;j;j--) {
			if (sum[n]-sum[j]>Ans) break;
			ans2 = (ans2+f[pre][j])%mod;
		}
		memset(f[cur],0,sizeof(f[cur]));
	}
	printf("%d\n",ans2);
}

BZOJ1043 下落的圆盘

点击这里去虐题

一道计算几何的题目
上次做计算几何是什么时候来着(:з」∠)应该已经是好几个月以前的事情了吧。。
我们观察数据范围可以知道

这是一个很裸很裸的暴力

因为n只有1000所以直接$N^2$，对每一个圆盘暴力枚举每一个在它上方的圆盘，然后求出被遮盖的弧长

对于两个相交的圆，我们可以知道他们的半径和圆心之间的距离。然后就可以很轻易的使用反三角函数求出图中的$\angle EAC$。然后再求出直线$AC$的极角，就可以表示出被遮盖的位置。因为这样求出来的弧度可能是负数，所以需要把它转换到$[0,2\pi]$的范围内。然后就简单地统计一下就好了。
复杂度: $O(N^2)$

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 1010;
using namespace std;
double r[N],x[N],y[N],ans,pi;
int n,top;
struct Line {double l,r;} q[N];
bool cmp(Line a,Line b){return a.l<b.l;}
double dis(int a,int b){return sqrt((x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]));}
int Cover(int a,int b) {if (r[a]>=r[b]+dis(a,b)) return 1;return 0;}
void Work(int a,int b){
	double d = dis(a,b);
	double t = (r[a]*r[a]-r[b]*r[b]+d*d)/(2*d);
	double st = atan2((x[a]-x[b]),(y[a]-y[b]));
	double l = acos(t/r[a]);
	q[++top] = (Line){st-l,st+l};
}
double calc(int x){
	for (int i=x+1;i<=n;i++) if (Cover(i,x)) return 0;
	top = 0;double tmp = 0,now = 0;
	for (int i=x+1;i<=n;i++)
		if (!Cover(x,i) && r[i]+r[x]>dis(i,x)) Work(x,i);
	for (int i=1;i<=top;i++) {
		if (q[i].l<0) q[i].l+=2*pi;
		if (q[i].r<0) q[i].r+=2*pi;
		if (q[i].l>q[i].r) {q[++top] = (Line){0,q[i].r};q[i].r = 2*pi;}
	}
	sort(q+1,q+1+top,cmp);
	for (int i=1;i<=top;i++) 
		if (q[i].l>now) {
			tmp+=q[i].l-now;
			now = q[i].r;
		}
		else now = max(now,q[i].r);
	tmp+=2*pi-now;
	return r[x]*tmp;
}
int main(){
	scanf("%d",&n);pi = acos(-1);
	for (int i=1;i<=n;i++) scanf("%lf%lf%lf",&r[i],&x[i],&y[i]);
	for (int i=1;i<=n;i++) ans+=calc(i);
	printf("%.3lf\n",ans);
}

BZOJ1049 数字序列

点击这里去虐题

感觉有点厉害的一道题，诶其实只是我弱(:з」∠)
对于第一问，要求最小化改变的数量，可以转化成最大化不变的数量。然后我们考虑对与这个进行DP，设f[i]表示i位置不变的最大不变数量，然后可以得到一个的DP方程$$f[i] = Max f[j]+1 (a[i]-a[j]>=i-j)$$后面的限制条件是因为要满足递增。
然后我们将a[i]-a[j]>=i-j移项得到a[i]-i>=a[j]-j可以发现原问题就转化为了对a[i]-i数组求最长不下降子序列。直接写一个$O(N\log_2N)$的模板上去就好了

然后对与第二问。。
在满足第一问的前提下的最小改变量，考虑那一些位置可以转移到i，然后就会得到一个DP方程$$g[i] = Min g[j]+w[i][j] (f[j]+1=f[i]) $$其中w[i][j]表示把i到j这一段改成符合条件的最小代价。
然后对此有一个性质，w[i][j]的方案一定会以某一个k分界，使得[j,k]之间的均为b[j],[k+1,i]之间的均为b[i]，证明嘛。。。

我不会！别问我！！

还是直接贴神犇的证明吧

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 40000;
using namespace std;
long long g[N],s1[N],s2[N];
int f[N],Min[N],head[N],a[N],n,cnt,L;
int read(){
	int x = 0,f = 1,c = getchar();
	while (c<'0' || c>'9') {if (c=='-') f = -1;c = getchar();}
	while (c>='0' && c<='9') x = x*10+c-'0',c = getchar();
	return x*f;
}
struct data{int x,y,next;} e[N];
void Insert(int x,int y){
	e[++cnt].x = x;e[cnt].y = y;
	e[cnt].next = head[x];head[x] = cnt;
}
int find(int x){
	int l = 1,r = L,res = 0;
	while (l<=r) {
		int mid = (l+r)>>1;
		if (Min[mid]<=x) {res = mid;l = mid+1;}
		else r = mid-1;
	}
	return res;
}
void solve1(){
	memset(Min,127,sizeof(Min)); Min[0] = -1<<30;
	for (int i=1;i<=n;i++) {
		int t = find(a[i]);
		f[i] = t+1; L = max(t+1,L);
		Min[t+1] = min(Min[t+1],a[i]);
	}
}
void solve2() {
	for (int i=n;i>=0;i--) {Insert(f[i],i);g[i] = 1ll<<60;}
	g[0] = 0;a[0] = -1<<30;
	for (int x=1;x<=n;x++)
		for (int i=head[f[x]-1];i;i=e[i].next){
			int p = e[i].y;
			if (p>x) break;
			if (a[p]>a[x]) continue;
			for (int j=p;j<=x;j++) s1[j] = abs(a[p]-a[j]),s2[j] = abs(a[j]-a[x]);
			for (int j=p+1;j<=x;j++) s1[j]+=s1[j-1],s2[j]+=s2[j-1];
			for (int j=p;j<x;j++) g[x] = min(g[x],g[p]+s1[j]+s2[x]-s2[j]-s1[p]);
		}
}
int main(){
	n = read();
	for (int i=1;i<=n;i++) a[i] = read()-i;
	a[++n] = 1<<30;
	solve1();
	solve2();
	printf("%d\n%lld\n",n-f[n],g[n]);
}

有错误请指出$$\mathcal {FIN}$$

Hello World

2016-03-14T14:43:50.295Z

额，第一篇博文写一些什么东西好呢。。。。

好像并不知道。。(:з」∠)
但是既然都自动生成了Hello World了就要写一点的吧。

#include <cstdio>
using namespace std;

int main(){
    printf("Hello World\n");
}

好就这样吧。
感觉有点草率。。~~不过我就是懒癌你管我~~
原来blog上的文章也不想转过来了
点这里回原站

Wyxoi's Blog

数论函数一丢题解

BZOJ 2301: [HAOI2011]Problem b

BZOJ 2005: [Noi2010]能量采集

BZOJ 2820: YY的GCD

BZOJ 3309: DZY Loves Math

BZOJ 2154: Crash的数字表格

BZOJ 2693: jzptab

BZOJ 3560: DZY Loves Math V

BZOJ 3561: DZY Loves Math VI

BZOJ 3739: DZY loves math VIII

三月走了啊

主席树预习与整理

一道题目引发的惨案

用主席树求区间颜色种类的在线带修改算法。（怎么这么绕呢）

序幕：离线求不带修改区间颜色种类

发展：在线求不带修改区间颜色种类

高潮：在线求带修改区间颜色种数

尾声：回到3236.

我强力推荐莫队套分块！！

莫队暴力出奇迹

后记：通过了这一系列题目的研究我们知道了口胡的危害

省选与之前数论函数讲课的搬运和整合

Menu:

积性函数

$Dirichlet$卷积

莫比乌斯反演

一类积性函数求前缀和问题

又到一年省选季

Day -1

Day 0

Day 1

Day 2

Day 3

闲来无事学数据结构——非旋转Treap

具体操作的分析

Build

Split

Merge

数论入门知识整理

逆元

扩展欧几里得

欧拉筛法

中国剩余定理(CRT)

组合数

Lucas定理，组合数取模

用CDQ分治维护凸壳

1492: [NOI2007]货币兑换Cash

From 温暖的二月 to 寒冷的三月

有你们的陪伴和$Aimer$的歌声我不会输

教练，我要刷水题

BZOJ1044 木棍分割

BZOJ1043 下落的圆盘

这是一个很裸很裸的暴力

BZOJ1049 数字序列

我不会！别问我！！

Hello World