Codeforces Round 942 Div.1

Sun, 05 May 2024 00:00:00 +0000

闲来无事，整了一场virtual codeforces来看看手有没有变生。感觉基本的手感还是有一些的？

A. Permutation Counting

题目大意

给定 $a_1$ 个 1, $a_2$ 个 2, $\ldots$ $a_n$ 个 $n$，同时还能补至多$k$个任意数，然后把这些数排成一个数列，问这个数列最多可以有多少个子串是${1, 2, \ldots, n}$的排列。

思路

题目的样例给了很强的提示。显然，假设1到$n$的数量是递增的，那么我们可以排这么一个数列出来：

$n-2,n-1,n,1,2,3,\ldots,n,1,2,3,\ldots,n,\ldots,1,2,3,\ldots,n$

答案就是$n(t-1) + 1 + p$，其中$t$为出现最少的数出现的次数，$p$为出现多于$t$此的数的数量。

二分$t$，计算$p$即可。

B1. Reverse Card (Easy Version)

题目大意

计算

\[\sum_{1\le a\le n, 1\le b \le m} [(a + b) | b \cdot \mathrm{gcd}(a, b)]\]

思路

显然，若$\mathrm{gcd}(a, b) = 1$且$b \neq 1$, 则$a + b \nmid b\cdot\mathrm{gcd}(a, b) $.

若$b = 1$, 则有$a + b | 1$恒成立。

考虑$b > 1, \mathrm{gcd}(a, b) > 1$, $a + b | b \cdot \mathrm{gcd}(a, b) \Rightarrow a + b | b \Rightarrow a | b \Rightarrow \mathrm{gcd}(a, b) = b$

原题变成

\[\sum_{1\le a\le n, 1\le b \le m} [(a + b) | b^2]\]

令$a = b(kb - 1)$，原题变成：

\[\sum_{1\le k\le \left\lfloor \frac{(n+b)}{b^2} \right\rfloor, 1\le b \le m} 1 = \sum_{1\le b \le m} \left\lfloor \frac{(n+b)}{b^2} \right\rfloor - 1\]

B2. Reverse Card (Hard Version)

\[\sum_{1\le a\le n, 1\le b \le m} [b \cdot \mathrm{gcd}(a, b) | (a + b)]\]

思路

令$g = \mathrm{gcd}(a, b), a = kg, b = lg, \mathrm{gcd}(k, l) = 1$

题目变为

\[\sum_g \sum_{1\le k\le \left\lfloor \frac{n}{g} \right\rfloor, 1\le l \le \left\lfloor \frac{m}{g} \right\rfloor} [kg^2 \| g(k + l)][\mathrm{gcd}(k,l) = 1]\] \[= \sum_g \sum_{1\le k\le \left\lfloor \frac{n}{g} \right\rfloor, 1\le l \le \left\lfloor \frac{m}{g} \right\rfloor} [kg \| (k + l)][\mathrm{gcd}(k,l) = 1]\] \[= \sum_g \sum_{1\le k\le \left\lfloor \frac{n}{g} \right\rfloor, 1\le l \le \left\lfloor \frac{m}{g} \right\rfloor} [g \| (k + l)][\mathrm{gcd}(k,l) = 1]\]

考虑$g$的因数$h$，注意到，如果$\mathrm{gcd}(k,l) = h$，那么有$g | (\frac{k}{h} + \frac{l}{h})$，记$k’ = \frac{k}{h}, l’ = \frac{l}{h}$，那么原式可以变为：

\[\sum_{1 < g < \min(n, m)} \sum_h \left( [g\|h] \sum_{1\le k'\le \left\lfloor \frac{n}{g} \right\rfloor} \left[\mathrm{gcd}(k',h - k') = 1\right]\cdot\left[1 \le h - k' \le \frac{m}{g}\right]\right)\]

如果依此式计算,令$\min(n, m) = N$，得到复杂度为：

