2020年08月_青烟绕指柔!

原创 HDU - 4386

题目链接：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>

2020-08-31 19:24:27 172

原创 Codeforces - Buying Sets

题目链接：Codeforces - Buying Sets如果不考虑 k 的限制，那么就是一个最小权闭合子图。然后现在需要相等，所以我们给集合一个正的权值，元素一个负的权值，保证可以相等。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int inf=0x3f3f3f3f3f

2020-08-31 17:45:48 261

原创 Codeforces - Omkar and Circle

题目链接：Codeforces - Omkar and Circle一眼看去，不是很好做。但是我们可以发现，相邻的两个一定不能同时被消掉。所以我们需要消除 n / 2 次。所以就是对于一个环，然后选两两不相邻，然后选 n/2 个不最小和。考虑破环成链，然后分析是否选最后一个位置和第一个位置即可。考虑dp，dp[i] 为前 i 个位置选 i/2 个数字的最小价值。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include&

2020-08-30 18:17:08 173

原创 HDU - 4705

题目链接：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

2020-08-30 15:31:31 267

原创 HDU - 4700

题目链接：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

2020-08-30 15:16:53 141

原创 HDU - 5919

题目链接：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

2020-08-29 17:37:04 221

原创 Codeforces - Till I Collapse

题目链接：Codeforces - Till I Collapse考虑根号分治。当 i <= bk 时，只有bk个，直接暴力即可。当 i > bk 时，因为答案最多为：n / i 个，并且答案具有单调性，可以相同连续段答案相同，所以我们可以分治区间，然后对答案相同的一起处理。最多递归 n / bk 次。当 bk = sqrt(nlogn) 时最优，复杂度为：nsqrt(nlogn)AC代码：#pragma GCC optimize("-Ofast","-funroll-all-l

2020-08-29 16:37:41 290

原创 [COI2012] TRAMPOLIN

题目链接：[COI2012] TRAMPOLIN建立一个传送点，然后变成某个点开始的种类最长路。但是存在环，所以我们可以缩点。然后记忆化dfs或者拓扑即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=3e5+10;int n,k,h[N],dfn[N],

2020-08-29 15:15:56 203

原创 [SCOI2008]配对

