雯舞

这个题怎么Difficulty rating 80%80\% 啊，送经验的感觉啊D(m,n)=======∑d|m∑k=1nσ0(kd)∑d|m∑k=1n∑a|k∑b|d[(a,b)=1]∑a=1n⌊na⌋∑d|m∑b|d[(a,b)=1]∑a=1n⌊na⌋∑d|m∑b|d∑i|a,i|bμ(i)∑i|mμ(i)×(σ0∗1)(mi)∑id≤n⌊nid⌋∑i|mμ(i)×(σ0∗1)(mi

(k+1)|(n+k)(k+1) | (n+k) 就是 (k+1)|(n−1)(k+1) | (n-1) 这个函数就是最大的 kk 使得 1,2,⋯,k1,2,\cdots,k 都整除n-1吧 随便容斥下咯#include#include#includeusing namespace std;typedef long long ll;inline ll Gcd(ll a,ll

直接考虑每一位的贡献，应该是一个 ai×i×(1+10+⋯+10n−i)a_i\times i\times (1+10+\cdots+10^{n-i}) 的形式，这就是个等比数列求和 然后因为是循环串，还是个等比数列求和，就好了#include#include#includeusing namespace std;typedef long long ll;const int P

二分转化为μ2\mu^2的前缀和。 然后转化为O(n13)O(n^{1\over 3})的运算，但是需要预处理μ\mu的前缀和，大力杜教筛求和。 然后感谢阿爷教我把二分改成了迭代，小范围内一个一个挪，用rho求μ(n)\mu(n)，然后就能卡进去了。 复杂度似乎是萎的吧。#include#include#include#include#include#include#defi

整体二分，然后问题变成，子集加，单点查询，然后像CTSC吉夫特 可以用经典的二进制分高位低位的搞搞。调个参，大概是高5位低12位。 不知道在线怎么做。#include#include#include#include#define pb push_backusing namespace std;typedef long long ll;inline char nc(){

建出后缀树，记录每个子串的出现次数，然后二分下答案在哪个子串中就好了退役选手不会写后缀自动机#include#include#include#include#define pb push_backusing namespace std;typedef long long ll;inline char nc(){ static char buf[100000],*p1=b

原标题 高三志开坑 2017.09.02 23:47 高三，还是记录一下吧。 DATE EVENT HINT 07.22 退役 07.25-07.27 CodeM Final，Beijing 点赞 08.04-08.18 Codechef August Long Challenge 2017 高三可能都不会这么认真的打比...

抱歉，退役了，Blog下的留言我可能不会回答了吧。UPD. 博客已搬 [雯舞 - Manchery's Space](manchery.co) ——2018.05.25

跟 51Nod 1356 代数数的次数 是一样的 不过这里都是质数 也就是就是 2n2^n 关键是输方案 这个不一定有二次剩余感谢sxt 一个一个数加进答案 转化成 已知F(x)F(x)，求F(x+a√)F(x+\sqrt a)和F(x−a√)F(x-\sqrt a)的系数 这个推一下就是一个FFT拷了myy的板子 自己的太慢了QAQ#include<cstdio>#include<cs

大意是把二元运算化成一元运算 感谢sxt的帮助剩下的看代码注释吧 //我觉得蛮清楚了 唯一不爽的是 没想到临时变量这么多 mmp#include<cstdio>#include<cstdlib>#include<algorithm>#include<vector>#define pb push_backusing namespace std;int B;struct abcd{ i

随便搞搞吧#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef long long ll;#define read(x) scanf("%d",&(x))const int maxn=200005;const int P=1e9+7;const int N=505;int n,a[N]

这是若干个 2xai+12x^{a_i}+1 的东西的卷积 然后这个FWT一下发现每一项只有 −1-1 或 33 那么卷积的FWT每一项就是若干个 −1-1 和 33 的乘积 这个不好求 直接加在一起FWT，那么我们得到了每一项 −1-1 和 33 的和 因为只有这两个取值，可以直接解方程有多少个 −1-1 和 33 然后快速幂再乘起来#include<cstdio>#include<

fi,jf_{i,j}表示长为 ii 的区间 最大值是jj 的答案 转移就枚举最左边的最大值在区间的位置 前缀和优化下就好了好像也可以fi,j,kf_{i,j,k}表示前 ii 个，末尾 KK 个中最大值在 jj ，最大值是 kk，有点复杂？#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typ

一个图的 kk 染色数是关于 kk 的 nn 次(?) 多项式 称为色多项式 那么这里模6 我们只要知道模2和模3的值 然后分类讨论下就好了 一张图的0染色数是0，1染色数等于[m=0][m=0]，2染色数与二分图的联通块个数有关#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#define

未经允许搬了过来代码略丑#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef long long ll;inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; return p1==p2&&(p2=(p1=buf)+f

请教了比利 首先 2n2^n 次项是没有问题的，比如2√+3√\sqrt2+\sqrt3，可以构造f(x)=(x+2√+3√)(x+2√−3√)(x−2√+3√)(x−2√−3√)f(x)=(x+\sqrt2+\sqrt3)(x+\sqrt2-\sqrt3)(x-\sqrt2+\sqrt3)(x-\sqrt2-\sqrt3) 这个不是最优解 最优解应该是构造这样一个矩阵 每一行代表一个质因子

本来想自己再推一下的，但是退役了也就弃坑了 未经允许的搬了搬题人的题解// BEGIN CUT HERE #include<conio.h>#include<sstream>// END CUT HERE #include<cstdio>#include<cstdlib>#include<cstring>#include<cmath>#include<iostream>#in

最小值的最大值小于等于最大值的最小值 那么只要有一行一列最小值等于最大值，那么矩阵就合法 如果我们枚举这一行和这一列，那么最小值最大值一定就是他们的交点 那么再枚举交点最后的值是多少 这样复杂度是O(n4)O(n^4) 换一下 先枚举值 再枚举位置 可以去一个代价最小值 O(n2logn)O(n^2\log n)#include<cstdio>#include<cstdlib>#in

这种非简单路 一般转化成任意一条路加上若干环 这里大概是任意一条路加上若干环长的gcd 任意一条路 可以弄出任意一颗生成树？ 但是这里实际上只需要一个带权并查集 详见官方题解#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef long long ll;typedef pair<

μ2(n)=∑d2|nμ(d)\mu^2(n)=\sum_{d^2|n} \mu(d) 然后就是xjb推 反正退役了 我也就弃坑了 95分代码 复杂度分析及优化详见官方题解#include<cstdio>#include<cstdlib>#include<cmath>#include<algorithm>using namespace std;typedef long long l

直接按照字典序类似逐位确定 先从后往前诸位确定确定答案和当前的LCP 然后在从前往后逐位确定 然后就转化为一个 某些不能选 某些必须选 某些随意 的独立集计数 链分治#include<cstdio>#include<cstdlib>#include<algorithm>#include<vector>#define pb push_backusing namespace std;

DP的转移是一个子集和的形式 直接做是3183^{18} 按照高9位 低9位分块可以做到29×39=692^9\times 3^9=6^9#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;#define read(x) scanf("%d",&(x))const int N=1<<18;cons

#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef pair<int,int> abcd;typedef long long ll;#define read(x) scanf("%d",&(x))const int P=1e9+7;inline ll Pow(ll a,int b){

这个题跟树状数组没有半毛钱关系 首先这是一个最低位翻倍的过程，如果这一位最终会变成 00 ，那么步数是 O(logn)O(\log n)的？ 要是这一位不能变成 00 ，也就是在环上跑了，似乎跑到环上的步数也是 O(logn)O(\log n)的？ 然后就变成了，修改要是跑到 00 就暴力跑，跑到环上，询问照样 设某个修改最早到环上的起点是w+z×kmw+z\times k^m，那么会对 w

两道类似的题 819D考虑一个人应该能够观察的位置 ti,(ti+S)modT,(ti+2S)modT⋯t_i,(t_i+S)\bmod T,(t_i+2S)\bmod T\cdots 这个应该是形成 gcd(S,T)\text{gcd}(S,T) 个环，每个环是长度 TgT\over g 然后把同一个环的一起处理，把点放到环上，那么沿环的方向到下一个点为止应该都是归到这个点答案里面的#inc

如果没有限制，显然根据排序不等式 当每个点最多有一个限制不能选的时候，有一个很重要的性质 性质:i对应的点与i的距离<=2 证明: 设有一种情况i对应i+3 i—–(i+3) i+1—(i+2) i+2—(i) i+3—(i+1) 那么,对于i,i+1来说,必定在(i–i+2),(i+1–i+3)中有一个限制必选,否则交换i,i+1更优 同理,(

可以转化成区间加，询问ai×ia_i\times i的最大值 这个不好维护，分块，零散的加，直接重构整块，否则在块上打标记 同时我们在块上还要维护当前最大值所在的 ii 和 接下来至少要整块加多少次才能使得最大值变化 每次在块上打标记，当达到临近就重构更新最大值，注意这个最大值随着全局加肯定是单调右移的，那么重构复杂度也是对的#include<cstdio>#include<cstdlib>

Magic Matrix把aa矩阵当成邻接矩阵，设bb为两点间路径最大值的最小值，那么ai,j≥bi,ja_{i,j}\ge b_{i,j}，然后ai,j≤max(ai,k1,ak1,k2,⋯,akm,j)a_{i,j}\le \text{max}(a_{i,k_1},a_{k_1,k_2},\cdots,a_{k_m,j})，所以ai,j≤bi,ja_{i,j}\le b_{i,j} 那么a=b

对于一个确定串ss，求不同子序列的个数有经典dpfi,si=∑jfi−1,jf_{i,s_i}=\sum_j f_{i-1,j}fi,j=fi−1,j,j≠sif_{i,j}=f_{i-1,j},j
eq s_i因为转移都是形式一样的我试着把所有串的fif_i都加起来，然后就发现FjF_j除了j=ϕj=\phi之外都是一样的，然后就记录两个量，然后就递推出来了#include<cstdio>

首先考虑如果要完成指定 kk 个课程，那么期望应该是 Fk=∑k−1i=01k−iF_{k}=\sum_{i=0}^{k-1} {1\over k-i} 令 ftf_t 表示 tt 时刻之前 要求未被完成的概率 令 pS,tp_S,t 表示 tt 时刻之前 位置集合 SS 未被完成的概率 然后瘦腿一发 E======∑t=0∞ft∑t=0∞∑S(−1)|S|(1−pS,t)∑t=0∞−∑

另解：四边形不等式优化考虑这个最优解关于段数是凸的，那么我们不限制段数，而是给每段一个额外的权值，随着这个权值单调变化，最优解的段数也会单调变化，二分出最优解是 mm 段就好了 这个的本质是二分出那个凸函数在 mm 上的斜率然后这个dp是满足决策单调性的 复杂度O(nlog2n)O(n\log ^2n)#include<cstdio>#include<cstdlib>#include<algo

首先肯定是一段模 dd 相同的数 然后枚举左端点 那么右端点应该满足条件 数字不重复出现且 maxvl,r−minvl,r≤r−l+kmaxv_{l,r}-minv_{l,r}\le r-l+k，这个最大最小值是除过 dd 的 也就是maxvl,r−minvl,r−r≤k−lmaxv_{l,r}-minv_{l,r}-r\le k-l 左端点边挪边用单调栈维护最大最小值 入栈出栈就线段树上区间

首先像我这种无脑的人可以大力上fft fin!=∑j=0i(−1)j(ij)(n+i−j)!n!{f_i \over n!}=\sum_{j=0}^i (-1)^j {i\choose j} {(n+i-j)!\over n!} 然而考虑经典错排的递推公式 dn=(n−1)(dn−1+dn−2)d_n=(n-1)(d_{n-1}+d_{n-2}) 这个东西的递推式是 把第nn个和n−1n-1

首先他保证图唯一确定，那么可以把图给构出来 类似这个题，按照出度从大到小排序，出度最大那个点怎么分配，类似无向图可图判定，应该是向出度小的点连，使得出度大的向他连，让出度大的出度减小// BEGIN CUT HERE #include<conio.h>#include<sstream>// END CUT HERE #include<cstdio>#include<cstdlib>

跟这个题一毛一样，那个题还高明一点，还会进位#include<cstdio>#include<cstdlib>#include<algorithm>#include<queue>#include<map>using namespace std;typedef unsigned int uint;typedef unsigned long long ull;inline char nc(

相当于每次每个点会变成自己和与自己相差一个二进制位的数的和 直接FWT 快速幂#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef long long ll;inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; r

题目大意： 这是一道通信题 第一个程序 输入一张无向图的点和边 再给一个2^60以内的数 第一个程序要给每个点赋值0/1 第二个程序也会读入这张图 然后读入当前点编号以及当前点的值，其他点的值一律不知，每次可以调用一个函数走向一个相邻的点，并得知这个点的值，120步以内得出只有第一个程序知道的那个数VIEW PROBLEM - AMUSEMENT PARK (JOI17_AMUSEMENT_P

题目大意：给出平面上n个带权点，有正有负，求平面上两条平行直线之间的点权和最大是多少 VIEW PROBLEM - BULLDOZER (JOI17_BULLDOZER)直接枚举斜率，点按照距离排序后是一个最大子段和问题 然后考虑扫描线旋转斜率，两个点相对关系变化只会发生在斜率与两点连线平行的情况，那么两点位置swap一下，更一般的如果是一段都满足这个，那么这一段要reverse一下 就是把两

题目大意：给出平面上n个不相交的矩形障碍，以及起点和终点，要求从起点走到终点的折线段段数最少 VIEW PROBLEM - GOLF (JOI17_GOLF)首先最优解肯定可以只在矩形边所在的直线以及过起点终点平行坐标轴的直线上移动 先预处理出矩形边界能够左右上下延伸的最远距离，转化成一些线段，可以扫描线加线段树 然后就直接bfs，关键操作是找出所有跟当前线段相交的且没被走过的线段，可以把线段

传送门问有多少个区间，出现过的数出现次数都是奇数 给每个数随机一个hash值 然后区间中所有数的xor和 和 所有pre<l≤i≤rpre< l \le i \le r的数的异或和 相同 那么就合法 枚举右端点，新增一个数会对一段造成影响 变成区间异或，区间是否存在一个数，分块维护#include<cstdio>#include<cstdlib>#include<algorithm>

这个东西链剖之后就是个裸的区间线性基，是可以暴力合并的O(log2n)O(\log ^2 n) 所以暴力线段树是 O(nlog4n)O(n\log ^4n) 改成ST表是 O(nlog3n)O(n\log ^3n) 而如果点分的话 应该是O(nlog2n)O(n\log ^2n)#include<cstdio>#include<cstdlib>#include<algorithm>#in

只能走补图的边 那么原图色的边不能走 那么我们容斥走了几条原图的边 这些边肯定是一些链 把链缩成一个点 那么不考虑其他不合法边用不用的情况下 贡献是 m的阶乘 m是缩完够的点数 然后 因为缩起来的点只可能是在同一个模板图中 那么对于最后总点数m的缩点方案数 是可以先处理出单个模板图的方案数 然后fft的 状压dp预处理模板图// BEGIN CUT HERE #include<c

首先根据可图性判定定理，可以发现任意一个和为2(n−1)2(n-1)的度数序列都存在方案，然后就是对于一个度数序列求生成树个数，根据Prufer推论，答案应该是 ∑{di}(n−2)!∏ni=1(di−1)!\sum_{\{ d_i\}} {(n-2)!\over \prod_{i=1}^n (d_i-1)!}这个直接做是O(n3)O(n^3)优化成O(n2)O(n^2)，参见大佬的题解// BEG

二分答案T之后转化成求最小费用 加超级源和超级汇 记每个植物生长的时间为xi,结束的时间为yi,减少的时间为di。 那么限制为 yi>=xi+ti-di, yi>=xi,xj>=yi, ys+T>=xt, 最小化sum di*ci然后直接对偶成费用流在目标函数中不存在的，把权值设为inf// BEGIN CUT HERE #include<conio.h>#include<sstream

好水的E题 f[i][j]表示删完[i,j]区间的最大收益 g[i][j] 表示把[i,j]删成a[i], a[i]+1, a[i]+2 …a[j]的最大收益 h[i][j]类似g[i][j]，递减 f[i][j] <- g[i][k]+h[k][j]+v[2*a[k]-a[i]-a[j]+1]#include<cstdio>#include<cstdlib>#i

翻译题解首先给出结论 把一段看做一堆石子 可以做到跟nim游戏等价具体 我们需要归纳证明一个结论 当前current_multiplier为 cc ，石子总数为 nn ，若异或和为 00 那么后手将以至少 n2c{n\over 2}c 的净得分获胜当游戏只剩最后两步的时候，两堆石子分别是n2n\over 2，那么后手会赢 n2c×2−n2c=n2c{n\over 2}c\times 2-{n\o

理解了有一会儿，但是题解确实说清楚了关键是只需要更新一遍#include<cstdio>#include<cstdlib>#include<algorithm>#include<vector>#include<queue>#define pb push_backusing namespace std;typedef pair<int,int> abcd;inline char nc()

根据最大似然估计，应该找出最大的 f(M)=(Mm)(N−Mn−m)(Nn)f(M)={{M\choose m}{N-M \choose n-m}\over {N\choose n}}我们手推下 f(M+1)≥f(M)f(M+1)\ge f(M)，得M≤(N+1)mn−1M\le {(N+1)m\over n}-1 那么答案是(N+1)mn{(N+1)m\over n}#include<cstd

好久没做过n=107n=10^7这种正常的递推题了二分图染色转化为棋盘模型，即 N×NN\times N 棋盘上放黑白棋子，每个格子至多放一个，同行同列没有相同颜色的棋子。 令bnb_n为只有一种颜色，那么bn=∑ni=0Cin×Pinb_n=\sum_{i=0}^n C_n^i\times P_n^i 然后我们考虑容斥掉两个颜色在同一格，如果一个格子既放黑又放白，那么这一列和这一行不会有其他棋

二分答案 然后每个子树维护二元组(a,b)(a,b)表示存在一个进入该子树后，第一天花费为aa，最后一天花费为bb，中间天都满足相邻叶子距离小于等于MidMid 直接转移状态数太多，我们发现对于一个aa只需要最小的b′b'，一个bb只需要最小的a′a'，可以two-pointers合并 那么新的状态数|S|≤2×min(|S1|,|S2|)|S|\le 2\times \text{min}(|

霍尔定理 有完美匹配必然有任意 |S|≤|N(S)||S|\le|N(S)| 那么这题答案就是max{S−|N(S)|}max\{ S-|N(S)|\}我们枚举N(S)N(S)，必然是x≤s∨x≥tx\le s \vee x\ge t的形式 那么对其有贡献的ii，满足Li≤s<t≤RiL_i\le s< t\le R_i 直接扫描线注意特殊讨论N(S)N(S)是全集的情况 这样的话不用满足Li

出烂了的原题，有可并堆的做法 然而昨晚翻原题的时候发现了精妙的做法看这里 令fi(x)f_i(x)为前ii个数，调整出最大值不超过xx的最小代价 那么fif_i是一条不升的折线 考虑转移 fi(x)=∑y≤xfi−1(y)+|ai−y|f_i(x)=\sum_{y\le x}f_{i-1}(y)+|a_i-y| 这实际上是两条折线合并一下 我们讨论两者的位置关系 实现的话只需要在堆中记下

参考这里 这是个经典问题，我们考虑记忆化搜索的过程，那么每次一个状态x，会产生新状态 ~x+1什么的，而这个状态数总数是O(logn)O(\log n)的 举个链接中的例子 1010110 –> 10110 –> 110 -> 10 0101010 –> 1010 所产生的所有串的数目刚好是x的位数减去末尾的0的数目那么我们就可以直接写一个记忆化搜索，然而这不优美 可以直接从低向上DP

我好菜啊 出过一万遍的原题 我怎么第一次看见啊 某乎链接 按照zyz的做法 orzzlcm(fS)==∏T⊆S,T≠∅gcd(fT)(−1)|T|+1∏T⊆S,T≠∅f(−1)|T|+1gcd{T}\begin{eqnarray}\text{lcm}(f_S)&=&\prod_{T\subseteq S,T
eq \emptyset }\text{gcd}(f_T)^{(-1)^{|T|+1

看fls的题解吧#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;const int N=1055;const int P=1e9+7;inline void add(int &x,int y){ x+=y; if (x>=P) x-=P;}#define read(x) scanf("%d"

#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef long long ll;inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; return p1==p2&&(p2=(p1=buf)+fread(buf,1,1

其实很久之前的东西了，可是最近一直懒得更，为了以后好查看还是更一下最近做一个OJ，系统栈有点小？ 然后在fls的教导下，自己YY用goto和define写出了奇怪的代码 自我感觉还很优美？就是这样一个函数inline void dfs(int u){ if (vst[u]) return; vst[u]=1; f[u]=abcd(u,u); while (1){ abcd p

从小到大枚举xx，剩下的限制是y>bi⋀z>ciy>b_i \bigwedge z>c_i或者y>bi⋁z>ciy>b_i \bigvee z>c_i 对应的是平面上一个矩形或者挖掉一个矩形 发现平面上矩形的交取个min就好了，挖掉的矩形要取并，这个可以用平衡树或线段树维护 大概是这样，我是灵魂画师 #include<cstdio>#include<cstdlib>#include<al

题解里给出了一种解偏微分方程得出生成函数的方法 最后应该是 H(z,x)=sinz+xcoszcosz−xsinzH(z,x)={\sin z+x \cos z \over \cos z−x\sin z} H(z)=sinzcosz=tanz=x+13x3+215x5+o(x5)H(z)={\sin z \over \cos z}=\tan z=x+{1\over 3}x^3+{2\over

这个题无话可说 fi,j,k,tf_{i,j,k,t}表示第 ii 位，AC自动机上走到 jj ，当前得分为 kk ，是否小于上界 tt ， 复杂度看着很高，其实跑不满？#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#define cl(x) memset(x,0,sizeof(x))using

这个题啊 分块 每块O(n√)O(\sqrt n) 把每个块内出现次数做一个前缀和，方便二分的时候O(1)查 然后整块加就打标记，两边零散的，变化不超过10，那么就直接在前缀和数组上修改下 复杂度大概是O(nn√logn+nn√×10)O(n\sqrt n\log n+n\sqrt n\times 10) 还有个问题是前缀和存不下？其实是存的下的，我们只要求从最小值开到最大值就好了，每次整块

拉格朗日乘数法 ACdreamers [Math & Algorithm] 拉格朗日乘数法首先那个能量肯定是要花完的，就变成一个限制了，乘上拉格朗日乘子，求偏导，变成了 2λkix2i(xi−vi)=12\lambda k_ix_i^2(x_i-v_i)=1 ∑kisi(xi−vi)2=E\sum k_is_i(x_i-v_i)^2=E发现 x≥vx\ge v 且 x2(x−v)x^2(x-v

第一眼觉得和一道题莫名相似，实际上并没有什么关系ft,i,jf_{t,i,j}表示从第 ii 个点，第 jj 扇门出发，走 tt 步所有情况的Hash值，那么很好转移一开始假设掉在房间中间，那我们按照顺序把所有点走过去一遍，取个最小表示，Hash在一起最后Hash值相同的就是等价了#include<cstdio>#include<cstdlib>#include<vector>#include

最大团这种数据范围，标算只有被随机艹的节奏了吧正解 抄自这里 我们穷举两个点，这两点距离要小于限制 然后我们分别以这两个点为圆心，两点距离为半径画圆 圆圆相交的部分被两点练成线段划分成两部分，不难发现 每个部分内点点之间的距离是小于限制的，很明显想到二分图 对于上半部分与下半部分的两点，如果距离大于限制则连边 然后我们求最大点独立集即可#include<cstdi

MLE最大似然估计可以通过观察数据来估计出随机的模型和参数 最大似然估计(Maximum likelihood estimation) Maximum likelihood estimation大概就是从所有可能的参数和模型中，选出概率最大的那一组模型，作为估计的模型和参数相关的还有一个最大后验估计(MAP)，我没看过然后就很好写了D#include<cstdio>#include<cstdl

那么问题来了 O(n)O(n)判到底对不对#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef double ld;struct P{ ld x,y; void read() { double _x,_y; scanf("%lf%lf",&_x,&_y); x=_x; y=_y;

本来的想法是能够找出叶子的兄弟 那么就把他们以及他们的父亲缩起来 但是很难找兄弟 看了题解发现是从初始一个点加点 相当于把缩的拆回去 通过点分治 我们找出当前树的重心 这里的重心是以叶子数量为权的 然后ask一下(g的左子树中的叶子，g的右子树中的叶子，当前要加的点) 有一些细节要处理 那么就可以确定当前点是在左子树 右子树还是子树外 询问复杂度O(nlogn)O(n\log n) 时

一个集合的 子集的和的平方 的和 就记一下 ∑a0i\sum a_i^0、∑a1i\sum a_i^1和∑a2i\sum a_i^2就好了 处理出 f(S)≥xf(S)\ge x的 这个就是一个6维前缀和 然后再把前缀和倒回去 就好了#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typede

ax≡b(modm)ax\equiv b \pmod m 有解就是 (a,m)|b(a,m) | b 也就是 (a,m)|(b,m)(a,m)|(b,m) 那么把数按照和mm的gcd的整除关系 建成DAG 跑一个最长链#include<cstdio>#include<cstdlib>#include<algorithm>#include<vector>#define pb push_bac

简直 在众人的帮助下理解了一个假题意 看完题解知道真题意 大概是每次加一个字符 这个串仍然要是Trie树的子串 直接建SAM 然后求SG值 不超过度数+1 也就是27 然后先手必胜 两边SG不同 那么按字典序数一数就好了#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#include<cass

垃圾数据结构题大概就是维护树上的点离最大承重还差多少 然后断掉的就是到根路径上最早的小于0的地方 断掉后 到根路径还剩的承重都要加上掉下的重量 就是一颗线段树满足区间加 区间求min鄙视CC强行可持久化 硬上主席树标记永久化#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#define cl(x)

这题有毒吧⌊ei⌋=⌊(e×10w)i10w⌋\lfloor ei\rfloor=\lfloor {(e\times 10^w)i \over 10^w}\rfloor然后只要ee的精度足够高 就可以当做整数类欧求 这里ww取80008000，40004000是不够的，纠结了好久，阿爷说会小数点后有进位进到个位from decimal import *import mathdef calc(a,b

对权值建主席树 然后对于区间[a,b],[c,d] 在主席树上二分排完序后从左第一个不一样的地方 以及从右第一个不一样的地方 这个可以Hash下权值的出现次数，也是可以相减的#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef unsigned long long ull;inlin

数据结构学傻 做做提答换换口味 最短路 case1 case3 卡掉floyd 101个点 没有边case2 case5 卡掉bellman 可以有重边 O(nm)O(nm)随便卡case4 case6 卡掉dij 这个dij没毛病？ 负边 可以卡成指数级盗图自 fjzzq2002 orz图染色 case7 卡掉搜索？ xjb随机就行了吧case8 放搜索过去？ 二分图case1

阿爷教导我 ∑∞i=0(Ai)∗(A+B−iA),A=x+y2,B=x−y2\sum _{i=0}^\infty \dbinom{A}{i}*\dbinom{A+B-i}{A},A={x+y\over 2},B={x-y\over2}然后就是数位dp+lucas定理的套路了 注意有减法要处理退位 一开始写的时候考虑的有点问题 调了很久很久 这个可以从低到高 也可以从高到低 因为意识模糊就

大概可以推出来转移是 fx=∑d|xμ(d)∑⌊P−1d⌋i=1gid=∑d|xμ(d)G(d)f_x=\sum_{d|x}\mu(d)\sum_{i=1}^{\lfloor {P-1\over d}\rfloor} g_{id}=\sum_{d|x}\mu(d)G(d) 转移是O(nlnn)O(n\ln n)的 然后就直接数位dp咯#include<cstdio>#include<cst

直接最短路就好了 第一次写竟然只拆了一个点 样例输出一坨0 QAQ 没有拿到FB 不开心#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#include<cmath>#include<queue>#include<vector>#define cl(x) memset(x,0,sizeof(x

裸的dfs随便剪剪就能跑出20多一点 这就启发我们直接上Dancing Link 列分别表示每个位置以及某个字符是否放了 行就枚举a-z和空格放在哪#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;const int N=205;const int M=200005;int ncnt;int

sro clrs97老师：”T1特别好写” orz 听说SPFA被卡了 /点蜡这个东西跑最短路，状态肯定不能指记录点，还要记录是哪条边走过来的，那干脆就直接记录边 把边变成点，把点变成连在边之间的边我是把一条边拆成两个点，中间设为边的费用 lcp的费用在点变成的边上，这个东西裸的连，在原图一个点上是O(deg2)O(deg ^2)的肯定炸 那么就建一颗虚树，然后枚举lca，把lca是这

我链分治是从immortalCO今年论文学来的 就是一个序列上能够维护的东西，把他搬到重链上，先处理好儿子重链的答案，然后把对这条重链上的影响累加在这条重链上然后就是套路 FWT一下就能加和乘了 注意0没有逆元复杂度O(mnlog2n)O(mn\log^2n) 实际上树链剖分是跑不满的 rank1 开心 O(∩_∩)O~~#include<cstdio>#include<cstdlib>#

首先解决依赖背包 如果是0/1背包，按照后序遍历dp，根据选或不选决策 现在是多重背包，那么这个点只留一个，剩下的变成一个新点挂上去，这样仍然满足依赖关系， 转移的时候多重背包用单调对列优化可以发现如果除了最长的一条链，剩余最多KK个 因为权值为正 那么最长链必然连到叶子，剩余必然取KK个（除非不足KK个） 那么我们枚举叶子 然后两边总共取出KK个，枚举两边分别选几个 两边需要两次儿子顺

给每条边的权值赋为编号 那么就相当于一个做kruskal的过程 也就是一个最小生成树的过程 跟BZOJ 2001 [Hnoi2010]City 城市建设一样？ 被阿爷教导了 多年前的模板又臭又长#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;typedef pair<int,int> abc

直接模拟下这个队列就好了 下一个处理的事件应该是第一个bi−i≤t−1b_i-i\le t-1的人 平衡树维护bi−ib_i-i#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#define cl(x) memset(x,0,sizeof(x))using namespace std;type

考虑sr xor si−1≤sr+1 xor si−1s_r\ \text{xor} \ s_{i-1}\le s_{r+1}\ \text{xor} \ s_{i-1} 相当于对si−1s_{i-1}第k位有一个限制 k是srs_{r}和sr+1s_{r+1}的LCP后一位然后就能很快算出每个点向右的答案 主席树一发#include<cstdio>#include<cstdlib>#i

判断两个可重集是否相同，给每个元素一个随机的 64 位无符号整数权值，然后全部加起来作为集合的 Hash 值。那么一个子串的 Hash 值可以简单地由前缀和作差得到，每次检验的复杂度为O(1)。其实只要一个观察 询问中不同的长度只有O(l√en)O(\sqrt len)种 map竟然T了 smg#include<cstdio>#include<cstdlib>#include<algorit

最大密度子图的建图 详见论文 这个东西是支持强制选的#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#define cl(x) memset(x,0,sizeof(x))using namespace std;typedef double ld;inline char nc(){ static

第52届IMO试题解答 #include<iostream>#include<algorithm>using namespace std;int main(){ long long l,r; cin>>l>>r; cout<<4<<endl<<max(r/11-l+1,0LL)+max(r/29-l+1,0LL); return 0;}

第一问玩玩你的吧 第二问直接杜教筛 S(n)=n∗(n+1)∗(2n+1)6−∑i=2ni∗S(⌊ni⌋)S(n)={n*(n+1)*(2n+1)\over 6}-\sum _{i=2}^n i*S(\lfloor{n\over i} \rfloor)#include<cstdio>#include<cstdlib>#include<cstring>#include<algorithm>

线段树 直接维护一段区间的答案 以及左右边界之间的连通性 然后合并的时候 根据中线并查集合并下 这么大常数竟然过了#include<cstdio>#include<cstdlib>#include<algorithm>using namespace std;inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; ret

我们把能够放在一个桶里的球连边 就是个最大匹配 这种图比较特殊 其实是比较老的模型了 在算法合集之《数据关系的简化》就有讲过一个连通块 必然能够达到⌊n2⌋\lfloor {n\over 2}\rfloor 这个上界 具体我们把一个连通块拎成一棵树 其中左儿子和自己同名 右儿子和自己同姓 我们每次必然能够找到一个点 他的儿子全是叶子 如果只有一个儿子 直接连不然 可以选择一个 把另一个

预先DP一遍则每个格子最多留一个球，然后对轮廓线的状态装压 如果定义一个点的状态数不超过SS 那么据题解说SS大概是5×1055\times 10^5 复杂度O(nmS)O(nmS) 接下来是卡常时刻 我先是把轮廓线上的球数转化成一个80进制数 然后和当前已经入袋的球数hash在一起 hashmap里面存一下 成功rnk1 开心#include<cstdio>#include<cstdl

记录f(i,j)是不是A/B的前缀，需要保留前m个dp值 其实就是轮廓线 复杂度O(nm∗4m)O(nm*4^{m})// BEGIN CUT HERE #include<conio.h>#include<sstream>// END CUT HERE #include<cstdio>#include<cstdlib>#include<cstring>#include<cmat

我们令fi,jf_{i,j}表示TiT_i和SjS_j的LCS 然后我们发现 fi,j−fi,j−1∈[0,1]f_{i,j}-f_{i,j-1} \in [0,1] 这个东西可以状压 预处理所有转移 然后DP#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>#define cl(x) memset(

我们在车的地方加一 在加油站减一 这样答案就是一个类似绝对值的区间和的东西 这个东西不好搞 分块 对于整块加减 我们在块上再维护一个表示0的指针 对于小块 暴力基数排序重构 复杂度O(nn√)O(n\sqrt n)#include<cstdio>#include<cstdlib>#include<algorithm>#include<cmath>#define pb push_bac

首先把一个区间翻转的最小代价肯定不是题目给出的那个代价 我们先跑一通floyd就能搞出来最小代价 然后呢 把所有奇偶性变化的位置 连成一个完全图 跑最小权完美匹配就好了 不会带花树 拷了个随机匹配的板子#include<bits/stdc++.h>using namespace std;typedef long long ll;namespace Work{ const ll OO=1

减掉所有只有小质数的数的个数就好了 大概就那么几千万个 首先包含大于根号b的质数只能有一个你可以直接算出来 然后再搜 怎么写都能三四秒出 然后你还要些剪枝 我是把大于三次根号b的质数瞎讨论一波 因为最多出现两个#include<cstdio>#include<cstdlib>#include<algorithm>#include<cmath>using namespace std;

大概是 ∑Cin∗2∗ik∗(ik−(n−i)k)modm\sum C_n^i*2*i^k*(i^k-(n-i)^k) \bmod m 后面那个东西模mm有循环节 同一组的组合数的和用lucas定理也能化成组合数乘上2的幂#include<cstdio>#include<cstdlib>#include<algorithm>#include<cstring>using namespace

详见lzz的集训队论文二进制分组做法二进制分组是在线段树的结构上做的 方便区间查询 至于删除 采用延迟重构的思想 每一层只有最后一个区间是萎的 我们需要递归下去 询问还是O(logn)O(\log n)个节点 重构复杂度势能分析下O(nlogn)O(n\log n) 只有上凸包是有效的 合并的时候采用归并加Graham可以做到O(n)O(n) 不然以我的常数 T的血惨 但是卡内存 只有90分#

详见吉丽的集训队论文吧我们发现修改操作可以变为这样一个形式S:x=max(x+A,B)S:x=max(x+A,B) 这个标记是可以合并的 就可以求当前值了 现在还要历史最值 我们就再加一个标记SSSS表示历史最大的标记 因为这个形式是一条折线 所以历史最大也是可以合并的 具体的我们两段时间有两对标记S,SSS,SS和s,sss,ss 时间先后分别对应pushdown时的父亲儿子关系 我们发现

我们用fif_i表示左边界是ii的答案 一条线段[a,b][a,b]对答案的影响是 f1f_1到flf_l中大于等于aa的都跟bb取max 这个可以用线段树科技做 复杂度证明跟区间最值操作的势能分析应该差不多#include<cstdio>#include<cstdlib>#include<algorithm>#include<cassert>using namespace std;inl