\[\sum_{1 < g < N} \sum_{h \le \sqrt{g}}\sum_{1\le k'\le \left\lfloor \frac{n}{g} \right\rfloor} O(\mathrm{gcd}) = O(N \sqrt{N} (\log N)^2)\]

在$N \sim 2\times 10^6$时，复杂度不可接受。

如果令$g = g’h$, 则原式化为

\[\sum_h \sum_{1 < g' < \left\lfloor\frac{\min(n, m)}{h}\right\rfloor} \sum_{1\le k'\le \left\lfloor \frac{n}{g} \right\rfloor} \left[\mathrm{gcd}(k',h - k') = 1\right]\cdot\left[1 \le h - k' \le \frac{m}{g}\right]\]

注意到，若令$\min(n, m) = N$

\[\sum_h \sum_{1 < g' < \left\lfloor\frac{\min(n, m)}{h}\right\rfloor} \sum_{1\le k'\le \left\lfloor \frac{n}{hg'} \right\rfloor} O(\mathrm{gcd}) = O(N(\log N)^3)\]

因此此时复杂度是可以接受的，依上式暴力计算即可。

花絮

第一次做的时候没想到最后一步，一直TLE，上perf看热点发现对于样例，有

long long sol() {
 long long n, m, ans = 0;
 cin >> n >> m;
     |
 long long mimn = min(m, n);
     |
00M|  for (long long g = 2; g <= mimn; g++) {
 999k|    long long mxk = n / g;
 999k|    long long mxl = m / g;
     |
 999k|    if (mxk >= g && mxl >= g) {
     ans += g - 1;
     continue;
   }
     |
 667M|    for (long long rg = 1; rg * rg <= g; rg++) {
 666M|      if (g % rg != 0) {
 659M|        continue;
 659M|      }
98M|      long long gg = g / rg;
98M|      long long tans = gg;
86M|      for (long long k = max(gg - mxl, 1ll); k <= mxk && k < gg; k++) {
88M|        long long l = gg - k;
88M|        if (l <= mxl && gcd(k, l) == 1) {
76M|          long long a = k * g;
76M|          long long b = l * g;
76M|          ans++;
76M|        }
88M|      }
98M|      if (gg != rg) {
1M|        for (long long k = max(rg - mxl, 1ll); k <= mxk && k < rg; k++) {
21M|          long long l = rg - k;
21M|          if (l <= mxl && gcd(k, l) == 1) {
67M|            long long a = k * g;
67M|            long long b = l * g;
67M|            ans++;
67M|          }
21M|        }
98M|      }
98M|    }
 999k|  }
     |
 return ans;
}

看到

 667M|    for (long long rg = 1; rg * rg <= g; rg++) {
 666M|      if (g % rg != 0) {
 659M|        continue;
 659M|      }

恍然大悟。

还是因为手生了。

某氢酱的年终总结 feat.2019

Tue, 31 Dec 2019 00:00:00 +0000

2014年12月31日，我在上海交大的礼堂里，期待着从两天的活动中获得点什么，然而，等到的，却是在QQ群里流传着的教育部的文件。不知道为什么，我虽然嘴里说着想去清华，但不知为何内心当中更想去的，却一直是上交。虽然总有人告诉我他对我想去上交的原因的猜测，然而事实是，我想去上交却远早于我进入高中。那一天之后，我总认为对于进入上交而言还有那么一丝机会，然而，事实却告诉我，没有，翌年三月份的一通电话似乎燃起了我的信心，然而接下来五月份的一通无人接听的电话却让我的情绪跌至谷底。接下来的故事，众人皆知，也没有重复去讲的必要。

2014年人工智能概念刚刚兴起，而一众公司融资正酣，那年夏天，在NOI上，旷视科技的几个人坐在深圳一所学校的礼堂内讲着渲染十万根毛的故事，而后在团体对抗赛上，湖北队的麻将AI则开局不利，虽然后来尚可，但仍无力回天。那是NOI的最后一次团体对抗赛。

再往前的7月，在湖南的省队集训里，一如既往的被虐，在NOI前的最后一次Codeforces当中，我掉回Div2；

4月，省选进入A类选手。但APIO却崩盘；

3月，湖南集训；

2月，冬令营；

五年之后的今天，我坐在上海的一间老破小里敲打着键盘，写下这篇总结的标题，然而心里想着的，却是2014年的总总。原因之一是在五年之后，再一次在上海迎接元旦，然而另一个原因……

自高中毕业以来，我再没有见过任何一位高中同学，内心里的自卑使我不敢再去面对那些老师，与那些高不可攀的同学。纵使现在在众人羡慕的公司工作，我也未敢再回高中看哪怕一眼。然而，在我更换了电脑，更换了帐号，在全新的环境下，打开地图，默认定位的蓝点，却不知为何永远打在华师一，打在三号教学楼，打在三号教学楼的最西侧。

不得不说，上海是一座有魔力的城市。

2019年，是平淡得不能更平淡的一年，去年立下的Flag似乎一一兑现，却又似乎差了点什么。成功进入Google工作，却愈发迷茫，甚至说不清自己未来的位置。从竞赛退役，却总是参和这样那样的竞赛，电台倒是通了不少，然而在传播低谷的天空下沉迷老头乐，而O(1/n)这个分组……似乎做了点什么，又似乎没有做什么。

那么2020年呢？工作？竞赛？无线电？以及……女朋友？我似乎没有什么办法能做出什么计划，但又显然对现在的林林总总不那么满意。

在Byvoid的博客当中，我看到一句话，他说他会用类似于模拟退火的方式，尝试跳出现有的状况，以此期望寻求对于自己的全局最优解，或许我也应当在自己没法判断何者更优的时候，去询问自己的老朋友——random.org。但又会想到，随机某种意义上难道不是一种对当下选择的逃避？显然，对于“晚上吃什么”这种问题，随机显然无妨，然而对于某些别的选择，随机恐怕不见得是一件好事。

在这个时候，我必须承认，自己十数年来，一直不会寻求他人的帮助，虽谈不上羞于求助，但也是极低优先级的存在。我几乎把搜索引擎当作我唯一的资料来源，并耗费了大量的时间去寻求询问他人立马可以获得的回答。或许我必须对此做出些许变化。姑且就把这定作我2020年唯一的目标。

氢酱算法周记 000 - Codeforces 1204E

Sun, 01 Sep 2019 00:00:00 +0000

Natasha, Sasha and the Prefix Sums

链接

视频

YouTube / Bilibili

试题

Codeforces 1204E

试题大意

定义一个数列 $a$ 的最大前缀和为 $f(a)=\max(0,\max\limits_{1\le i\le |a|} \sum\limits_{1\le j\le i} a_j )$, 对于包含 $n$ 个+1与 $m$ 个 −1 的所有 $a$ ，求对应的 $f(a)$ 的和, 答案对998244853取模, $0\le n, m\le 2000$，时间限制2秒

一种思路

试题的作者使用了动态规划的做法来解决此题，但使用纯组合数学方法亦可解决此题.

考虑一个退化版问题，即对于包含 $n$ 个1与 $m$ 个−1的所有子串，前缀和最大值恰为 $x$ 的序列种数

对于这个问题，我们不妨继续简化情况，询问有 $n$ 个1与 $m$ 个-1的所有序列中,最大前缀和恰为 n-m 的情况种数

可以证明简化后问题的答案为 $C^{n+m}_m−C^{n+m}_{m−1}$ 即，序列的任意后缀中，1的个数不少于-1的个数，这个答案的证明可以参考卡塔兰数的证明方法。

那么，对于包含 $n$ 个1与 $m$ 个-1的所有子串，前缀和最大值恰为 $x$ 的序列种数,可以通过枚举最大值 $x$ 第一次出现的位置得到，如果假设位置是 $y$ 的话

可以知道这个前缀包含 $(x+y)/2$ 个+1与 $(y-x)/2$ 个-1 那么这个前缀的种数即使之前简化问题的解 $C^{y-1}_{(y-x)/2} - C^{y-1}_{(y-x)/2-1}$

而对于答案的后半部分，就是从这个位置开始数，遇到的-1个数不会少于遇到的1的个数，如果后半部分有 $p=n−(x+y)/2$ 个+1与 $q=m−(y−x)/2$ 个-1，答案就是 $C^{p+q}_{p} - C^{p+q}_{p-1}$

至此，可以得知，前缀和最大值为 $x$ 的序列方案数为

\[\sum_{1\le y\le n+m} \left(C^{y-1}_{(y-x)/2} - C^{y-1}_{(y-x)/2 - 1}\right) \times \left(C^{n+m-y}_{n-(x+y)/2} - C^{n+m-y}_{n-(x+y)/2-1}\right)\]

进一步枚举𝑥，可以得到问题的答案为

\[\sum_{1\le x \le n-m}\sum_{1\le y\le n+m} \left(C^{y-1}_{(y-x)/2} - C^{y-1}_{(y-x)/2 - 1}\right)\left(C^{n+m-y}_{n-(x+y)/2} - C^{n+m-y}_{n-(x+y)/2-1}\right)\left[(x\mod 2)=(y\mod 2)\right]\]

复杂度分析

我们枚举了 $x$ 与 $y$，其中$x=\Theta(n) ，y=\Theta(n)$，计算组合数在预处理后计常数复杂度，复杂度约为$O(n^2)$ 在Codeforces上，本题使用了249ms

代码

#include <bits/stdc++.h>
using namespace std;
 
const long long mod = 998244853;
const int maxn= 4000 + 5;
long long prod[maxn], iprod[maxn];
 
long long pmod(long long a, long long b) {
	long long ret = 1;
	while (b) {
		if (b & 1) ret = ret * a % mod;
		b >>= 1;
		a = a * a % mod;
	}
	return ret;
}
 
long long C(long long n, long long m) {
	if (n < m) return 0;
	if (n < 0 || m < 0) return 0;
	return prod[n] * iprod[m] % mod * iprod[n - m] % mod;
}
 
long long f(long long m, long long n) {
	if (m < n) return 0;
	return (C(m + n, m) - C(m + n, m + 1) + mod) % mod;
}
 
long long sol(long long n, long long m) {
	long long cnt = 0;
	for (long long i = 1; i <= n; i++) {
		for (long long j = 0; j <= m && j <= i; j++) {
			long long ans1, ans2;
			ans1 = f(i - 1, j) * (i - j) % mod;
			ans2 = f(m - j, n - i);
			(cnt += ans1 * ans2 % mod) %= mod;
		}
	}
	return cnt;
}
 
int main() {
	int n, m;
	prod[0] = iprod[0] = 1;
	for (long long i = 1; i < maxn; i++) {
		prod[i] = prod[i - 1] * i % mod;
		iprod[i] = pmod(prod[i], mod - 2);
	}
	cin >> n >> m;
	cout << sol(n, m) << endl;
	return 0;
}

某氢酱的年终总结

Mon, 31 Dec 2018 00:00:00 +0000

0x00. Abstract & Keyword

本文按照工作、后ACMer、台站建设以及$O(1/n)$分组建设等几个方面xjb诌了一下今年摸的一些鱼，并对明年的摸鱼计划进行了一些不切实际的展望。

Keywords: 咸鱼；年终总结；摸鱼；瞎扯；

0x01. 工作

今年参加了若干个公司的面试（大约5家）其中既有特别有名的那种，也有不知名的那种，但好像都有一个特点，就是ACMer（或许应该叫JBer，但是实际上退役的时候都还是ACMer，所以应该叫ACMer）特别多。现在的状态是咸鱼等着某G（A？）字头公司的Offer，如果有人方便的话，烦请捞一把，谢谢啦。

另一方面2018年下半年 ProblemCI 正式版……开工……开花……关注。

0x02. 退役$^2$

今年虽然退役了，但还是参加了两场Regional，分别是南京和深圳的CCPC Final，总的来说两场都还是不错的，但是还是有点手生导致犯了一些弱智的错误，其实稍微注意一下的话，拿金似乎也不是不可能的样子。

另外一件事就是最近开坑了一个项目，名为：

“Summer Nap CAFE”，远东算法午睡结社之夏

名字的来源是高中时看《中二病》给OI集训队（？）起的名字，后来在机房的门口挂了一段时间，不过好像后来被扯了下来。目前对这个名字的用途应该是作为一个民间算法竞赛相关，兼而研究一些奇怪的黑科技的社团性质（Like 学校社团）的组织，但仍然没有任何特别的想法。

另一个就是计划以这个社团的名义举办一场程序设计竞赛，但不一定是算法竞赛，也可能含有少量的CTF元素。以及以这个社团的名义举办一场“情侣Hackathon”，关于这个情侣Hackathon的内容，参考我之前发的一条说说。

如果有愿意提供Idea的同学，欢迎和我联系。

0x03. 台站建设

今年虽然在上半年的时候正式拿到了呼号，但是手中唯一的设备只有一台小米对讲机，功率更是只有2W之高，以至于上中继也只能得到（目测）45、46的信号报告，后来花重金更换了某拉杆天线之后，可以得到（目测）58、59的信号报告。之后由于在外实习的缘故一直没有进行任何QSO，在实习结束之后，进行过一些零散的QSO。在南京的时候面基了某BD4RCW，并亲切问候了该女装选手，进行了Eyeball QSO，并交换了QSL卡片。还印制了第一批QSL卡，虽然还没有发送的意思。

在十二月考试并拿到了B证，并又花重金购置了一台有名的_U/VHF电台，即宝峰UV5R。

在2019年，大概会干这么两件事：

架短波台
打卫星

并定下这么一个flag：完成包含中国大陆10个区重至少7个区的通联，并完成至少20个短波QSO以及10个卫星QSO。当然2019年上半年的目标嘛……

购入一套完整的，可以用于接收以及发射的短波设备

（这就排除了德生PL365这种短波_收音机了

0x03_.25 “WARSC”通联中国车站

今年感到比较遗憾的一件事就是武九线（北环线段）的拆除，之前一直对北环线和它的拆除工作有些了解，但是又一直由于时间关系没能实地参观一下这条著名的铁路。对武九线的拆除还是感到又惋惜又无奈，如果当时修的是复线的话，可能还有一些别的可能性，现在来看的话，无论是运力还是空间都显得特别鸡肋，现在只是希望能把徐家棚车辆段和武昌北站搞得好看一点。

明年一个打算就是向完成“通联中国车站”这个不可能完成的任务稍微前进一些。又听说帝都的环铁现在正在展出部分复兴号机车，希望能够在撤展之前（虽然应该不太可能了）再前去参观一次。不得不说，CR在铁路文化方面好像有那么一点进步了。

0x04. $O(1/n)$分组的建设工作

略。

算法竞赛，从入门到退役

Sun, 14 Jan 2018 00:00:00 +0000

算法竞赛的前奏

还记得第一次接触编程是在小学四年级的时候（写完这句话突然发现，接触编程已经十年了），那时候偶然见到一本讲Flash的书（当年Flash还不是Adobe家的，现在Flash已经成为时代的眼泪了），从那里开始接触到Flash的编程，ActionScript2，但是并没有怎么深入，因为没多久就接触到一门更方便入门的语言，叫Visual Basic。

VisualBasic虽说有个Basic的名，但是现在想来，和Basic并没有多大联系，或者是说可能经过好几个大版本的迭代，已经没有当年Basic的影子了。不过从初学者的角度而言，VB还是挺好用的，当然主要原因就是VB可以拖控件，这就使得一行代码不写，就可以“写”出一个可以过编译但是除了过编译就没有任何用的程序。不过正是因为VB不写代码就能写（带窗口的）程序的特性，给刚接触编程的我一个正反馈，也使得我在编程的路上越陷越深。后来家里人看着我这样，感觉光写程序太没意思了，就随便报了一个NCRE（就是等级考试啦，好像这么多年还是80块？），一级的MSOffice随便就过了，到二级的时候因为各种概念记不清楚，笔试就挂了一次。后来也过了。到小学六年级的时候，想尝试一下三级，三级的时候就不能用VB了，取而代之的是有用VC的网络的科目来选。

VC，虽然现在被骂得不成样子，但是确实是一个事实标准，相比于VB，C语言一下子就复杂了许多，首先VB是一个（伪）面向对象语言，而C就只有面向过程部分，更不用说指针把人指的眼花缭乱。但似乎除此之外，也没有太多的不同点。VB有函数，VC也有，VB有循环，VC也有，VB用EndIf、Next，VC用的大括号，这样想来，其实所有的编程语言（应该是大部分）都一个样，换个关键词，换个结构，就能编程另外一门语言。

到了初中之后，压力一下子大了起来，早上六点起床成了常态，虽然我的成绩稍好一些，大部分的作业都能在学校完成，在家里并不需要多少时间应付作业上的事情。但也不可能有大块时间去写代码。初一的时候，在网上搜到了一篇新闻，讲的是参加算法竞赛有机会保送到武汉市的重点王牌中学（原文如此）便想去尝试一下。打电话联系到了一位老师试着听了一下他的课，虽然只听了一次就因为没有时间而放弃了，但也摸到了算法竞赛的门把手。在那年的秋天参加了当年的NOIP（全国信息学奥赛省赛）的初赛之后，就在复赛（普及组）漂亮地得到了0分。此后两年，没有任何和算法竞赛的接触，甚至剪掉了家里电脑的电源线（只是一根备用线，用来忽悠初中班主任）。

真正的入门

再一次接触算法竞赛，是在初中升高中的暑假，早早知道自己的成绩之后，在开学之前的暑假到了高中参加暑假集训。因为Pascal正在算法竞赛届流行（差不多就是在那一年之后，没有更多的人用Pascal写算法竞赛题目，都转而使用C++，其原因是CCF方面放开了C++语言使用标准库的限制）就花了几天从C转到Pascal，又在比赛前夕转用C++编程，正如我之前所说，这些语言都是相似的，无非就是些关键字的差别，声明调用的差别，所以这次转语言异常顺利。高中开学之后，被（qin）分（ding）到了竞赛班，全班只有我和另外一名同学参加信息学竞赛。一眼望去，全是数学和物理竞赛的。加上入学摸底考试又处于全班垫底，使得我高中三年都不敢看成绩单（事实上，这一垫底就垫了三年，所以我不用看也能知道自己的排名）。

那年的NOIP成绩并不理想，只有省二等奖，在湖北省这个弱省的环境下可以说很差了。而到了高一下学期，也就是2013年，开始了停课生涯，也就正式开始为算法竞赛而准备。也接触了Online Judge这个好东西，没日没夜的在机房刷题，虽然现在看来，做那些题目跟划水没有区别，但是仔细去想的话，也在一定程度上提高了写代码的熟练程度。高一的那年暑假，到湖南去参加湖南省队组织的集训，第一次见到真正的算法竞赛的大神，也第一次见识到真正的算法竞赛题目。在划了一年水之后，我开始接触有难度的题目，决定以省选为目标。也接触到“大视野在线评测”这个OJ。高二新学期开学之后，写的代码从“计算书号”，变成了“给你一个长度十万的数列，1秒内做十万次区间/减/乘/除/极大/极小/和/中位数/平均数”等等等等。

疯狂的2014年

跨入2014年，我的目标从“拿省一”变成了“用上Ubuntu 14.04 LTS”，因为这个版本在省选之后发布，如果没有入选省队，也就意味着就此退役，回归普通高中生的生活。为此我拼命地刷题，在做题最多的一天，我从早上7点半一直做到了晚上十点，完成了7道题。而在半年多的时间当中，我做了300题有余。也是在那个时候，我接触到了在线比赛，即一个名为Codeforces的网站，时不时地打一场比赛，学一下新姿势，成为了生活的常态。想到今年听到广东工业大学的教练说他们的同学是“冬练三九，夏练三伏”，也是深有同感。当然也参加了当年的武大校赛，虽然只过了一题就GG了。

2014年，我开始用Github管理我的代码，也看到了当年为了从全国千余人中出头的渴望。在上面这张图里，也可以看到在六月，也就是大赛前的一个月，Github上的格子格外密集一些。当然，最终一切都停在了2014年的7月底，大赛结束之后，因为自己的能力实在不足，我退役了，退役之后文化课成绩不到500分，为了弥补一年多的损失，只有把当年打比赛的精力全部用来准备高考。高考最后结果怎么样嘛，当然是裸分考不上武大啦。

再战算法竞赛

高考结束之后，我在湖北NOI学生交流群里看到了这样一句话：“武汉大学ACM集训队暑假集训将于2015年7月19日开始，地点在计算机学院B304”，本来这个消息是说给当年NOI上面签约的另外三名同学的，然后我见到之后当即决定：

不打这比赛我还是人？

（当然，我在高考结束之后的第一天，就已经决定要在大学参加ACM系列比赛，此处仅供调侃）

于是在2015年的夏天，我的Github上又多处了一抹原谅的绿色。

看那夕阳下的绿色，是我逝去的青春啊。

在那暑假集训之后，我们队就以还行的成绩去参加了当年的ACM/ICPC区域赛合肥赛区，深秋的合肥不得不说还是挺冷的。在合肥，我还见到了当年的高中学长和当年湖北省队的第一名@vfleaking，虽然合肥的成绩并不理想，90个参赛队中，只拿到了一个还行的成绩。有趣的是，在比赛的直播中，似乎有一名主播说了这样一句话：

这个（叫傅立叶变换的队）昨天没有做出C怎么今天在看A啊

（那两场比赛中C题和A题都是傅立叶变换的题目）

那年的12月，我们又参加了在上海举办的EC-Final（再一次享受到了公费旅游的乐趣），然后”顺利”得到了铜牌第一名的成绩（就是上面那张图）。

转眼间到了2016年，课程压力又又又又变大了。但是即使这样，该要继续的东西还是要继续，B304机房里面的同学，大三大四的开始退役，为找工作，实习，读研奔波。只是偶尔能在机房看到他们打三国杀 / 狼人。到了2016年的春天，我们又开始为新一年的比赛做准备。当然，2016年因为划水太多，很多训练都没有用心去做，事后也没有认真去想，2016年的成绩也并不理想，只得到了两个铜。

（别看数量，看密度）

只为金牌的2017年

2016年的比赛之后，又有一波同学退役了，当然也有陆敬浩他们队进了决赛。这个时候，上海交大以前的金牌选手@ftiasch（圈内叫叉姐）发出了一个名为ICPC-Camp的训练营的邀请，之前组过FFT队的队友@Sagitta拉着我想去参加。

当然要去啦，不去我还是人？（诶这话我是不是说过？）

在集训队里面问了一下之后，我们集训队最终凑出了三支队（~~BiBi，Printemps和Lily white~~）（没睡醒、丝滑拿铁、两学一做）一共九个人，跑去被虐。也是在两次参加湖南省队集训之后的第三次感受到了真正的难题的样子。不过题目难是一方面，做起来的确舒服。而差不多是每年的既定程序，在武汉打了一圈校赛之后，又到湖南和陕西参加了两场省赛，都是二十余名的样子，好在都拿到了金牌。

又到了暑假集训，和之前两年的暑假集训所不同的地方在于，这一年的暑假集训，是由我来组织。因为暑假集训关系到当年的参赛队伍，也是在比赛之前最后一次大规模训练，所以从题目的挑选到规划，都必须按照当年的区域赛的模式来进行。为此没有少操心。在暑假集训期间，机房的空调效果也不好，问了楼下的物业怎么检查却发现不了问题，最后得到的答复竟然是“关掉放五分钟再开”就好了（事实上真的是这样！）还有训练期间遇到的学院大楼停电，就有了30人大战女仆咖啡厅的故事。

三十人大战女仆咖啡厅的场面

在暑假集训的最后几天，因为又有一些人怀疑排名的公平性，所以又换题，模拟正式比赛流程，自己出钱去打印题面。但最后还是得到了一个让大部分人都信服的排名，按照这个排名又去安排了这一年的区域赛参赛分配。而我所在的队就最终定在了ICPC的沈阳、南宁、外加一个CCPC的杭州赛区。而比赛结果方面，沈阳赛区当中，银牌第四，杭州倒是拿了金牌，但到了南宁，又和题目八字不合（其实就是菜）只拿到了铜牌。在比完南宁之后，我倒是觉得，差不多就这样了，没有金牌也就认了，还是自己的能力不够。抱着这样想法的我，对于EC的准备也是随便应付一下，又把精力投入到了课程的学习当中。

但可能也正是因为对EC的准备是如此的放松，如此的不抱希望，在比赛的时候心态也是如此的好。像以往的时候，我在比赛时常说的一句是“靠题数，罚时算了”，但是EC的时候我却对着一道一百多个队通过的题说出了“我再改改，不行这题就算了”的话。到了最后一个小时，想法也从“我们抓紧时间，一起想一题”，变成了悄悄再开一题玩玩，反正拿不了金。

可哪想着就这样拿金了呢？所以说，一个人的命运啊，既要考虑历史的进程，个人的心态也是很重要的啊。

无病呻吟的感悟

比完今年的最后一场比赛，想着算法竞赛的生涯就到此结束，要和五年来不变的目标说再见了，感觉还是少了点什么。不过看着OJ上不再提交的一个个账号，他们的个人签名变成了“OI再见”或者“ACM再见”之类的话，想来算法竞赛对于我们而言早已是生活的一部分，又怎么可能那么简单说再见呢？打算法竞赛的时候，我曾经为了一道题目，代码能够块10毫秒，少用几兆内存而改上数个小时，能够因为一道题没有通过就寝食难安，也曾为做出一道鲜有人做出的题惊喜，也有在比赛中登顶的喜悦。

这些东西，早已成为了肌肉记忆，哪怕不再打比赛，不用再纠结那一点点的优化，也会去不自觉的去修改代码——这里还能把常数改小一点，那里换个顺序还能让浮点数的精度高一点——而正是这些，在算法竞赛中积累的经验，以及精益求精的思想和严谨的思维，是其它任何东西都带来不了的。

Codeforces Round 368 Div.2

Wed, 04 Oct 2017 00:00:00 +0000

今天下午找Camp的训练题的时候找到的一场CF的题目，感觉题目的质量还不错，尤其是这一场的E题非常喜欢。

A. Brain’s Photos

没有什么多说的，非常基础的模拟题

B. Bakery

同样也没有什么多说的，这一题如果稍加变化是一道非常好的Div.2 C难度的题目

我做的时候使用了超级源跑最短路的想法，实际上完全不需要，一个贪心就可以了。

C. Pythagorean Triples

给你一个数，求与可以这个数组成勾股数的另外两个数。

感觉是数学里面非常基础的一个点，即a² - b² = (a + b)(a - b)，分奇偶讨论一下就可以发现答案，这一题给了数学不好的人非常好的提示，就是几组样例，思考样例的答案是如何构造出来的就可以发现上面的公式。

D. Persistent Bookcase

这题有点OI风范，感觉质量不算高，有点为了可持久化而可持久化的意思，非常裸的裸可持久化。但是又对可持久化的原理要求一定的了解，另外还有一丝卡内存，数据范围应该再稍微小一些比较好。

E. Garlands

这一题是整套题目里面最喜欢的一道题，大概能推测出来作者是先想出的这道题再补全剩下的题目。

题目的大意是在2000*2000的矩阵内给定若干条互不相交的灯带，每个灯如果亮就对它所在的格子有w的权值贡献，一次可以开或者关一个灯带，穿插着一些询问，询问的格式是问一个矩形区域内当前量着的灯的权值和是多少。

喜欢这道题的原因是这题给了充足的提示，引导你的思维往正解的方向上走，比如题目里面最明显的提示就是询问的个数不超过2000个，这就很容易去引导着想2000的平方左右的算法，事实上我最终的算法大约是O(nq log n)的。同时这一题还有很多非常基础的思想。

最开始看到这题的时候，以为是一道数据结构题，但是后来发现没有合适的数据结构可以处理这样的修改。这时候2000的提示就有了作用，这个两千提示我要单独处理询问，于是开始往离线处理的思路上去想，同时我们对于这样的询问一个显然的思想就是使用容斥原理来算出答案而非直接区间查询。

因此我们发现了另外一个2000乘2000的地方，即有不超过2000条灯带，灯带的长度也同样不超过2000，即可以考虑分不同的颜色来单独处理，忽略灯带的连续性，而只将其视作离散的点集，思考如何在2000乘2000的时间内计算某一种颜色对于所有区域的贡献。

接下来考虑使用排序离散化之后配合Bit完成区间查询的操作，发现可以满足题目的要求，复杂度即前文的平方log，可以接受。最后把答案合并即可，整个过程十分流畅，同时没有非常复杂的数据结构，整个完成时间应该可以在45分钟左右。作为一道没有过于高级的数据结构题目，也是非常适合初学者锻炼思想以进一步提高的题目。

TopCoder SRM717 Div1 Middle

Mon, 04 Sep 2017 00:00:00 +0000

题意

给定两个数$n$, $m$

另$D_i$为集合${1, 2, \ldots, n + i}$的全排列$p$中满足$\forall j \in [1, i], p[j] != j$的全排列的个数。

另$B_i = D_i / n!$，易证$B_i$为整数

求$B_1 \oplus B_2 \oplus B_3 \oplus \ldots B_m$的值。

注意：异或和只是为了减少答案大小，标程计算了所有的$B_i$的值。

思路

考虑$D_i$的表达式

\[D_i = \sum_{j=0}^i \binom{i}{j} (-1)^j (n+i-j)!\]

最后发现拿$\frac{n!}{0!n!},\frac{(n+1)!}{1!n!},\frac{(n+2)!}{2!n!},\ldots,\frac{(n+m)!}{m!n!}$和$1/0!, -1/1!, 1/2!. -1/3!, \ldots, (-1)^m/m!$卷一下就好了。

Code

耗时: 12107 ms

内存: 37480 kB

#include <bits/stdc++.h>
using namespace std;

const int mod = 1000000007;
const double PI = acos(-1);
typedef complex<double> Complex;
const int N = 262144, L = 15, MASK = (1 << L) - 1;
Complex w[N];
void FFTInit()
{
	for (int i = 0; i < N; i++)
		w[i] = Complex(cos(2 * i * PI / N), sin(2 * i * PI / N));
}

void FFT(Complex p[], int n)
{
	for (int i = 1, j = 0; i < n - 1; i++)
	{
		for (int s = n; j ^= s >>= 1, ~j & s;);
		if (i < j) swap(p[i], p[j]);
	}
	for (int d = 0; (1 << d) < n; ++d)
	{
		int m = 1 << d, m2 = m * 2, rm = n >> (d + 1);
		for (int i = 0; i < n; i += m2) {
			for (int j = 0; j < m; j++) {
				Complex &p1 = p[i + j + m], &p2 = p[i + j];
				Complex t = w[rm * j] * p1;
				p1 = p2 - t;
				p2 = p2 + t;
			}
		}
	}
}

Complex A[N], B[N], C[N], D[N];
void mul(int a[N], int b[N])
{
	for (int i = 0; i < N; i++) {
		A[i] = Complex(a[i] >> L, a[i] & MASK);
		B[i] = Complex(b[i] >> L, b[i] & MASK);
	}
	FFT(A, N), FFT(B, N);
	for (int i = 0; i < N; i++)
	{
		int j = (N - i) % N;
		Complex da = (A[i] - conj(A[j])) * Complex(0, -0.5),
				db = (A[i] + conj(A[j])) * Complex(0.5, 0),
				dc = (B[i] - conj(B[j])) * Complex(0, -0.5),
				dd = (B[i] + conj(B[j])) * Complex(0.5, 0);
		C[j] = da * dd + da * dc * Complex(0, 1);
		D[j] = db * dd + db * dc * Complex(0, 1);
	}
	FFT(C, N), FFT(D, N);
	for (int i = 0; i < N; i++) {
		long long da = (long long)(C[i].imag() / N + 0.5) % mod,
			 db = (long long)(C[i].real() / N + 0.5) % mod,
			 dc = (long long)(D[i].imag() / N + 0.5) % mod,
			 dd = (long long)(D[i].real() / N + 0.5) % mod;
		a[i] = ((dd << (L * 2)) + ((db + dc) << L) + da) % mod;
	}
}

long long pow_mod(long long a, long long b)
{
	long long ret = 1;
	while (b)
	{
		if (b & 1) ret = ret * a % mod;
		a = a * a % mod;
		b >>= 1;
	}
	return ret;
}

int ta[N], tb[N], nn[N], frac[N], ifrac[N];

struct DerangementsStrikeBack{
	int count(int n, int m)
	{
		FFTInit();
		memset(ta, 0, sizeof ta);
		memset(tb, 0, sizeof tb);
		memset(nn, 0, sizeof nn);
		memset(frac, 0, sizeof frac);
		memset(ifrac, 0, sizeof ifrac);
		nn[0] = frac[0] = ifrac[0] = 1;
		for (int i = 1; i <= m; i++)
		{
			frac[i] = ((long long)frac[i - 1]) * i % mod;
			ifrac[i] = pow_mod(frac[i], mod - 2);
			nn[i] = ((long long)(nn[i - 1])) * (n + i) % mod;
		}
		for (int i = 0; i <= m; i++)
		{
			ta[i] = ((long long)nn[i]) * ifrac[i] % mod;
			if (i & 1)
				tb[i] = (mod - ifrac[i]) % mod;
			else
				tb[i] = ifrac[i];
		}
		mul(ta, tb);
		int ans = 0;
		for (int i = 1; i <= m; i++)
			ans ^= (((long long)ta[i]) * frac[i] % mod);
		return ans;
	}
};

TopCoder SRM716 Div1 Middle

Mon, 04 Sep 2017 00:00:00 +0000

题意

给定一棵树，能否找到一条路径$x_0, x_1, x_2\ldots, x_n$，使得$x_0 = 0$，$Set{D(x_i, x_{i+1})} = S$

思路

如果存在长度为$A$的路径，那么一定存在长度为$A-1$的路径。

考虑建一个新的图，使得图中的每条边的长度都在S中，则答案就是询问是否存在一个点$p$，使得能从0沿新的图走到$p$，且满足距离$p$最远的点的距离大于等于$S$中最大的元素。

Code

耗时: 3911 ms

内存: 28192 kB

#include <bits/stdc++.h>
using namespace std;

const int maxn = 2000 + 5;

struct JumpDistancesOnTree{
	vector<int> e[maxn], e2[maxn];
	unordered_set<int> S;
	int dd[maxn], fur[maxn];
	int flag[maxn];
	void getdist(int u)
	{
		memset(dd, 0x3f, sizeof dd);
		dd[u] = 0;
		queue<int> q;
		q.push(u);
		while (!q.empty())
		{
			int u = q.front();q.pop();
			for (int i = 0; i < (int)e[u].size(); i++)
			{
				if (dd[e[u][i]] > dd[u] + 1)
				{
					dd[e[u][i]] = dd[u] + 1;
					q.push(e[u][i]);
				}
			}
		}
	}
	string isPossible(vector<int> p, vector<int> s)
	{
		int mx = 0;
		memset(fur, 0, sizeof fur);
		for (int i = 0; i < (int)s.size(); i++)
			S.insert(s[i]);
		mx = s[s.size() - 1];
		int n = p.size() + 1;
		for (int i = 0; i < (int)p.size(); i++)
		{
			e[p[i]].push_back(i + 1);
			e[i + 1].push_back(p[i]);
		}
		for (int i = 0; i < n; i++)
		{
			getdist(i);
			for (int j = 0; j < n; j++)
			{
				if (S.find(dd[j]) != S.end())
				{
					fur[i] = max(fur[i], dd[j]);
					e2[i].push_back(j);
				}
			}
		}
		queue<int> q;
		q.push(0);
		memset(flag, 0, sizeof flag);
		flag[0] = 1;
		while (!q.empty())
		{
			int u = q.front(); q.pop();
			for (int i = 0; i < (int)e2[u].size(); i++)
			{
				if (!flag[e2[u][i]])
				{
					flag[e2[u][i]] = 1;
					q.push(e2[u][i]);
				}
			}
		}
		for (int i = 0; i < n; i++)
			if (flag[i] && fur[i] >= mx) return "Possible";
		return "Impossible";
	}
};

DFT FFT NTT 是什么 & 为什么？

Fri, 04 Aug 2017 00:00:00 +0000

最近在各种比赛中做了一些关于FFT的题目，感觉对FFT的理解还不是特别深刻，于是在网上搜了一些资料，整理出了关于DFT（FFT）和NTT的一些内容。

DFT

我们都知道，当我们用到FFT或者NTT的时候，都是各种多项式乘法的内容，于是问题来了，为什么它是对的？

先从线代的内容开始

考虑这样一个矩阵：

\[A = \left( \begin{matrix} a_{0,0} & a_{0,1} & \cdots & a_{0,n-1} \\ a_{1,0} & a_{1,1} & \cdots & a_{1,n-1} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n-1,0} & a_{n-1,1} & \cdots & a_{n-1,n-1} \\ \end{matrix} \right)\]

和这样一个向量 $x = \left(x_0, x_1, \cdots, x_{n-1}\right)^T$

如果它是线性无关的，且是可逆的，那么我们就有$AxA^{-1} = x$，我们发现这是一句废话，所以并没有多少实用价值。但是我们这时候就把$A$这个矩阵叫做变换好了。

我们知道，DFT的目的是为了做向量的卷积，即求出 $z = x \star y$ , 这里 $\star$ 表示卷积。

如何利用上面这些东西？

注意到 $z_v = \sum_{q} x_q y_{v-q}$

我们又注意到 $(Ax)_{u} =\sum_qx_qa_{u,q}$ 和 $(Ay)_{u} = \sum_q y_q a_{u,q}$

$(Ax)_{u} (Ay)_{u} = \sum_p\sum_q x_p y_q a_{u,p} a_{u,q}$

那么这个时候，如果我们在$z$边上加个求和符号的话，就得到了

\[\sum_v z_v = \sum_p \sum_q x_q y_{p-q} = \sum_q x_q \sum_q y_{q} = (\sum_q x_q)(\sum_q y_{q})\]

那么如果再在左边加上一个 $a_{u,v}$ 呢？

\[Z_u = \sum_v z_v a_{u,v} = \sum_p \sum_q x_q y_{p-q} a_{u,v}\]

啊，如果对于矩阵$A$，我们有 $a_{u,p}a_{u,q} = a_{u,p+q}$ 的话就好了，因为这样我们就可以得到一个重要的式子——

$Az = Ax \cdot Ay$

证明

由前文得到的

\[Z_u = \sum_v z_v a_{u,v} = \sum_p \sum_q x_q y_{p-q} a_{u,v}\]

我们有

\[Z_u = \sum_v z_v a_{u,v} = \sum_p \sum_q x_q y_{p-q} a_{u,q}a_{u,p-q}\]

即

\[Z_u = \sum_q x_q a_{u,q} \sum_p y_{q,p-q} a_{u,p-q} = (Ax)_u (Ay)_u\]

即

\[Z = (Ax)\cdot (Ay)\]

即

\[Az = (Ax)\cdot (Ay)\]

于是呢？

根据指数函数的性质，我们可以轻易构造出一组$A_{u,v} = b_u^v$异或

构造

\[A = \left( \begin{matrix} 1 & b_0 & b_0^2 & \cdots & b_0^{n-1} \\ 1 & b_1 & b_1^2 & \cdots & b_1^{n-1} \\ \vdots & \vdots & \ddots & \vdots \\ 1 & b_2 & b_2^2 & \cdots & b_{n-1}^{n-1} \\ \end{matrix} \right)\]

当$b_u$两两不同的时候，$A$是可逆的。

性质

从上面这些内容，我们可以得出这个变换的一些性质：

$Ax + Ay = A(x + y)$
$A(kx) = kAx$
$x\star y\star z = Ax \cdot Ay \cdot Az$ 推广得到 ${\Large\star} x_i = {\Large\cdot}Ax_i$
$(x_1 + x_2)\star y = (Ax_1 + Ax_2)\cdot Ay$（我们将在后面展示这个性质的应用）

这里的第一、二条很显然，第三条要理解这个变换的实质，而第四条则是第1条的另一个扩展，它在部分情况下很实用。

从 DFT 到 FFT

现在思考我们在DFT中用到的矩阵

\[A = \left( \begin{matrix} 1 & b_0 & b_0^2 & \cdots & b_0^{n-1} \\ 1 & b_1 & b_1^2 & \cdots & b_1^{n-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & b_{n-1} & b_{n-1}^2 & \cdots & b_{n-1}^{n-1} \\ \end{matrix} \right)\]

发现要计算它还是得 $O(n^2)$ 的时间，我们觉得很恶心，因为这样的变换没有起到降低复杂度的作用。于是我们考虑一个我们已经用过很多遍的技术……算贡献。

然而我们发现……并没有什么卵用。这时候就有人提出，如果让$b_k = b_1^n$的话，事情似乎会变得不一样……

\[A = \left( \begin{matrix} 1 & 1 & 1 & \cdots & 1 \\ 1 & b & b^2 & \cdots & b^{n-1} \\ 1 & b^2 & b^4 & \cdots & b^{2(n-1)} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & b^{n-1} & b^{2(n-1)} & \cdots & b^{(n-1)^2} \\ \end{matrix} \right)\]

我们发现它依然是可逆的，但是依然没有什么卵用，考虑令 $b = e^{2\pi / n}$

\[A = \left( \begin{matrix} 1 & 1 & 1 & \cdots & 1 \\ 1 & e^{2\pi / n} & e^{2\times 2\pi / n} & \cdots & e^{(n-1)\times 2\pi / n} \\ 1 & e^{2\times 2\pi / n} & e^{4\times 2\pi / n} & \cdots & e^{(n-2)\times 2\pi / n} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & e^{(n-1)\times 2\pi / n} & e^{(n-2)\times 2\pi / n} & \cdots & e^{2\pi / n} \\ \end{matrix} \right)\]

不妨令 $n=8$，我们直观感受一下这个矩阵。

\[A = \left( \begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & e^{1\times 2\pi / 8} & e^{2\times 2\pi / 8} & e^{3\times 2\pi / 8} & e^{4\times 2\pi / n} & e^{5\times 2\pi / 8} & e^{6\times 2\pi / 8} & e^{7\times 2\pi / 8} \\ 1 & e^{2\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{6\times 2\pi / 8} & 1 & e^{2\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{6\times 2\pi / 8} \\ 1 & e^{3\times 2\pi / 8} & e^{6\times 2\pi / 8} & e^{1\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{7\times 2\pi / 8} & e^{2\times 2\pi / 8} & e^{5\times 2\pi / 8} \\ 1 & e^{4\times 2\pi / 8} & 1 & e^{4\times 2\pi / 8} & 1 & e^{4\times 2\pi / 8} & 1 & e^{4\times 2\pi / 8} \\ 1 & e^{5\times 2\pi / 8} & e^{2\times 2\pi / 8} & e^{7\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{1\times 2\pi / 8} & e^{6\times 2\pi / 8} & e^{3\times 2\pi / 8} \\ 1 & e^{6\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{2\times 2\pi / 8} & 1 & e^{6\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{2\times 2\pi / 8} \\ 1 & e^{7\times 2\pi / 8} & e^{6\times 2\pi / 8} & e^{5\times 2\pi / 8} & e^{4\times 2\pi / 8} & e^{3\times 2\pi / 8} & e^{2\times 2\pi / 8} & e^{1\times 2\pi / 8} \\ \end{matrix} \right)\]

折半引理和蝶形变换

注意到 $b^k = b^{\lfloor k / 2\rfloor}b^{k - 2\lfloor k / 2\rfloor}$ ，我们发现这又是一句废话，但是它非常有用。

然后继续观察矩阵的特征，考虑使用 $X^{[0]}$ 和 $X^{[1]}$ 分别表示这个矩阵分别作用于$x$偶数行和$x$的奇数行的结果。则我们发现，对于结果的前4行，我们有 $X_k = X_k^{[0]} + X_k^{[1]}$ ，对于结果的后四行，我们有 $X_{k+4} = X_{k+4}^{0} - X_{k+4}^{[1]}$

考虑这样的一个计算方法：

\[\begin{matrix} X^{[0]} =& x_0 + b^2x_2 + b^4x_4 + b^6x_6 + \ldots + b^{2n}x_{2n}\\ X^{[1]} =& b(x_1 + b^2x_3 + b^4x_5 + b^6x_7 + \ldots + b^{2n}x_{2n+1}) \end{matrix}\]

注意到这个过程可以递归分治实现，故复杂度为 $O(n \log n)$ ，进一步的分析可以使用非递归的FFT进行计算。

(哇，这又是行又是列的真是绕)

从DFT到NTT

注意到在DFT中，我们使用了单位复数根$e^{2\pi / n}$作为我们的$b$，那么如果要求使用整数，或者说模 $p$ 的群中进行计算的话，有没有别的方法可以达到一样的效果呢？

注意到我们需要这个数满足下面的性质：

$b^{i}$，当$k$取 $i$ 到 $n - 1$ 的时候，值不能有重复。这是为了保证矩阵的线性无关。
$b^{i} + b^{i + n/2} = 0$ ，当然这一点很好满足，因为我们只需要让 $b^{n} = 1 (\mod p)$，即可满足这一点。

那么答案当然是存在的，利用数学中原根的概念，可以很轻易做到这一点。

那么问题就变得非常简单了，只需要简单地用 $p$ 的乘法原根去替换前文中的 $b$ ，我们就可以得到一个新的变换，同时它还满足FFT的几乎所有性质。我们管他叫NTT

（完，这篇文章主要讲了FFT和NTT的各种“为什么”，也是我一直以来比较疑惑的一点。）

HDU 6061 RXD and functions

Tue, 01 Aug 2017 00:00:00 +0000

题意

在一眼看出$a_i$只有用来求$\sum a_i$意义之后，题意变成了求$\sum_{i=0}^{n} c_i(x + p)^i$展开式中$x^i$项前面的系数。

思路

考虑变形：

\[\begin{align*} \sum_{i=0}^{n} c_i(x + p)^i &=& \sum_{i=0}^{n} c_i \sum_{j=0}^i \binom{i}{j} x^{i-j} p^{j} \\ &=& \sum_{i=0}^{n} c_i \sum_{j=0}^i \frac{i!}{j!(i-j)!} x^{i-j} p^{j} \\ (r\leftarrow i-j) & = & \sum_{r=0}^{n} \frac{x^r}{r!} \sum_{j=0}^{n-r} \frac{(r+j)!}{j!} c_{r+j} p^{j} \\ & = & \sum_{r=0}^{n} \frac{x^r}{r!} \sum_{j=0}^{n-r} c_{r+j} (r+j)! p^j (j!)^{-1} \\ \left(K_j\leftarrow p^{n-j}(n-j)!^{-1}\right) & = & \sum_{r=0}^{n} \frac{x^r}{r!} \sum_{j=0}^{n-r} c_{r+j} (r+j)! K^{n-j} \\ \left(Q_{r,j}\leftarrow (r+j)!c_{r+j}\right) & = & \sum_{r=0}^{n} \frac{x^r}{r!} \sum_{j=0}^{n-r} Q_{r,j} K^{n-j} \\ \end{align*}\]

注意到最后的式子为卷积的形式，结合$\mod 998244353$，考虑使用NTT来进行计算。构造$Q,K$两个数列，进行卷积即可得到答案。

Code

耗时: 592 ms

内存: 12736 K

#include <bits/stdc++.h>
using namespace std;

const int g = 3, mod = 998244353, maxn = 262144;

long long pow_mod(long long x, long long b)
{
	long long ret = 1;
	while (b)
	{
		if (b & 1) ret = ret * x % mod;
		x = x * x % mod;
		b >>= 1;
	}
	return ret;
}

struct NTT {
	long long w[262144];
	int cur_w_dir = 0;
	void pre_processw(int oper, int n) {
		if (cur_w_dir == oper * n) return;
		w[0] = 1;w[1] = pow_mod(g, (mod - 1) / n);
		if (oper == -1) w[1] = pow_mod(w[1], mod - 2);
		for (int i = 2; i < n; i++) w[i] = w[i - 1] * w[1] % mod;
	}

	void fft(long long P[], int n, int oper)
	{
		pre_processw(oper, n);
		for (int i = 1, j = 0; i < n - 1; i++) {
			for (int s = n; j ^= s >>= 1, ~j & s;);
			if (i < j) swap(P[i], P[j]);
		}
		for (int d = 0; (1 << d) < n; d++) {
			int m = 1 << d, m2 = m * 2, rm = n >> (d + 1);
			for (int i = 0; i < n; i += m2) {
				for (int j = 0; j < m; j++) {
					long long &P1 = P[i + j + m], &P2 = P[i + j];
					long long t = w[rm * j] * P1 % mod;
					P1 = (P2 - t + mod) % mod;
					P2 = (P2 + t) % mod;
				}
			}
		}
	}
}ntt;

long long frac[maxn], finv[maxn];
long long A[maxn], B[maxn], C[maxn];
long long sigma = 0;
int n;

void sol()
{
	int k = 1;
	while (k <= (n + 1) * 2) k *= 2;
	memset(B, 0, sizeof(long long) * k);
	memset(A, 0, sizeof(long long) * k);
	sigma = 0;
	for (int i = 0; i <= n; i++) scanf("%lld", &C[i]);
	for (int i = 0; i <= n; i++)
		B[i] = C[i] * frac[i] % mod;
	int m;
	scanf("%d", &m);
	for (int i = 0; i < m; i++)
	{
		int t;
		scanf("%d", &t);
		(sigma += t) %= mod;
	}
	sigma = mod - sigma;
	sigma %= mod;
	for (int i = 0; i <= n; i++)
		A[n - i] = pow_mod(sigma, i) * finv[i] % mod;
	long long kkinv = pow_mod(k, mod - 2);
	ntt.fft(A, k, 1);
	ntt.fft(B, k, 1);
	for (int i = 0; i < k; i++)
		(A[i] *= B[i]) %= mod;
	ntt.fft(A, k, -1);
	for (int i = 0; i < k; i++) A[i] = A[i] * kkinv % mod;
	for (int i = n; i <= n + n; i++) printf("%lld ", A[i] * finv[i - n] % mod);
	printf("\n");
}

int main()
{
	frac[0] = 1;
	for (int i = 1; i < maxn; i++) frac[i] = frac[i - 1] * i % mod;
	for (int i = 0; i < maxn; i++) finv[i] = pow_mod(frac[i], mod - 2);
	while (~scanf("%d", &n)) sol();
	return 0;
}