fxt275307894a的博客

题面传送门不小心抢了个最优解，比第二少了0.6s0.6s0.6s分块+根号分治套路题。看到这种跳着加的就知道是根号分治了。对于x>sx>sx>s的直接加，用分块维护。对于x<sx<sx<s的，维护数组fi,jf_{i,j}fi,j​表示跳iii个，从jjj开始加了几次。为了之后统计方便，还要前缀和。统计时，一部分是分块直接统计。另一部分可以在fi,jf_{i,j}fi,j​上算，考虑整块和零散的情况。直接统计前缀和即可。关于sss我取80左右，实测跑得飞快

题面传送门首先有一个结论就是不存在二次变换。如果存在二次变换，那么二次变换那个点的至少一个方向会新出现一个点，但是要新出现一个点那个方向必定原来就存在一个点。所以不成立。那么就可以从上到下做扫描线，当碰到一列最上面的点时给树状数组那个位置加一，最下面减一就好了。代码实现:#include<cstdio>#include<vector>#include<cstring>#include<algorithm>#define max(a,b) ((

题面传送门这道题暴力dp是很好想的。就是分别从上一天，最晚可转移的天，凭空买来转移。因为有状态自然叠加所以只要转移最晚可转移的天就好了。然后会发现这个是可以正反两边单调队列优化的。复杂度O(TP)O(TP)O(TP)代码实现:#include<cstdio>#include<cstring>#define max(a,b) ((a)>(b)?(a):(b))using namespace std;int n,m,w,x,y,z,f[2039][2039],

题面传送门一不小心抢了最优解。首先跑出111到所有点的最短路，因为那个梗在先，所以用堆优化dj然后这道题显然要让我们求最小瓶颈路之类的东西。所以就可以建出克鲁斯卡尔重构树。在树上倍增。同时处理子树内距离最小值。倍增到的那个点的值就是答案了。代码实现:#include<cstdio>#include<queue>#include<algorithm>#include<cstring>#define min(a,b) ((a)<(b)?

题面传送门考虑暴力建分层图dp实际上就是对于每个时间建到下一层的图就好了。然后停留就是自环，爆炸就连向永远走不出来的点。其实这个东西是可以矩乘优化的。然后复杂度就降到O(logtn3)O(logtn^3)O(logtn3)代码实现:#include<cstdio>#define mod 2017using namespace std;int n,m,k,x,y,z,t,anss;struct jz{ long long f[139][139]; jz operator

题面传送门一道套路题。考虑把图分解成链与环。然后我们会发现其实路径就是一条链加上一堆环。因为从链走到环的路径会被异或两次为000所以就直接上线性基就好了。代码实现:#include<cstdio>using namespace std;int n,m,k,x,y,flag[100039];long long p[10039],z,ans,d[100039];struct yyy{int to;long long w;int z;};struct ljb{ int hea

题面传送门首先用两颗线段树维护每个点所在的亮灯联通块。然后再建一颗二维线段树，每个点表示到当前为止，有多少个时刻能从iii到jjj。对于每次修改，依靠两颗线段树维护的区间，来修改。这里有一个小技巧，在修改时加上q−tq-tq−t，修改时减去，就是答案，还能累加。查询就查当前点就好了。代码实现:#include<cstdio>using namespace std;int n,m,k,x,y,z,tot,root[300039],a[300039];char s;struct

题面传送门可以算一道线段树维护hash的模板题了吧。hash要满足两个条件:相同的数hash值一定一样与hash冲突尽量少。这道题hash序列可以用幂次方来hash然后用线段树随便维护一下就好了。代码实现:#include<cstdio>#include<algorithm>#define max(a,b) ((a)>(b)?(a):(b))#define min(a,b) ((a)<(b)?(a):(b))using namespace std;i

题面传送门数据太大了，所以要hash。多取几个模数正确性更高。代码实现:#include<cstdio>#define mod 1000000007using namespace std;int x,y,z,n,m,k,head,ans[100039],fff;long long tot,a[100039],now;char _s;int main(){// freopen("1.in","r",stdin); register int i,j; scanf("%d%d

