2020年07月_青烟绕指柔!

原创 Codeforces - Captain Flint and Treasure

题目链接：Codeforces - Captain Flint and Treasure如果不是输出路径的话，显然就是DAG上面dp。现在需要输出路径，我们就要知道选的先后顺序。然后每个点就看之前的点贡献的正负，确定先后顺序，然后又是一个拓扑排序了。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace

2020-07-31 23:11:30 260

原创 HDU - 6437

题目链接：HDU - 6437其他博客中基本上都是O(n+m*m)复杂度的连边。但是其实可以优化到O(n+m)我们对每种种类，分别看成两层图，然后第一种是第一类的，第二层是第二类的。如果选择某个节目，那么看完之后连向本身的下一个点则 -W 的费用，否则连向另一层点为 0 的费用。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long lon

2020-07-31 21:39:38 244

原创 HDU - 6495

题目链接：HDU - 6495显然只能dp做，而且dp的状态也很好找的。dp[i][j]为前 i 个选 j 个剩下的最大血量。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e3+10;int n,m,a[N],b[N],c[N],dp[N][N],res;

2020-07-31 19:15:18 211

原创 HDU - 6415

题目链接：HDU - 6415我们假设是从大到小放，那么我们可以发现当前放的时候，必须在已经放过的一行或者一列放。那么就成了一个dp问题了，dp[i][j][k]前 i 个数字，已经放了 j 行，k 列的方案数。因为每个数只和之和前一个数字有关，所以可以空间优化。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing

2020-07-31 13:50:38 197

原创 HDU - 6406

题目链接：HDU - 6406预处理出从起点开始，到每个点的个数，以及每个点作为起点到终点的个数。然后对于当前的点，分段考虑即可。预处理的时候可以用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,mx[N][20],m

2020-07-30 23:47:51 240

原创 HDU - 6394

