poursoul

【牛客网】2017年浙江工业大学大学生程序设计迎新赛热身赛 F题 方块 I时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 131072K，其他语言262144K 64bit IO Format: %lld 题目描述 有 N 个方块排成一排，每个方块都染有颜色，第 i 个的颜色为 Ci，一共有三种颜色，分别为红，黄，蓝，现在你可以对相邻的颜色不同的方块进行施法，使其变成第三

题目链接：【codeforces】741E. Arpa’s abnormal DNA and Mehrdad’s deep interest观察两个插入位置对他们rank的影响，可以发现，可以拆成求5段lcp，因此我们在将两个串拼接后求一个后缀数组，然后就可以直接对所有插入位置求出他们的rank了。然后询问可以根据k分块，这题就做完了。 就是需要写一会儿。#include <bits/stdc++

题目链接：【codeforces】678 F. Lena and Queries#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define getid( l , r ) l + r | ( l != r )const int MAXN = 30

题目链接：【UVALive】7502 Suffixes and Palindromes根据回文半径数组能得出一堆不等相等关系，相等缩点，不等建边。 根据sa数组的对偶数组rank数组的性质，考虑sa[i]和sa[i-1]，如果如果rank[sa[i]+1]>rank[sa[i-1]+1]则s[sa[i]]可以等于s[sa[i-1]]；如果rank[sa[i]+1]>rank[sa[i-1]+1]则

题目链接：【HDU】5994 Generator and Monitor看懂题就会做系列，模板题。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 200005 ;const int

#include <bits/stdc++.h>using namespace std ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 3505 ;const int MAXE = 100005 ;const int INF = 0x3f3f3f3f ;struct Edge { int v , c ,

题目链接：【codeforces】739D. Recover a functional graph其实就是一个匹配问题，先枚举最大的那些”x ?”放在哪个环上，那么接下来哪些地方是一定要填的都已经知道了，还没有填的地方我们就用匹配来实现。构造方案比较简单，肯定是链只从同样大小的环中随便选一个，然后再选一个点连出来，然后确定最长的树链，剩下的深度为ii的就指向深度为i−1i-1的树链上的点即可，深度0

题目链接： 【hrbust】2298 Diamond枚举斜率算贡献。n2lognn^2\log n预处理，O(1)O(1)查询。PS：一开始写了n2lognn^2\log n每组，然后TLETLE了，思考了一下发现可以先预处理，然后每组O(N)O(N)，结果又TLETLE了……然后再思考了一下发现可以O(1)O(1)询问，就是代码量瞬间长了一些……总体来说还是比较简单的……#include <bit

题目链接：【topcoder】SRM696 div1 550 Clicounting最大团可以n2nn2^n搞，然后对这个可以做高维前缀最大值。就可以得到以某个状态的子集构成的最大团的大小。然后显而易见可以折半爆搜，然后瞎几把搞就好了。#include <bits/stdc++.h>using namespace std ;#define clr( a , x ) memset ( a , x ,

题目链接：【玲珑杯】1048 - Best substringwa了一辈子，最后发现是利用归并排序后的退栈策略错了。应该是判栈顶和当前元素的关系，然而我偷懒只判了相邻两个元素的关系，gg。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , s

题目链接：【codeforces】660F. Bear and Bowling 4考虑对序列分治，然后可以发现，以左半部分每个下标为x，右边则可以表示成kx+bkx+b的形式，因此可以对右边的直线维护一个下凸壳。 复杂度O(nlog2n)O(nlog^2n)，如果用归并排序代替快排，可以做到O(nlogn)O(nlogn)#include <stdio.h>#include <string.h>

题目链接：【PA】PA2014Final Wykładzina均摊分析可知复杂度O(N2)O(N^2)#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;typedef unsigned long long ULL ;#define clr( a ,