题面传送门你会发现这道题和LNOI2014某题很像。但是那个kkk次方很难处理。考虑k=1k=1k=1的情况，就是那道题。照样差分，但是这次差分不是那么差，而是每个点的权值改成dik−(di−1)kd_i^k-(d_i-1)^kdik​−(di​−1)k这东西就可以实现了。因为加到一个点时这个点到根节点的路径都会被加。而这个值又恰好等于深度的kkk次方。那么把原来的线段树改成带权的就好了。代码实现:#include<cstdio>#include<cstring>

题面传送门一道典型的树剖题目。这东西如果暴力肯定是没法算的。除非能转化一下，比如算贡献。然后会发现HHHOJ上有一道题和这个很像。这样的话可以把每个点向上算贡献，一直加111到根节点。这样当一个点加到时那么就自然算到了贡献。其实质是差分，只不过没那么明显罢了。这个东西可以用树剖+线段树维护。但是这道题是区间查询。如果每次暴力加进去只有O(mnlog2n)O(mnlog^2n)O(mnlog2n)的复杂度，比那个O(nmlogn)O(nmlogn)O(nmlogn)的暴力还劣。首先这个区间肯

题面传送门首先你可以把所有直径求出来然后暴力。但是这道题可以把求树的直径的方法。首先求出一条直径，把直径上的所有点点权减一。然后再求一遍，两次相减就是答案。正确性显然。代码实现:#include<cstdio>#include<cstring>#define max(a,b) ((a)>(b)?(a):(b))#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y,z,t

题面传送门启发式合并大法好!你会发现这道题可以暴力合并。然而数据稍微用心一点就卡掉了。然后你可以试图优化一下，比如合并时把小的合并到大的上面去。结果就过了。这样复杂度上界是O(nlogn)O(nlogn)O(nlogn)，具体证明在这篇题解里有。代码实现:#include<cstdio>#include<cstring>int n,m,k,x,y,z,a[100039],siz[1000039],ans,cur,fa[1000039];struct yyy{in

题面传送门题目要求有多少个i，ji，ji，j使的l≤∑k=ijai≤rl\leq \sum\limits_{k=i}^{j}{a_i}\leq rl≤k=i∑j​ai​≤r用前缀和搞一下，变成l≤qj−qi−1≤rl\leq q_j-q_{i-1}\leq rl≤qj​−qi−1​≤r再变换一下，变成qj−r≤qi−1≤qj−lq_j-r\leq q_{i-1}\leq q_j-lqj​−r≤qi−1​≤qj​−l然后动态开点线段树或者平衡树一搞就好了。代码实现:#include<cstd

题面传送门显然是树剖题目，关键是怎么维护不同宗教。对于每个宗教可以开一棵线段树，但是空间会爆。所以可以动态开点。代码实现:#include<cstdio>#include<cstring>#define max(a,b) ((a)>(b)?(a):(b))using namespace std;int n,m,k,x,y,z,tot,root[100039],top[100039],d[100039],fa[100039],idea,id[100039],si

题面传送门一道二分图的题目。考虑将菜向客人，客人向房间连权值为111的边，但是这样会有重复计算。所以将客人拆成两个点，两点之间连权值为111的边，就可以达到限制流量的目的。代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y,z,st,t,nows,cur,no

题面传送门月赛中的简单题。考虑将原数列以能量排序，那么肯定是前一半匹配后一半最优。而匹配时优先取被覆盖次数最大的即可判断无解。但是有一种特殊情况，就是前一半全部指向一个点。那么把这个点特殊处理掉然后正常做即可。代码实现:#include<cstdio>#include<queue>#include<algorithm>#include<cstring>using namespace std;int n,m,k,x,y,z,in[1000

题面传送门月赛中的简单题。考虑推一波式子。设g=gcd(bi,bj)g=gcd(b_i,b_j)g=gcd(bi​,bj​)那么原式就是bi+bj+g=bi×bjgb_i+b_j+g=\frac{b_i\times b_j}{g}bi​+bj​+g=gbi​×bj​​big+bjg+1=big×bjg\frac{b_i}{g}+\frac{b_j}{g}+1=\frac{b_i}{g}\times \frac{b_j}{g}gbi​​+gbj​​+1=gbi​​×gbj​​换元，设x=big,y

题面传送门一道圆方树的板子题。对于每个点先让它连到环顶。那么他到环顶的距离就是从两边走的最小值。那么求两点间距离就可以考虑倍增了。但是最后要考虑特殊情况代码实现:#include<cstdio>#include<cstring>#define abs(x) ((x)>0?(x):-(x))#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,xs,y,z,fa[10039][

