青烟绕指柔的博客

题目链接：HDU - 6085考虑每个数字 a % b == k，其实就是 ( a - k ) % b == 0，然后考虑使用bitset通过右移来维护。直接用bitset做位运算与。但是这样错过了一些数的因子，所以我们对于每个因子对因子的倍数来做贡献。我们枚举余数，从大到小维护一个bitset即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define i

题目链接：HDU - 4747每次枚举右端点，加入一个数字，维护每个位置的mex，显然很复杂。所以我们考虑每次删除一个左端点，维护前缀mex。考虑当前位置的影响，会影响到后面大于 a[i] 的mex，会变成 a[i] ，直到下一个 a[i] ，所以线段树维护区间修改即可，因为答案是单调递增的，所以线段树区间赋值即可，不用segment beats。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/

题目链接：HDU - 5172对每个排列集合哈希即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e6+10,mod=1e18;mt19937 rnd(time(0));int n,m,a[N],h[N],sum[N],p[N];void solve()

题目链接：HDU - 4386婆罗摩笈多公式：我们可以发现，当后面 cos = 0 时为最值。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;double a[10],p; int ts;void solve(){ for(int i=1;i<=4;i++) cin>

题目链接：HDU - 4705正难则反。考虑总方案减去为一条链的方案。这样我们枚举一条链中间的点即可。然后另外两个点从不同子树中选取，或者从父亲选一个。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e5+10;int n,sz[N],s;vector&l

题目链接：HDU - 4700显然如果原图合法，那么我们可以构建成一个树。即两点之间的所有边权最小值为两点之间的流量。即最大生成树。建完树之后check一下两点之间的最小值是否合法即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=110;int n,g

题目链接：HDU - 5919维护区间不同数字的个数，并且贡献为前面的那个数字，所以我们可以做一个后缀主席树。然后我们求出区间的数字个数，然后就能找到第(k+1)/2个数字了。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=2e5+10,M=N*40;int

题目链接：HDU - 6873我们可以发现，每次推的时候，只会有2列发生变化。也就是后面往前移动，前面的一块贡献给最前面小于y的块，然后后面增加一个高度为y-1的块。用平衡树维护区间插入+删除即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;typedef long long

题目链接：HDU - 6486每次n-1个数减去1，可以看成一个数字+1。那么操作次数计算就很简单了。但是怎么判断合法性呢？最优操作肯定是每次都操作最大的数字。如果最大的数字 <= 次数，那么就是不合法的。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=

题目链接：HDU - 5102本来想直接二分+点分治的。但是因为K很小，所以我们可以直接拓展。先用一条边，然后由一条边拓展到两条。因为我们是单向拓展的，所以有些会拓展不到，所以我们对一条边弄两个方向，最后除以2即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int

题目链接：HDU - 5215对于奇环来说，直接二分图染色即可。对于偶环来说，我们先DCC缩点。然后对于一个DCC来说，如果点数为偶数那么必然存在一个偶环。如果点数为奇数，如果边数不为点数，那么证明有多个环嵌套，如果是两个奇环那么一定可以抵消成偶环。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespac

题目链接：HDU - 5200对询问离线，然后按照顺序加点，维护联通块个数即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=5e4+10;int n,m,f[N],res[N],vis[N],ans;struct node{int id,x,f;}t[N

题目链接：HDU - 5398显然这个东西是可以预处理的。然后我们依次加点，显然每个点只会和因子匹配最优。然后用LCT维护最大生成树即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=2e6+10;int n,idx,w[N],f[N]; long lo

题目链接：HDU - 5325显然，我们从权值小的连向权值大的。那么答案就是每个点能到的点数。取max。只有这样，一个联通块才是合法的。保证一定是小的在中间。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=5e5+10;int n,w[N],dp[N],re

题目链接：HDU - 5317因为一个数不同的素因子不超过logn个，所以答案不会很大。我们枚举每个答案 i ，如果合法，那么就是这个区间的 i 的倍数个数大于1这个东西可以前缀和预处理。并且我们可以算出答案上界为7AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int

题目链接：HDU - 5383从两端向中间构造最短路径树。然后强制到每个点的距离。最后输出方案的时候，如果是在最短路径树上面的边直接用两点之间的差值输出。否则输出n。注意构建最短路径树的时候，每个点必须是能由已经构造完成的点转移而来。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;

题目链接：HDU - 5418状态dp，dp[i][s]为当前在 i 点，然后经过的状态为 s 的最短路。然后Dijkstra即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=17;int n,m,g[N][N],dp[N][1<<N],vis

题目链接：HDU - 5410因为B为正，所以我们可以将一个物品拆成两个，一个价值为a+b的单一物品，一个价值为a的完全物品。然后两次背包即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=2e3+10;int n,m,w[N],a[N],b[N],dp[

题目链接：HDU - 5969我们可以发现，任意区间的最优解肯定是有一个最大值来限制的。我们枚举每个值作为最大值的时候，然后更新每个长度的区间即可。因为数据是随机的，所以每次跑的区间不会很长。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e5+10;int

题目链接：HDU - 5699显然可以二分时间，然后我们就只关注距离大于mid的任务即可。我们可以发现 |l-x| + |r-y| <= mid化简可以达到：r-l-mid <= y-x <= mid+r-ll+r-mid <= x+y <= l+r+midAC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int l

题目链接：HDU - 5669区间之间连边用线段树或者倍增优化即可。然后k次机会可以建立分层图，或者直接dp。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=5e5+10,M=4e6+10;int n,m,k,d[N][15],vis[N][15],res,

题目链接：HDU - 5468有莫比乌斯反演我们可以得到，与某个数互质的数的公式：count[d]为d的倍数的个数。然后我们维护每个数倍数出现的次数即可，然后因为我们要知道子树当中的个数，每次递归的时候先记录递归这颗子树之前的个数，然后做减法。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace

题目链接：HDU - 5452因为树上只能割一条边，显然这条边割完之后，连接这条边两端的边必须全部割掉，我们维护每条边的答案即可。用树上差分维护。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=2e4+10;int n,m,pos[N],bl[N],sz[N]

题目链接：HDU - 5441显然可以按照边权离线，然后用并查集维护联通块的size即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10;int n,m,Q,f[N],sz[N],res[N],now;struct node{int u,v,w

题目链接：HDU - 5617从两个起点开始，往中间走，如果下一步都相同才能走。然后 dp[k][i][j] 来表示，走了 k 步， 当前第一个人的横坐标为 i ，第二个人的横坐标为 j 的方案数。然后第一维可以压缩一下。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const

题目链接：HDU - 5607首先设置一个答案矩阵，最初为走0步的时候，然后构造一个转移矩阵。做k次矩阵乘法即可。怎么构造转移矩阵：每个点都是由上一个点转移而来，上一个点转移到的概率为出度分之1。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=55,M=1e3+

题目链接：HDU - 4909考虑如果没 ‘?’ 我们怎么计算，因为我们只需要知道奇偶信息，我们对每个点开一个前缀状态奇偶压缩，如果和之前某一个状态相等，那么证明做减法之后也是相等的。现在多了一个 ‘?’ ，我们枚举表示的字母即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;co

题目链接：HDU - 4858因为边很少，我们可以把非树边单独判断。然后每个点相邻的点，其实就是一个BFS序。最后把非树边单独求一下。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10;int n,st[N],ed[N],dfn[N],m,f[N]

题目链接：HDU - 5637因为每次都是异或操作，所以从S->T，等价于异或的：0->S^T。所以我们从0开始跑BFS即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=20,mod=1e9+7;int n,a[N],m,d[1<<

题目链接：HDU - 5495其实就是每一列可以重排，然后问LCS。我们可以发现，把 b 看成 a 的置换，那么每个环的贡献都是环的大小 - 1 。特判环为1，贡献为1。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10;int vis[N],a[

题目链接：HDU - 5638考虑最小字典序，显然可以贪心求。对于每次的点来说，看是否可以删边使得更小的点入队。然后我们可以发现，对于拓扑排序来说，删边的实质就是使得某个点的入度减1。然后我们可以用线段树维护每个点的入度，然后每次可以取出一个最小的，入度满足小于等于k的点，看是否通过操作使其入队。维护最小字典序的队列，我们换成优先队列即可。注意细节，不要让一个点重复入队。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#incl

题目链接：HDU - 5900显然可以区间dp，dp[i][j] 为区间 [ i , j ] 的最大值。然后我们就可以枚举两个区间的组合，或者是枚举当前区间的两个端点组合，但是要保证中间是可以合并的。用dp数组的值判断即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const in

题目链接：HDU - 5898显然我们可以数位dp，然后每一位的状态只和当前位的奇偶性，当前是否合法，当前奇偶数的个数的奇偶性。注意前导零的影响。然后转移即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=22;int dp[N][3][3][2],a[N],

题目链接：HDU - 5883答案显然就是任意一个欧拉通路。首先考虑连通性。然后我们可以分度为奇数的个数，大于2显然无解。如果为0，那么任意选一个起点。如果为2，那么则是一定是路径。然后对每个点看贡献，看度除以2的奇偶性即可，因为出去一次进来一次，特判起点。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing na

题目链接：HDU - 6290对判断是否能走，我们可以发现等级越低，越能过去。然后判断消费：假设每次经过的边的等级提升值分别为：a1,a2,a3…ak我们可以发现代价为：log2(1+a1+a2+a3+…+ak)，也是等级越低越优，所以我们对等级跑最短路即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing name

题目链接：HDU - 6252可以发现，给出的信息其实就是几个点之间的大小关系，建差分约束系统即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=2e4+10,M=N*10;int n,m,x,d[N],cnt[N],ts,vis[N];int head[N]

题目链接：HDU - 6156数位dp即可，每次转移的时候记录每个字符串的长度，以及当前选了的位数。如果选了未超过一半，那么都可以选，否则只能选之前选的对称位的值。注意处理前导零。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=90;int dp[N][N][

题目链接：HDU - 6446考虑每条边的使用次数。显然只有1-2,2-3,3-4这样穿过才是合法的，一共有 n-1 对。然后我们可以从子树当中选一个位置，和非子树的选一个位置，然后其他的随便放。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e5+10,mo

题目链接：HDU - 6447显然可以dp,dp[i][j]=max(dp[i-1][j],dp[i][j-1],dp[i-1][j-1]+v)然后这个东西可以用数据结构优化。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10,M=N*40,up=1

题目链接：HDU - 6098我们枚举每个数字，然后找到他的倍数，这个过程是一个调和级数，所以我们只需要知道每个区间的max即可。用ST表预处理。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10;int n,a[N],f[N][20];inli