题目链接：【codeforces】730F. Ber Patiodp[i][j]dp[i][j]表示买了前ii件物品，另外得到了jj个代币所用的最小现金数。买第i+1i+1件前还剩多少代币可用总代币-买了前ii件另外获得的代币（即dp[i][j]dp[i][j]的jj）-买前ii件要花多少钱（即∑ik=1ak\sum_{k=1}^{i}a_k）+买前ii件用了多少现金（即dp[i][j]dp[i][

题目链接：【51nod】1302 矩形面积交因为最后可以旋转，所以每一组的矩形一定是短边对短边，长边对长边。 考虑短边最短的一定在AA组，然后我们将其余的矩形按照长边排序，枚举在BB组的最短长边，逐个将矩形插入优先队列，然后优先队列中个数大于NN时，取出短边最短的加入AA，然后同时维护两组矩形的面积即可。 因为此时相当于固定了AA组的短边（最小只可能是一开始孤立出来的矩形），AA组的长边以及BB

题目大意：给一棵NN个节点的树，你可以选择任意一个点作为根然后树链剖分（树链剖分的定义：如果这个点不是叶子，则其中恰好一条边为重边，其余均为轻边），剖分的方式由你定。然后接下来有MM对(u,v)(u,v)，定义(u,v)(u,v)为树上节点uu到节点vv的最短路径。现在你要确定一个剖分方案，使得所有对(u,v)(u,v)经过的轻边个数之和最小，经过多次算多次。输出个数之和。N,M∈[1,1e5]N,

题目链接：【BZOJ】3992 [SDOI2015]序列统计 利用原根的性质，对下标做变换，使得乘法变成加法，然后就有卷积性质了。n很大我们就在外面套一层快速幂即可。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;typedef unsigne

题目链接：【codeforces】gym 101137 E - Economy Printing对值排序，会发现只有最后两个元素有用，枚举他们是被压缩在哪种类型，接在哪个数后面，dp即可。#include <bits/stdc++.h>using namespace std ;typedef pair < int , int > pii ;#define clr( a , x ) memset (

题目链接：K - Knights of the Old Republic考虑对图集合dp，一个连通块的dp值为两个连通块的值的和或者强制加一条新边后的最小值，取个最小值（边从小到大枚举，则强制加一条最大的边会导致连通块内较小的边一定都选，则会构成一个生成树）。用kruskal实现这个dp过程即可。#include <bits/stdc++.h>using namespace std ;typede

题目链接：【HDU】5958 New Signal Decomposition在此先感谢小q对我的指导，没有q老师的帮助，估计永远也做不出来了。首先我们考虑对这个式子做离散对数。令gg为pp的某个原根，则有： bi=∑p−1j=0aj⋅r(i,j)\quad b_i=\sum_{j=0}^{p-1}a_j\cdot r(i,j) bi=∑p−1j=0aj⋅2sin32πi⋅jp\quad b_i

题目链接：【HDU】5436 Transmigration tree#pragma comment(linker, "/STACK:16777216")#include <stdio.h>#include <string.h>#include <vector>#include <algorithm>using namespace std ;typedef long long LL ;#de

题目链接：【HDU】5420 Victor and Proposition#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;const int MAXM = 40000

题目链接：【HDU】5426 Rikka with Game#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;const int MAXE = 200005 ;con

题目链接：【HDU】5574 Colorful Tree#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005

题目链接：tree#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 30005 ;const int MAXE = 60005 ;struct Edge { int v , c

题目链接：Clarke and room#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define ls ( o << 1 )#define lson ls , l , m#define rs ( o << 1 | 1 )#define rson rs , m + 1 , r#define rt 1

今早看到的题，想了下会做了，但是觉得这题挺有意思的，于是打算写一下做法。本题利用了gcd的基本性质：更相减损法以及结合律，平时做gcd的题基本没用到过这两性质，而本题对这性质进行了充分利用。思路： 首先我们考虑给一个序列，我们该怎么做。 令f[i]=a[1]+a[2]+…+a[i]。 我们考虑序列的一个k+1划分f[x1]，f[x2]-f[x1]，f[x3]-f[x2]，…，f[n]-f[xk

题目链接：K. The World of Trains记录一个横着的前缀dp和以及斜着的前缀dp，复杂度O(n2)O(n^2)#include <bits/stdc++.h>using namespace std ;typedef pair < int , int > pii ;typedef long long LL ;#define clr( a , x ) memset ( a , x ,

题目链接：A1228. 飞飞侠#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 155 ;const LL INF = 1e18 ;struct Node { LL dis ;

题目链接：Remmarguts’ Datek短路模板题，用这题验证了我可持久化左偏树的正确性。#include <stdio.h>#include <vector>#include <queue>#include <algorithm>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;ty

题目链接：Subsequence吐槽，先是对着定义yy了可持久化二项堆，然后发现不好搞这个k短路，然后找了左偏树的定义，对着yy了20分钟写出了可持久化左偏树，然后过了poj2449后就1A了这个题。#include <stdio.h>#include <vector>#include <queue>#include <algorithm>using namespace std ;typed

namespace Binomial_Heap { struct Node { int c[2] , x ; LL val ; } T[MAXN * 200] ; struct Heap { int n ; pii rt[BLOCK] ; Heap () : n ( 0 ) {}

题目链接：Query on a graph水题#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;typedef unsigned long long ULL ;#define clr( a , x ) memset ( a , x , sizeof

题目链接：Metal Processing Plantbitset优化kosaraju，复杂度O(n^2/64)，总复杂度O(n^4/64)。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;typedef unsigned long long U

题目链接：卡常大水题#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;typedef unsigned int UI ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN =

题目链接：oasis in desert#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 505 ;const int

题目链接：Black White Tree枚举子树，对于一个a，其对应的可行b一定是一个连续区间。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )con

题目链接：Walk Around The Campsite要知道多边形的边只会在端点相交。则如果以一个点为原点，作射线，然后旋转，那么遇到边的左端点我们往set插入线段，遇到边的右端点我们删除线段，那么任意时刻在set中的线段和射线的交点到原点的距离的大小关系是相对不变的。那么我们就可以通过动态维护set的操作符’<’动态维护线段距离原点的远近了。 接下来就很简单了，枚举原点，然后极角排序，然后转

题目链接： 新年的繁荣#include <bits/stdc++.h>using namespace std ;typedef pair < int , int > pii ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;struct Seg {

题目链接：Ice Walls#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < double , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 1005 ;const doubl

题目链接：【51nod】1291 Farmer去年做的题，一直没有放出来，单调栈，O(N^2)。O(N^2logN)也能过。#include <bits/stdc++.h>using namespace std ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 1005 ;char s[MAXN] ;int U[M

题目链接：Yong Zheng’s Death#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 300005 ;int nxt[MAXN][26] ;int word[MAXN] ;

题目链接：Just A Mistake考虑先枚举根，求根必选的排列数，这样可以算出根对答案的贡献。然后，设dp[i][j]表示以i为根的子树，i排在第j位且i必选的方案数。考虑子树v，如果v的位置在i的前面，那么v必须不选，那么我们把他减掉；如果v的位置在i后面，那样在我们选了i以后自然不会选v。然后就是对两个排列求并的方案数，这个和【HDU】5789 Permutation一个道理，都是枚举一个排

题目链接：merge#include <stdio.h>#include <string.h>#include <set>#include <algorithm>using namespace std ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 300005 ;set < int > s[MAXN] ;

题目链接：Call It What You Want暴力枚举经过的顺序，然后起点终点在一个子树的做个dp即可。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;cons

题目链接：Glorious Brilliance#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 505 ;const int MAXE = 2000005 ;const int I

题目链接：Join The Future并查集压缩相等的点，发现最多只会有20个大于1的联通块，状压dp即可#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 42 ;const int

题目链接：Memento Mori#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 2005 ;struct Node { int x , y ; Node () {}

题目链接：Eades#include <stdio.h>#include <string.h>#include <math.h>#include <vector>#include <algorithm>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x

题目链接：Product Bo思想很好，挺有趣的题，在床上突然会做的。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN =

题目链接：Gardener Bo分情况处理add操作即可。#include <stdio.h>#include <string.h>#include <math.h>#include <vector>#include <algorithm>using namespace std ;typedef unsigned int UI ;typedef pair < int , int > pi

题目链接：Filling轮廓线dp出整个的，一半的，1/4的，然后用burnside引理去重。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x ) memset ( a , x , sizeof a )const

题目链接：Turn Gamedp套dp。逐行dp，枚举每一行的状态，向下转移。状态即每一列上是否有列覆盖住这一行。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef vector < int > vi ;typedef map < LL , int > mpvi ;#define clr( a ,

题目链接：Interval#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 80005 ;const int mod = 1e9 + 7 ;vector < int > fac[MAX

题目链接：Permutation#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef vector < int > vi ;typedef map < LL , int > mpvi ;#define clr( a , x ) memset ( a , x , sizeof a )const int

题目链接：Magic Number看懂题目，就知道怎么做#include <stdio.h>#include <vector>#include <string.h>#include <algorithm>using namespace std ;typedef long long LL ;typedef pair < int , int > pii ;#define clr( a , x

题目链接：Robots旋转45度坐标系，x’=x+y,y’=x-y，然后横纵坐标变成独立问题，接下来dp。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 205 ;const int

题目链接：Captain is coding二分Z用了多少次，然后枚举deadline小的用了多少Z，再优先队列模拟#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 1005 ;stru

题目链接：Square Revolution题意：求串s有多少个子串满足不存在形式为AA的前缀或后缀（其中A是一个字符串）。本质是求以某个点为起点或者终点的最短AA串的长度。求出这东西以后就可以询问离线+扫描线树状数组搞搞了。求最短AA串怎么求呢，我们枚举A的长度k，然后看i和i+k的lcp（最长公共前缀）和lcs（最长公共后缀）是否加起来大于等于k，是的话用他们更新一下被影响的每个点的信息（即以他

题目链接：Advanced Traffic System建线段树，每个线段树节点存下包含这个区间的加边的信息。然后第一次取所有包含起点的加边区间，然后将这些信息标记为删除（以后遇到就删掉，保证复杂度），然后加上他们的边权，丢进优先队列里。然后从优先队列里取出最小的一个加边信息，将矩阵里所有的点去更新，更新方法和用起点更新的方法是一样的。考虑到每次枚举矩形内所有的点肯定复杂度不对，而且因为每个点只会被

题目链接：Birthday Gift首先，最优解一定是一个凸包，但是接下来的算法不会显性利用到凸包的性质。 枚举每个点作为多边形最左侧的端点（然后删除他左侧的点，否则可能会错，我就因为这个问题错了好几发，虽然不知道什么情况，删了保证对），然后以这个点做极角排序，接下来dp[i][j]表示多边形上上个极角序最大的点是i，内部包含了j个点的最小周长，然后枚举下一个点就可以做到n^3转移（三角形内点的个

题目链接：GCD首先以每个点作为右端点的相同区间gcd的左端点构成一个区间，则这些区间最多只有log个。nlogn暴力预处理出每个gcd值的个数。 考虑修改第i个点值对所有gcd值的影响，影响的gcd值肯定是包含i的区间。把所有以i为右端点的gcd值区间取出来，i为左端点的也取出来，取的方法用线段树上二分（比较简单，就不细说了），然后左边和右边最多各logn个，所以logn*logn暴力更新就好了

题目链接：Backpack on Tree每层，对价值除以花费的斜率从大到小排序，然后贪心到恰好大于询问的容量t，接下来开始dp。 设dp[i][j]表示贪心到第i个物品，取出里面花费为j的最小价值。dp2[i][j]表示斜率从小到大（即从右到左）取出花费为j的最大代价。 假设现在贪心得到的价值为t2（因为最大花费为5，所以t2-t<5），然后我枚举从贪心的解里面丢掉花费为x的最小价值dp[i]

题目链接：D. Captain America上下界最小流模板题，离散化建图跑即可。By No.baka, contest: Codeforces Round #366 (Div. 1), problem: (D) Captain America, Accepted, # #include <bits/stdc++.h>using namespace std ;#define clr( a ,

题目链接：D. Andrew and Chemistry树同构模板题，同构的儿子选一个走就好。#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;const int MA

题目链接：1043 - G. Quailty and Square Counter首先，x向x^2%2017建边，跑一跑找找规律，能发现环套树一共有14个，每个的环最大6，且在环上的点一共64个，且不在环上的点到环的常数最多5。知道这样的性质后，就简单了，区间平方直接暴力，区间赋值直接搞，暴力的话到某个区间为相同数时停止。其实上面都不是重点，大家都会，卡常才是最重要的，我从本地43s卡到11.6s，

时间复杂度O(NN−−√)O(N\sqrt N) 空间复杂度O(N)O(N)my   code:my~~~code:#include <bits/stdc++.h>using namespace std ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;const int MAXQ = 10000

传送门：【ZOJ】3942 Substring Counting赛场上写了两个多小时没有过，回来后过了好久才肯补。结果写了4个多小时，还写了trie来对拍，调到电脑没电还没调好，第二天终于找到最后一个细节错，艰难的AC了。各种漏细节，没救了。（希哥说他这题定义是简单题，mdzz！）总之就分三种情况模拟，两边是00，两边是11，两边是01或10（01或10只要reverse下数组就能用同一种方法计算

传送门：【FZU】Problem 2217 Taximy   code:my~~~code:///*#include <stdio.h>#include <string.h>#include <algorithm>//*///#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a

传送门：【Codeforces】280D k-Maximum Subsequence Sumkey word：取反my  code:my~~code:#include <stdio.h>#include <string.h>#include <vector>#include <algorithm>using namespace std ;typedef long long LL ;#defi

由Ak=A[0](w3kn)+wkn⋅A[1](w3kn)+w2kn⋅A[2](w3kn)A_{k}=A^{[0]}(w_n^{3k})+w_n^{k}\cdot A^{[1]}(w_n^{3k})+w_n^{2k}\cdot A^{[2]}(w_n^{3k}) 得yk=y[0]k+wkn⋅y[1]k+w2kn⋅y[2]ky_{k}=y_{k}^{[0]}+w_n^{k}\cdot y_{k}^{

传送门：【BZOJ】4130: [PA2011]Kangaroos【KD树】题意：给出一个长度为N(N≤5⋅104)N(N\leq 5\cdot 10^4)的区间序列。然后接下来M(M≤2⋅105)M(M\leq 2\cdot 10^5)个询问，每个询问给出一个区间[L,R][L,R]，问区间序列中最长的连续子序列长度，使得连续子序列中每个区间和询问给出的区间存在交集。分析：将询问[L,R][L,R

传送门：【BZOJ】4154: [Ipsc2015]Generating Synergy分析：以dfs序和深度为关键字，作为平面点，于是对于每个询问就是在平面上的矩形区域修改以及查询。my   code:my~~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x )

传送门：【BZOJ】3616: War【KD树】分析：建好树，对于每个塔，对他能打到的点打标记，这个用KD树+bitset打标记即可。所有标记打完后把标记下传，这样可以得到每个点在每一轮会被哪些塔打到，然后我们把所有同一阵营的或（位运算）起来，这样就知道每个阵营每一轮有多少的概率是完全完好的，然后pow一下累加到ans里，最后输出ans即可。复杂度O(NN−−√+N232)O(N\sqrt N +

传送门：【HDU】2966 In case of failure【KD树】题意：给平面图上N(1≤N≤105)N(1\leq N \leq 10^5)个点，对每个点，找到其他 欧几里德距离 离他最近的点，输出他们之间的距离。保证没有重点。这是本弱学习KDKD树做的第一题。本题做法网上很多，我就不详细说了。KDKD树在算法竞赛中主要用来做各种各样的平面区域查询，包含则累加直接返回，相交则继续递归，相离

传送门：【HDU】5470 Typewritermy  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ;const int N = 26

传送门：【HDU】5421 Victor and String能维护左右最长回文的前提是要知道除了上一个节点表示的最长回文串能更新出新的本质不同的回文串外，其他节点都做不到（比赛的时候就是这个性质没想清楚，然后想了个O(N2)O(N^2)的做法……），这个可以YY一下，想清楚了就简单了，分别维护左右last指针，然后用一棵回文树实现这个过程，具体过程我就不多说了。my  code:my~~code:

传送门：【HDU】5390 tree操作记得离线到每个线段树节点中，否则在线做，空间可能爆炸……my  code:my~~code:#pragma comment(linker, "/STACK:16777216")#include <stdio.h>#include <string.h>#include <stdlib.h>#include <vector>#include <algor

传送门：【HDU】5383 Yu-Gi-Oh!my  code:my~~code:#include <stdio.h>#include <string.h>#include <vector>#include <algorithm>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , s

传送门：【HDU】5370 Tree Makermy  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 505 ;const int mod = 1e9

传送门： 【HDU】5367 diggermy  code:my~~code:#include <stdio.h>#include <string.h>#include <algorithm>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int M

传送门：【HDU】5362 Just A String这题整整想了我两天= =终于搞出来了。 一开始写出O(N3)O(N^3)的dp，转化一下，可以搞出一个生成函数，然后展开生成函数可以发现系数是二项式，然后对于枚举的长度i取出第i项就可以了。有个优化是发现奇数长度的回文串和偶数长度的回文串的贡献是一样的，所以不需要特殊处理奇数了。my  code:my~~code:#include <bits/

传送门：【HDU】5343 MZL’s Circle Zhou对于a串可能和b串重复的部分，我们总能找到一个位置，使得a串达到最长，即a串的后继为空，所以我们只要预处理以字符x为开头的b串的个数即可。my  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a

传送门：【codechef】 Prime Distance On Tree点分治+FFT水题……竟然n*n爆int没发现…… 而且NTT TLE，FFT跑的超级快……my  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a

传送门：【51nod】算法马拉松4 F 移数字涉及知识点：多项式求逆，多项式除法，多点插值，阶乘取模。对于N!%P，复杂度为O(N−−√log2N−−√)O(\sqrt N \log^2\sqrt N)。 但常数巨大，和暴力算实际复杂度只相差常数= = 这个是可以扩展到组合数取模的~my  code:my~~code:#include <stdio.h>#include <string.h>

传送门：【HDU】5333 Undirected Graphmy  code:my~~code:#pragma comment(linker, "/STACK:1024000000")#include <stdio.h>#include <string.h>#include <map>#include <algorithm>using namespace std ;typedef long

传送门：【ZOJ】3881 From the ABC conjecture复杂度大概O(N0.67)O(N^{0.67})，我也不会算www，首先转换一下（我们是根据积性函数打表找规律得到的，也可以推出来）使得： g(N)=∏pi ϵ N(pia+1)g(N)=\prod_{pi~\epsilon ~N} (pi^a+1) 暴力展开发现贡献为： h(N)=∑x=1N∑y=1N(x⋅y≤N an

传送门： 【HDU】5321 Beautiful Setmy  code:my~~code:#include <stdio.h>#include <string.h>#include <vector>#include <algorithm>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a ,

传送门：【HDU】5320 Fan Limy  code:my~~code:#include <stdio.h>#include <string.h>#include <vector>#include <algorithm>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , size

传送门：【ZOJ】3889 Making Sequence根据题意构造即可。ZOJ月赛我们抢的第二个FBwwwmy  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef unsigned long long ULL ;const int MAXN = 205 ;ULL n , a , b , s , t ;ULL

传送门：【ZOJ】3886 Nico NumberYY方法出只有2的幂次和素数是等差的，打表验证发现只有6是反例，注意到0项也是等差，所以0和1也算。每个数最多logn次取模，所以区间更新暴力到叶子就行。ZOJ月赛的时候抢了这题的FB ^_^my  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long lon

传送门：【HDU】5314 Happy King算法分析： 点分治，子树去重类可做。对于一个重心，取出所有路径按照最大值排序，扫下最小值，插入到线段树里维护个数，双指针扫扫解决。然后对所有重心的儿子对应的子树再做一次去重。这个方法我是今早在床上想了下想到的。 我是动态树，动态树比较裸，对点权排序，然后双指针扫扫，接下来就是链接两棵子树或者拆分两棵子树时的子树的siz。子树siz可以用两个变量维护

传送门：【HDU】5313 Bipartite Graph复杂度：O(NN√logN32)O(\frac{N\sqrt{N}\log{N}}{32}) 方法：多重背包bitset优化my  code:my~~code:#include <stdio.h>#include <string.h>#include <bitset>#include <algorithm>using namespa

传送门：【HDU】5309 JRY is Fightingmy  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;const int MAXN = 500005 ;int a[MAXN] ;int R[MAXN] ;int d[MAXN] ;int nxt[MAXN] ;int

传送门：【HDU】5307 He is FlyingPS：神奇的姿势可以用double或long double过（FFT），我是过不了my  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr(a,x) memset ( a , x , sizeof a )cons

传送门：【HDU】5304 Eastest Magical Day Seep Group’s Summermy  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN

传送门：【HDU】 5302 Connect the Graphmy  code:my~~code:#include <bits/stdc++.h>using namespace std ;typedef long long LL ;typedef unsigned long long ULL ;const int MAXN = 10005 ;int y[MAXN][2] ;void solve

传送门：【HDU】5298 Solid Geometry Homeworkmy  code:my~~code:#include <stdio.h>typedef long long LL ;struct Node { LL x , y , z , d ;} a[100] , b[10] ;int n , m , p , q ;LL f ( LL x ) { return ( LL

传送门：【HDU】5296 Annoying problem这题我是分类讨论做的，没想到多校题解的方法my  code:my~~code:#include <stdio.h>#include <string.h>#include <algorithm>using namespace std ;typedef long long LL ;#define clr(a,x) memset ( a ,

传送门：【HDU】5293 Tree chain problemmy  code:my~~code:/************************************************************************* > File Name: F.cpp > Author: poursoul > Created Time: 2015年07月22

传送门：【HDU】5291 Candy Distributionmy  code:my~~code:/************************************************************************* > File Name: D.cpp > Author: poursoul > Created Time: 2015年07月22