题面传送门一眼就是二分图，但是考虑怎么建边。如果暴力匹配O(nmtlogw)O(nmtlogw)O(nmtlogw)肯定会TTT飞。卡片上的数的阈值范围很小，可以考虑欧拉筛一趟然后分解质因数。分解质因数后对于每个质数开一个邻接表，然后对于每一个建边。建边复杂度就变成了O(tnlogw)O(tnlogw)O(tnlogw)代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,

题面传送门考虑暴力dpdpdp:设dpidp_idpi​表示以iii结尾的分组方案数，qi=∑j=1iaiq_i=\sum\limits_{j=1}^{i}a_iqi​=j=1∑i​ai​那么dpi=∑j=1i−1dpj[qi−qj≥0]+[qi≥0]dp_i=\sum\limits_{j=1}^{i-1}{dp_j[q_i-q_j\geq0]}+[q_i\geq0]dpi​=j=1∑i−1​dpj​[qi​−qj​≥0]+[qi​≥0]然后发现这个是一个二维偏序板子。就可以树状数组优化了。代码实现

题面传送门这是一道基环树直径的题目。考虑对于一个基环树，只有两种情况:直径在环上，直径在半个环上与链上。直径在环上直接搞就好了，另一种情况可以单调队列优化dp代码实现:#include<cstdio>#include<cstring>#define max(a,b) ((a)>(b)?(a):(b))using namespace std;int n,m,k,x,y,z,st,flag[1000039],flag2[1000039],q[2000039],he