题目链接：HDU - 6394每个点和向上跳能到的点连边构成一棵树，然后建立一个跳出去的虚拟节点。那么能跳到的点就是虚拟节点和当前点 split 一条链之后的size-1.AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10;struct LCT{

2020-07-30 23:02:08 245

原创 HDU - 6315

题目链接：HDU - 6315因为每次只会增加1，然后b是一个排列。考虑用线段树暴力维护当前可以更新的叶子节点，我们可以看做是 b 每次减1，减到0就答案增加1，然后把b变回去。极端情况的复杂度：每次更新的叶子节点数是和之前的操作数有关的，所以复杂度是正确的。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing na

2020-07-30 10:32:12 289

原创 HDU - 6701

题目链接：HDU - 6701我们可以分治最大值，然后启发式计算答案。但是对于当前枚举的数字，我们先用最大值和K算出当前的极限端点位置，然后算出这个点之前最远能到的位置。这个都可以预处理。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=3e5+10;int

2020-07-29 23:05:39 229

原创 HDU - 6681

题目链接： HDU - 6681显然这是一个平面图，我们可以根据欧拉公式：V - E + F = 2假设射线之间交点个数为x，有n条线段。那么V = 4 + x + 2*n , E = 4 + 2*x + 2*n所以：F = 2 + E - V = x + 1所以我们维护交点个数即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define in

2020-07-29 21:45:43 243

原创可重集

题目链接：可重集显然这种题就是用各种hash去做的。如果是判断一个区间是否完全相等，我们可以给每个值换一个随机值，然后区间异或哈希。但是现在是差分相等，如果是区间异或的话，做加法很困难。所以我们可以考虑用次幂哈希。例如：5 = base ^ 5这个就很好做加法了。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusin

2020-07-29 16:13:26 630

原创 HDU - 6638

题目链接：HDU - 6638枚举x的范围，然后对y做一个区间最大连续子段和即可。但是要注意处理相同x的情况。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=2e3+10;typedef long long LL;int n,m; LL res;stru

2020-07-29 11:43:58 303

原创 HDU - 6635

题目链接：HDU - 6635随机下，LIS长度的期望为 sqrt(n) ，那么我们考虑时光回溯，先求出一个LIS，然后如果当前删除的位置不在LIS上面，那么直接删掉即可，否则重新求LIS。复杂度为：O(nsqrt(n)*log(n))，因为删除位置在LIS上面的期望为sqrt(n)。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long l

2020-07-29 11:03:35 249

原创 HDU - 6606

题目链接：HDU - 6606显然可以二分。然后二分之后，我们就可以dp了，dp[i]=max{dp[j]+1},保证j+1到i的和小于等于mid即可。然后这个显然是区间max，可以用线段树优化，这道题很恶心，卡空间了，所以我们必须离散化。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace st

2020-07-29 00:13:33 340

原创 HDU - 6583

题目链接：HDU - 6583显然可以dp, dp[i] 为以 i 结尾的最小花费。dp[i]=min(dp[i-1]+p,dp[j]+q)保证 str(j+1，i) 为 str(1,j) 的子串即可。显然这个花费是单调递增的。由子串的性质可以证明。所以我们枚举的时候，可以用尺取 + SAM 求出可以转移的最远的 j 。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h&gt

2020-07-28 11:34:43 281

原创 HDU - 6409

题目链接：HDU - 6409假设一次都不能选一对兄弟。那么我们肯定是贪心，对每个节点选最大的权值的儿子，现在可以选一对兄弟，那么我们选一个最优的次大值加上即可。最小值同理。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e5+10,inf=0x3f3f3f3

2020-07-27 23:10:52 198

原创 HDU - 6586

题目链接：HDU - 6586看见字符串最小字典序，显然可以想到贪心。我们依次对每一位从小到大枚举，如果当前合法就可以放。怎么判断合法性呢？我们放这个字符之后需要保证，后面的位置可以满足放需要放的个数，以及后面的位置不能超过最多还能放的位置，以及当前枚举到的位置后面还有这个字符，以及这个字符不能超过R[i]个。所以我们可以用后缀和+序列自动机预处理。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bit

2020-07-27 21:33:07 174

原创 HDU - 6540

题目链接：HDU - 6540树形dp，dp[x][i] 为距离节点 x 的最大关键节点距离为 i 的方案数。我们先算不选当前节点的方案数。对于儿子节点，直接组合即可。然后再考虑一个儿子单独和根组合。然后如果这个节点是关键节点，那么我们就让小于等于k的方案数 * 2 即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longu

2020-07-27 10:01:07 290

原创 HDU - 6695

题目链接：HDU - 6695我们先按照x排序，然后依次枚举最大的x是多少。我们可以发现，x 之前的随意选取都是对 x 的最大值无影响的，然后当前的最优解可以是，后面未选择的最大的 y 和当前 x 的差值，如果 y 小于当前的 x ，那么可以从 x 之前的找一个接近的 y 。这个用multiset维护即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define

2020-07-26 22:42:26 201

原创 HDU - 6789

题目链接：HDU - 6789直接枚举死亡的两个人即可。然后dp[i][j]为第一个人剩的血量为 i 第二个为 j 的最小次数。然后枚举转移即可。代码比赛的时候过了，然后HDU上面卡常。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;int dp[1010][1010],n=10

2020-07-26 20:15:58 210

原创 HDU - 6787

题目链接：HDU - 6787dp方程很显然，然后可以发现最多连续10个传送门。但是要注意无法到达的情况。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e3+10,mod=1e9+7;int n,m,dp[N][N][12]; bool vis[N][N

2020-07-26 19:20:12 213

原创 Alice收集玩偶

题目链接：Alice收集玩偶显然可以三分小猫玩偶的数量，然后check。但是要注意用double去check，因为会产生小数，用整数check会有误差，。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;int A,B,x11,y11,x2,y2,res;inline double ch

2020-07-26 16:33:53 154

原创相邻的糖果

题目链接：相邻的糖果显然根据贪心，每次减去右边的值一定是最优的。然后暴力减的复杂度就是对的，因为区间是固定的，所以每个数字只会被减一次。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e6+10;int n,m,s,now,a[N],res;signed m

2020-07-26 13:16:56 159

原创黑妹的游戏II

题目链接：黑妹的游戏II设dp[i][j]为当前点到终点，自己减去对手能得到的最大值。当前在(i,j)最后，就该对手走了，对手肯定是选择一个最小值转移。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=510;int n,m,dp[N][N],a[N][N];

2020-07-26 11:22:14 176

原创黑妹的游戏III

题目链接：黑妹的游戏III不难发现，每次除以因子，可以等价于除以质因子。然后我们对每个质因子单独看也是不影响的。然后就变成质因子最多可以抵消多少次了。假设某个质因子总数为sum，最大值为mx，那么如果mx*2<=sum，则会剩下1或者0个（奇偶）。不然就是mx*2-sum个。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long

2020-07-26 10:33:25 334 2

原创 HDU - 6464

题目链接：HDU - 6464维护每个数字的个数，以及区间和。对于每次查询，我们可以在线段树上二分到需要的区间，然后注意一下端点不一定会取完。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,mod=1e9+7;int n,num[M]

2020-07-25 22:02:35 204

原创弹钢琴

题目链接：弹钢琴对音高排序之后，不难发现是一个最大权值的LIS问题。线段树即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e6+10;int n,mx[N<<2],m;struct node{int a,b,c;}t[N];vector&l

2020-07-25 19:13:01 130

原创 HDU - 6769

题目链接：HDU - 6769考虑二分。然后dp[i][j]为当前到节点 i，选了 j 个权值A的边的到 i 节点能达到的最长的最短链长。然后初始化为INF，只要任意组合可以满足加起来小于mid，那么我们就可以更新当前节点的 dp 值。最后只需要看dp[1][k]的点是否被更新即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long

2020-07-24 23:02:47 344

原创 [HAOI2015]树上染色

题目链接：[HAOI2015]树上染色考虑子树当中所有边的贡献即可。然后就能简单做树上背包了。但是要注意枚举的顺序，应该从大到小更新，否则某个状态会多次被加。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=2e3+10,M=N<<1;int n,K,

2020-07-24 22:52:05 150

原创地铁

题目链接：地铁因为对点跑最短路很难判断是否是同一条地铁转移而来，所以我们可以对边跑最短路。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<<2;int n,m,d[M],res;int head[N],nex[M],to[M]

2020-07-24 18:01:32 269

原创 Tree Intersection

题目链接：Tree Intersection考虑树上启发式合并。每次合并的时候，我们只需要统计子树当中存在并且不为最大值的个数。一直维护一下就好了。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,c[N],cnt[N],num[N

2020-07-24 17:05:06 233

原创 Dynamic Graph

题目链接：Dynamic Graph很简单的一道题，但是要注意细节。更新的时候暴力更新就好了，然后拓扑上面维护Bitset，但是要注意黑点不能直接跳过，直接不去更新颜色即可，如果直接跳过会导致某些点加不进来。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=31

2020-07-24 15:17:34 855

原创 Roads

题目链接：Roads容易发现，答案就是有可能出现在MST上面的边，然后使其不在同一个联通块中的最小切边数。所以我们把所有可能出现在MST上面的边全部加进来，求一个全局最小割，StoerWagner即可。判断边是否可能在MST上面出现，我们先对边排序，对于相同权值的点一起看，只要当前这两个端点未被连通则可以出现。各种倍增判断当然也是ok的，只是比较麻烦。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bi

2020-07-24 14:44:49 294

原创 Intersection

题目链接：Intersection可以直接线性基求交，也可以利公式：a&b=a+b-a|b。前者复杂度两个log，后者一个。答案就是 2 ^ 线性基交的秩。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=70;int n;struct Base{

2020-07-24 12:36:17 333

原创排列

题目链接：排列显然爆搜复杂度过高，考虑用状态压缩dp优化。我们规定一个顺序放入数字，从小到大。那么 dp[s] 为当前放入数字的位置状态为 s 的最小值，因为是从小到大放，所以我们可以从二进制位找到当前放入的数字是谁，然后因为有一个绝对值，所以我们可以把绝对值拆开，分当前数字对之前已经放入的数字的贡献，和之后要放的数字的贡献，对于之后的数字，那么我们可以提前减去当前的数字那么之后看之间数字的贡献就可以直接加了。AC代码：#pragma GCC optimize("-Ofast","-funrol

2020-07-24 10:57:49 105

原创买一送一

题目链接：买一送一因为我们只需要对每个点维护到根节点的一条链，所以可以想到用入栈添加出栈删除来维护到当前节点的一条链上信息。当前节点的答案可以由上一个节点转移，然后加上到之前一样颜色的点之间的不同颜色数量。然后注意选两个相同节点的情况。注意细节即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespa

2020-07-23 23:30:10 336

原创 J.I

题目链接：J.I因为题目保证不成环，那么说明肯定是一个二分图。那我们二分图染色之后，答案就是 n1*n2 - m ，所以我们要让二分图两边的点尽量接近，直接dp即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=2e5+10;int n,m,vis[N],

2020-07-23 08:56:29 309

原创有毒的玻璃球

题目链接：有毒的玻璃球把式子的因子提出来，然后枚举因子，预处理i^k即可。预处理直接sieve一下就好了。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e7+10,mod=1e9+7;int pw[N],n,k,vis[N],res;int qmi(int

2020-07-22 23:00:49 209

原创小A的数学题

题目链接：小A的数学题比较naive的莫反题。考虑枚举gcd，然后提出来就ok了。然后gcd=d的形式，我们让区间同时除以d，变成gcd=1的形式做整除分块即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e6+10,mod=1e9+7;int n,m,u

2020-07-22 21:59:34 214

原创小A与最大子段和

题目链接：小A与最大子段和假设我们设一个前缀和为：sum[i] = sum[i-1] + i * a[i] , s[i] = s[i-1] + a[i]那么我们答案可以表示为：sum[r] - sum[l-1] - (l-1) * (s[r]-s[l-1])化简可得：sum[r] + {-(l-1)*s[r]-sum[l-1]+(l-1)*s[l-1]}把(l-1)当成斜率，-sum[l-1]+(l-1)*s[l-1] 当成截距，然后就可以斜率优化dp了。这里我采用了之前没写过的李超树维护

2020-07-22 20:06:24 214

原创动态连通块

题目链接：动态连通块看到操作3和数据范围不难想到分块和bitset。但是分块不能解决动态连接问题，所以考虑用bitset。每个点维护能到的不同颜色即可。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],col[N],c

2020-07-22 17:21:25 295

空空如也

空空如也