题目链接：[SCOI2008]配对两边互相sort之后，直接匹配一定是最优的。但是可能会有相等的元素，如果有相等的元素，我们可以考虑前后互相交换，或者联系3个成环交换一定可以变成有解。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[

2020-08-27 20:33:55 188

原创 URAL - 2030

题目链接：URAL - 2030对每个点维护给其他点加了多少，然后每个修改一个点是时候，顺便维护父亲节点。那么查询的时候就只需要知道父亲节点的增加值。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+10,mod=1e9+7;int n,m,a[N],v

2020-08-26 21:00:59 2193

原创 Codeforces - Little Pony and Harmony Chest

题目链接：Codeforces - Little Pony and Harmony Chest因为值域很小，所以用到的质因子不会很多。所以我们对每个质因子状态压缩，使得一个质因子只会使用一次即可。然后Dp的时候记录转移方案。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const

2020-08-25 13:22:45 395

原创 [JSOI2009]球队收益

题目链接：[JSOI2009]球队收益因为要限制每个比赛，一胜一负，流量无法限制。所以我们可以假设先全败，然后选择某个人获胜，然后用差值来改变。假设当前a胜，b负。然后获胜一次的差值为：c*(a+1)*(a+1) + d*(b-1)*(b-1) - c*a*a - d*b*b= c*(2*a+1) - d*(2*b-1)AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h&g

2020-08-25 00:19:51 119

原创 Codeforces - Shortest Path

题目链接：Codeforces - Shortest Path跑BFS的时候，对每个点记录是从哪个点过来的，然后就变成快速check3个点是否合法了。哈希即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=3e3+10;int n,m,k,d[N][N],

2020-08-24 17:55:56 232

原创 Codeforces - Matching Names

题目链接：Codeforces - Matching Names因为是前缀信息，所以我们可以发现，每次选LCP最长的匹配一定是最优的。于是Trie上面贪心即可。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,t[N*8][26],i

2020-08-24 14:46:41 230

原创 Codeforces - Information Graph

题目链接：Codeforces - Information Graph离线得到树形结构，然后倍增。对于查询，我们只需要知道一个点是否在某条链上。直接用点到端点的距离判断即可。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,par

2020-08-24 11:08:50 177

原创 Codeforces - Ehab and a component choosing problem

题目链接：Codeforces - Ehab and a component choosing problem显然 Σa / k，相当于取平均值，我们得到最大值肯定是k=1的时候。求最大值树形dp即可。但是与此同时可能存在多个最大值。再次树形dp求出即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namesp

2020-08-24 10:21:04 184

原创 Codeforces - Split the Tree

题目链接：Codeforces - Split the Tree预处理出每个点最多向上到的距离。然后从叶子往上贪心，如果某个点未被子树中的点覆盖，则答案加一，新开一条链。找每个点最多向上走的点，树上倍增即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;const int N=1e5

2020-08-24 00:10:05 167

原创 Codeforces - Leaf Sets

题目链接：Codeforces - Leaf Sets找一个度不为1的点开始，从叶子往上贪心即可。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,k,dp[N],res;vector<int> g[N];void df

2020-08-23 23:15:59 156

原创 LUK-Triumphal arch

题目链接：LUK-Triumphal arch首先考虑二分最小的k。然后转为判定合法性。我们可以树形dp。dp[x] 为当前 B 在x点，然后A需要在子树中染色的最小点数。dp[x] = Σ dp[v]+1 - k最后判断dp[1]==0即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespac

2020-08-23 12:02:01 279

原创 URAL - 1742

题目链接：URAL - 1742显然，最小次数就是入度为0的点+单独环的个数。最多的个数就是：每个环只能贡献一次，答案就为n - 所有环的大小 + 环的个数。我们直接DFS找环即可。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,

2020-08-22 22:59:36 170

原创 URAL - 1651

题目链接：URAL - 1651因为边有访问顺序，所以我们可以采用动态加边的方式。也就是按照顺序枚举每一条边，是否会更新下一个点。但是注意我们要输出方案，所以我们应该是对每个编号存上一个转移点的位置。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e5+1

2020-08-22 22:04:44 208

原创 Flags

题目链接：Flags首先这个可以二分。然后这个东西可以 2-SAT，然后我们可以发现我们对每个点连边的时候连的是一个区间。所以我们可以用线段树优化。如果对每个点都建立选 or 不选两个点的话，我们就需要两颗线段树了。我们可以优化一下，对于一个点选的话，我们找到这个区间不能选的点，然后就是连向这个区间所有点的另一个点，也就是选这个点，那么必须选这个区间的另一个点。然后找区间的时候，不能连向自己的反点。AC代码：#pragma GCC optimize("-Ofast","-funroll-al

2020-08-21 22:14:26 409

原创 Codeforces - New Year and Handle Change

题目链接：Codeforces - New Year and Handle Change直接dp的话，复杂度是n*k的。但是我们可以发现，如果我们给每次选择，一个负的代价，那么整体的最优解是一个凸包。我们就可以wqs二分了。但是要注意，因为选择的次数是小于等于k，但是最优解一定是选k次。因为我们每次转移是从 i - l 转移的，所以如果 i < l 我们也需要转移。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#incl

2020-08-21 16:30:03 247

原创两个机器人

题目链接：两个机器人对两个机器人同时BFS即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=55;const int dx[]={0,1,0,-1},dy[]={1,0,-1,0};int n,m,vis[N][N][N][N]; char g[N][N

2020-08-21 09:20:34 301

原创 HDU - 5352

题目链接：HDU - 5352按照每次的变换建边即可。因为要求最小字典序，所以我们可以用费用流的权值来限制。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int inf=0x3f3f3f3f;const int N=1e3+10,M=1e6+10;int n,m,k,

2020-08-20 22:59:33 146

原创 Codeforces - Generate a String

题目链接：Codeforces - Generate a String我们可以发现 dp[i] = min(dp[i-1]+x,dp[i+1]+x,dp[i/2]+y)然后对这个多跑几次即可AC。但是其实我们可以发现：我们不会连续删除数字。每次删除一定是*2之后超过了n。那么我删除两次，不如先删除再*2所以：if(i%2==0) dp[i]=min(dp[i-1]+x,dp[i/2]+y);else dp[i]=min(dp[i-1]+x,dp[i/2+1]+x+y);AC代码：#

2020-08-19 20:42:13 214

原创 Codeforces - Fox And Jumping

题目链接：Codeforces - Fox And Jumping有一个显然的dp，dp[i]为gcd为 i 的最小价值。那么可以直接和其他值转移，但是值域很大。因为数字很少，每个数字能与其他数字组成的不同gcd一共最多log个，所以用map优化即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespa

2020-08-19 20:15:54 177

原创 Codeforces - Photo Processing

题目链接：Codeforces - Photo Processing显然可以二分。然后 dp[i] 为前 i 个是否合法，我们可以用双指针找到最远的一个合法的位置，然后如果在能转移的区间有一个 1 即合法。判断转移的区间是否有合法的，直接前缀和。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace

2020-08-19 18:22:19 251

原创 HDU - 6873

题目链接：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

2020-08-19 12:31:46 398

原创乔乔和牛牛逛超市

题目链接：乔乔和牛牛逛超市因为一个物品是有两种状态的。A，B。买了A才能在买A的基础上买B。我们可以把费用拆成两种。第一个为f(A)，第二个为f(B)-f(A)。这样的话买两个的时候就不会多算了。然后按照最大权闭合子图建图即可。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>#define int long longusing namespace std;cons

2020-08-18 23:19:47 1323

原创 URAL - 1487

题目链接：URAL - 1487这个题目说的不是很清楚，如果一个队A比另一个队B强的定义是：不比能打过B的若。也就是说，不存在一个队即能打过A，也能打过B。这个我们可以先维护每个点打不过的点，然后传递闭包得到所有打得过自己的点。这里可以Bitset优化。然后查询的时候直接就是两个bitset与的个数。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define

2020-08-17 21:50:28 162

原创 HDU - 6486

题目链接：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=

2020-08-17 20:09:51 292

原创 Codeforces - Inna and Dima

题目链接：Codeforces - Inna and Dima先DFS判环。然后DAG上最长路。但是要注意最长路的时候，一定要从’D’开始。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing namespace std;const int N=1e3+10;const int dx[]={0,1,0,-1},dy

2020-08-16 17:12:46 182

原创 Codeforces - Pencils and Boxes

题目链接：Codeforces - Pencils and Boxes显然可以dp，dp[i] 为前 i 个是否合法。然后sort一下，然后枚举当前位置的时候，二分或者尺取找到最远的合法的位置。然后就找到了转移区间，只要转移区间有一个合法的，那么当前也是合法的。AC代码：#pragma GCC optimize("-Ofast","-funroll-all-loops")#include<bits/stdc++.h>//#define int long longusing na

2020-08-16 16:13:49 191

原创 HDU - 5102

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

2020-08-16 12:16:34 166

原创 HDU - 5215

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

2020-08-15 23:42:15 241

原创 HDU - 5200

题目链接：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

2020-08-15 22:29:04 169

原创 HDU - 5398

题目链接：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

2020-08-15 21:58:17 219

原创 HDU - 5325

题目链接：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

2020-08-15 16:25:28 159

原创 HDU - 5317

题目链接：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

2020-08-15 14:52:07 177

空空如也

空空如也