题面传送门仔细阅读题面可知，只有在这个循环矩阵内有连续kkk个斜着的111,那么就可以覆盖。所以这题可以分成两部分:预处理哪些区间可以被覆盖和处理覆盖的最小区间。处理覆盖的最小区间显然可以单调队列优化dp，设fif_ifi​为覆盖到第iii个且最后一个矩阵右端点在iii处的最小覆盖数量。那么可得状态转移方程为fi=max⁡j=max⁡(0,i−m)j<ifj+1[pi]f_i=\max\limits_{j=\max(0,i-m)}^{j<i}f_j+1[p_i]fi​=j=max(0,i−

题面传送门动态开点线段树水水就过了。指针版更好写。代码实现:#include<cstdio>using namespace std;int n,m,k,x,y,z,tot=1;struct tree{int l,r,f,sum;}t[15000039];inline void push(int l,int r,int now){ int m=(l+r)>>1; if(!t[now].l) t[now].l=++tot; if(!t[now].r) t[now].

题面传送门显然基环树dp对于每个联通块找到环然后强制选和不选累计答案即可。代码实现:#include<cstdio>#include<cstring>#include<queue>#define max(a,b) ((a)>(b)?(a):(b))using namespace std;int n,m,k,x,y,a[1000039],b[1000039],in[1000039],flag[1000039],root;long long dp[1

题面传送门很毒瘤的一道大模拟。首先贪心让军队走到最上面的点，如果能走到根节点就停留在根节点下面。然后查看哪几颗子树没有被封死。对于有军队的根节点，让能走回来的军队出去调动，反之让其停留在当前节点。然后就是细节。代码实现:#include<cstdio>#include<cstring>#include<queue>#include<algorithm>#include<vector>using namespace std;

题面传送门线段树离散或者动态开点都可过。动态开点线段树只要排个序然后区间覆盖即可。代码实现:#include<cstdio>#include<algorithm>#include<cstring>using namespace std;int n,k,tot=1;struct yyy{int x,y;int z;}s[40039];struct tree{int l,r,f,siz;long long sum;}t[800039];inline bo

题面传送门这东西有一个更优的复杂度。显然可以二分，二分以后对每一维尺取后算是O(nwlogw)O(nwlogw)O(nwlogw)的，可以过去。但是我们发现在第二维尺取时的这一维www很没有必要，换句话说，很没效率。所以就可以用一棵权值线段树代替掉，对每一个点向后midmidmid个贡献权值。查询时查询最大值即可。代码实现:#include<cstdio>#include<cstring>#include<algorithm>#define max(a,

题面传送门直接跑二分图最大匹配即可。关于输出方案看哪条边没有权值就输出两个端点即可。代码实现:#include<cstring>#include<cstdio>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y,z,nows,cur,now[1039],d[1039],st,t,ans;struct yyy{int to,w,z;}t

题面传送门显然对列数奇偶性染色然后建边跑二分图即可。注意无法放置点可能重复。代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,h,x,y,z,st,t,a[239][239],flag[239][239],now[100039],nows,cur,d[100039],an

题面传送门显然是二分图建模板子题。观察可得，可以黑白染色建图。那么从黑格向白格建边跑二分图最小点覆盖即可，注意要用全部点减去最小点覆盖。代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y,z,st,t,a[239][239],flag[239][239],no

题面传送门数据这么小，一看就可以floydfloydfloydfloydfloydfloyd外层循环就是允许点转移，那么题目中依次给出允许点转移顺序，那么直接可以做了。代码实现:#include<cstdio>#include<cstring>#include<algorithm>#define max(a,b) ((a)>(b)?(a):(b))#define min(a,b) ((a)<(b)?(a):(b))using namespac

题面传送门一道二分图建模的好题。题目中要求最少覆盖，很容易想到最小点覆盖，也想到了二分图。把横竖模板铺出来，可以贪心，一定是延展到最长最优。那么把图建出来后跑最小点覆盖即可，可以得出最小点覆盖等于最大匹配数。代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y

题面传送门对于左部点建超级原，右部点建超级汇，边权为111跑dicnicdicnicdicnic即可，这样超级原控制了每个点只能走一次。代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y,z,now[10039],d[10039],nows,cur,st,t,an

题面传送门直接上dicnicdicnicdicnic板子即可，注意加几个剪枝，跑得飞快。代码实现:#include<cstdio>#include<cstring>#include<queue>#define min(a,b) ((a)<(b)?(a):(b))using namespace std;int n,m,k,x,y,z,d[1039],now[1039],st,t,nows,cur;long long ans;struct yyy{i

题面传送门先两遍dfsdfsdfs跑出树的直径。因为所有树的直径都是相类似的，所以只要跑一条直径就好了。然后在这条直径上尺取。最后对于直径上每个点的子树不经过直径上的边求距离取最大值即可，这一步很难想，因为如果不取最大值那么就会漏掉答案因为无论如何都是要有这条边的权值的。完美O(n)O(n)O(n)代码实现:#include<cstdio>#include<cstring>#define max(a,b) ((a)>(b)?(a):(b))#define m

题面传送门题目要求kkk个连接关键点的边权之和的二倍。那么ans=dist(a1,a2)+dist(a2,a3)+...+dist(ak−1,ak)ans=dist(a_1,a_2)+dist(a_2,a_3)+...+dist(a_{k-1},a_k)ans=dist(a1​,a2​)+dist(a2​,a3​)+...+dist(ak−1​,ak​)那么加入或删除一个点时对左右两边拆边建边即可。维护左右两边可以用平衡树维护，这里写了一个非递归式权值线段树维护。时间复杂度O(nlogn)O(nl

题面传送门感觉就像一道裸题。转化成前缀和然后建边即可。注意前缀和特性:qi>qi−1&&q−qi−1≤1q_i>q_{i-1}\&\&q_-q_{i-1}\leq1qi​>qi−1​&&q−​qi−1​≤1所以按照这个建边就好了。代码实现:#include<cstdio>#include<cstring>#include<queue>#define max(a,b) ((a)>(b)

题面传送门空间这么小，只能莫队。在移动时用域值分块O(1)O(1)O(1)修改即可。代码实现:#include<cstdio>#include<cmath>#include<algorithm>using namespace std;int n,m,k,x,y,z,ans[1000039],a[100039],l,r,mid,f[100039],ku[100039],st[100039];struct yyy{int x,y,a,b,num;}fs[100

题面传送门如果k=1k=1k=1显然非常简单，取树的直径即可。考虑k=2k=2k=2怎么做。第一条显然要取树的直径。而第二条如果围成的环和第一条围成的环有重叠，那么重叠的边要走两次。所以我们可以把这几条重叠的边权值设为−1-1−1，然后再跑一遍树的直径。代码实现:#include<cstdio>#include<cstring>#include<algorithm>#define max(a,b) ((a)>(b)?(a):(b))using n