bjfu170203101的博客

直接上讨论区老哥的解法！#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)//#define m (l+r)/2#define pb push_backtypedef pair<int,int> pii;const double PI= acos..

在刷完24道网络流后，这种题随便切。。读题到AC不到25min但还是忘了输出-1wa了一次，还是要细心一点。。显然，二分图，这里的费用是取max，所以用二分建边跑最大流即可。若费用求和，则可用最小费用流。#include <bits/stdc++.h>using namespace std;typedef long long ll;const int M = 1000000+7;const int N = 20000+7;struct Dinic{ //N个点，M条

这类操作构造问题一般给的操作限制就是上界。也就是我们要n次换完。很容易想到一次换一个。由于是反转操作，我们可以i和n-i+1打包一起换。然后换n/2次即可。细节见代码#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)//#define m (l.

现在的DP题一般需要对题目分析，得出一些性质，然后利用性质和一些数据结构对暴力DP进行优化！这题先写出朴素DP：dp[i]:以第i个人为拍摄终点，最多的拍摄次数。显然有转移：dp[i]=max(dp[i],dp[j]+1); j<i && dis(i,j)<=t[i] - t[j];然后考虑优化:我们发现：r才500，也就是说当时间差大于1000时，一定可达任意点。而两个人出现的时间差至少大于1，所以我们可以暴力时间差1000内前面的人，10...

n个数切成k份,求切出数的平方和的最小值.有个比较显然的结论：对于一个数x，把它分成y份，求平方和sm，使得sm最小的分法一定是均分。而把一个数分成y份，平方和与分成y-1份的平方和减量设为Cy，分成z份，平方和与分成z-1份的平方和减量设为Cz。显然有：if(y<z)则Cy>Cz。这里说明了我们可以贪心的分萝卜，当前最优一定是全局最优，因为后面的分块一定不优于当前分块sm的减量。于是便有了贪心：刚开始n个数，还需要分出k-n块。我们把每个数存到优先队列里，.

构造题就是先分析性质，然后尽量简化过程，简单的进行构造。这题分析下可知：3后面必须要有1，或者2来与其构造。2后面只能跟1.所以就有了贪心构造：从前往后，记录前面2，3的个数。1优先跟2配对，然后2，3与3配对。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o&lt.

给你n个栈，你需要对于每一个栈，从前往后选择若干个，栈中每一个元素有一个贡献，问选择k个的最大贡献是多少。思路：首先可以想到：最终一定是选完若干个栈，最后剩一个栈选若干元素。证明：若最后存在两个栈未选完：栈a,b. a选到i，b选到j。假设a[i]>a[j],显然a[i+1]>a[j]；完全可以不选a[j],选择a[i+1].所以最后一定至多有一个栈未被选完。然后：就有了做法:枚举是哪个栈最后未被选完，然后对其他栈打包做一个01背包。总复杂...

暴力枚举每条边免费再用dij求最短路复杂度为：n*m*k*logm;需要进行优化：我们发现：把边i(x -> y)免费后对于路径 a -> b只有三种情况： 1：原本i不在 a->b最短路上，免费后也不在。 2：原本i不在 a->b最短路上，免费后在。 3：原本i在 a->b最短路上，免费后也在。只需要判断下： ds[a][b] 与 min(ds[a][x]+ds[y][b],ds[a][y]...

经典的带余数DP转移。看到要求最后和整除K，就想到DP多开一维状态表示到当前状态下选的数和模K为多少。然后要求每行最多选m/2个，那么开一维状态表示每行选了多少数。然后再开两维表示选到第i行，第j列。总共四维DP，O(n^4) 滚动数组一下可以优化两维，这里我只优化了一维。具体看代码就行。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#de.

设a,b， x=gcd(a,b);题目可以转化为： a,b,x^2 组成三角形。设a<b，若a为质数，则b一定只能为a^2 , 否则无法构成三角形（证明比较简单略）若a为合数，则设b= z*y ,令a=(z-1)*y. 则 a，b，y^2 一定可以构成三角形。所以结论为：若一个数x是合数，则他不孤独。若一个数是质数，则如果他的平方也在，则他不孤独，否则孤独。#include <bits/stdc++.h>using namespace std;...

思维量比较大的一道题，如果之前做过类似的就很简单，但没做过的话真的有点难想。。首先一个比较容易想到的点：从1枚举到n+1，用某种方法计算最终的MEX序列是否出现i。对于一个子数组[L,R],若其MEX等于x，则其必须满足:区间内不包含x，且区间内包含所有1 - x-1的数。关键点在于这里如何进行维护。我们可以这样做：对于区间不好含x这个限制我们可以每次取区间：(lst[a[i]],i),这样区间一定不包含a[i],而包含1 - x-1的数可以考虑用权值线段树维护：从左往右..

这种最大最小值不固定的题目，一般要枚举最大值/最小值。可以先求出 c[n][6] = b[i] - a[j];总共n行6列的矩阵，每行选一个数，选出n个数，求这n个数最大最小值之差最小是多少。我用的是枚举最大值：显然需要找每行小于当前最大值且最大的数是多少。如果枚举做的话就是n^2的了。但我们如果先预处理排序下的话，发现每次没必要枚举找每行的小于当前最大值的最大值。我们可以维护一个multiset表示每行当前情况下的最大值。每行的初值为：b[i]-a[1].这样维护，.

比较简单的DP。。dp[i][j],第i个碟子，dij秒拿出来最少的结果。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)//#define m (l+r)/2#define pb push_backtypedef pair<int,int> p

很经典的思维套路。我们知道：长度为i的排列共有 i！ 种，显然20！> 1e5*2e5所以其实无论怎么改变，最多修改不到20个数。我们可以类似于二进制的思想，从前往后修改。比如1 2 3 4 5，对于2号位置，其于其后面的4个数总共有4！ = 24种排列，那么对于1号位置来说：其排列为24*5=120，即这五个数每个数放在最前面，后面都是4个数的排列。对于字典序从低到高来说：我们把2放在最前面，其余相对位置不变往后移变为：21345，这个排列是第25字典序小的排列（..

在做这一题之前先看一道题：给的一个长度为n的序列a，求最少需要改变a的数量，使得a序列非严格递增。显然结果为：n-LIS，（因为最后一定有些数是不变的，我们让不变的数尽量长，则必须让不变的数满足最终序列的性质即：非递减）如果把非严格改成严格递增呢?我们依然用上面的思路：让不变的序列尽量长，即满足最终序列，最终序列是严格递增序列，由于是整数，则对于：j>i,必须满足a[j]>a[i].且a[j]-a[i]>=j-i. 这样才能保证中间变化的数有解。为了方便我们对上面的式子

A:简单分析可知：一定是从左往右和从右往左两个递减序列组成的；然后从前往后构造即可：前一个序列一定递减，后一个递增。显然又贪心：让前一个尽量大，后一个尽量小，这样后面的数构造更灵活。非法情况时break即可。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<&l

很容易发现：最终结果为：仔细观察，大胆猜测结论：设op=-1的个数为x， 只要满足:(n+x)%3==1，且op序列不等于1，-1，1，-1，1…… ，则一定能通过一种方法构造得到这种op序列。证明：首先：若两个序列均满足 (n+x)%3==1 则他们合并后一定也满足(n+x)%3==1.证：显然n=1时成立(x=0).设其中一个序列长度n1，op=-1的个数为: x1, 另一个序列的长度为n2，op=-1的个数为x2.合并后的序列长度为n=n1+n2，op=-1的个数...

很容易发现，如果怪物区间严格不相交，则是一个非常简单的枚举题目。因为中间空的时间再多，我们也只能上一次子弹，也就是说，每波怪物开始的时候，最多只能存k发子弹。而题目又保证了只能相交于上一波的终点。显然我们可以倒着处理，判断每波开始之前，枪里至少要有多少发子弹。若某一波是独立的则dp[i]=max(0ll,p[i].a-(p[i].r-p[i].l)*k); 除了第一秒后面每秒都能上一次弹。第一秒需要的子弹数就是dp[i].而如果当前波结束的时间就是下一波开始的时间，则这两波是关联的.

(353) xxx 5 187 +00:05 +00:10 +100:28 +00:53 +01:21 A:倒着枚举就行，复杂度是够的，不要纯On^2就行。。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define r...

#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define pb push_backtypedef pair<int,int> pii;const double PI= acos(-1.0);const int M = 2e5+7;const int mod = 1e9+7;struct node{ int l,r,id,ans;}...

比较简单的一道E，只不过特殊情况有点多，需要考虑全面。有个比较显然的贪心:从后往前处理，如果后面的后缀某两个位置删除了，前面的后缀一定需要删除，(因为删不删某两个位置的字符，只跟他们后面的字符有关)然后就是简单的处理了。这里给出一些情况，方便大家调错：(最左边的字符是当前处理的字符)bba 删去bb；--> aaab 不删除；--> aabaabba 删除aabb;--> aaabbab 删除bb;--> aaab //wa46...

1：24 做出 D， 这场打的还行，主要是最近手感不错。A - Fence直接取上界-1即可:#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)//#define m (l+r)/2#define pb push_backconst double PI..

A Circle Coloring 从前往后构造即可#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)//#define m (l+r)/2#define pb push_backconst double PI= acos(-1.0);

80minAK ,无罚时。比较简单的一场DIV3A：Floor Number直接算就行#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)//#define m (l+r)/2#define pb push_backconst double PI= acos

https://blog.youkuaiyun.com/zqy1018/article/details/108791516参考了这篇博客思路都在代码里了。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI

A:冒泡排序，最坏情况下严格递减，需要n*(n-1)/2次#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e5+7;/*int

这类找区间个数题，一般可以枚举一个端点，找符合条件的另一个端点的个数。这题我们枚举右端点，对每个数x而言，其作为右端点的时候，满足条件的左端点必须是其前面2个x与前面3个x之间的点。我们用lst[i][j],当前状态下，从后往前第j个i的位置。显然：对于每个值i，都有：在区间[lst[i][3]+1 - lst[i][2]] 合法，其余点做为左端点均不合法。由此有了做法：从左往右枚举右端点，对于每个值，当前状态下，某个点可以作为左端点，则其值+1，否则不变。显然，只有满足点值为0的点

A：先求出需要多少个木棍，然后求出次数即可#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e5+7;/*int head[M],

由题意有：每个点的颜色影响其出边。这样不方便我们递推。所以我们建立反边。从n走到1的最短路。这样边确定，点的颜色也就对应了。设：b[x]:x为黑色，到达x点时的最短路；w[x]:x为白色，到达x点时的最短路；dp[x]:x为任意色，到达x点时的最短路；如果不考虑复杂度，直接spfa进行dp：x -> y显然有：b[y]=min(b[y],dp[x]+1);w[y]=min(w[y],dp[x]+1);dp[y]=max(w[y],b[y]);

A:直接贪心取即可#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e5+7;/*int head[M],cnt=1;void in

A:思维贪心，尽量只保留0或者只保留1#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e5+7;/*int head[M],cnt=

题意：求每个前缀是否是ABABA 的形式。(其中A有k+1个，B有k个，AB均可为空)对于一个前缀字符串i：令S=AB则可看成：SSSSA。若满足S的个数为k，则满足题意。对于前缀字符串i：其最小循环节e长度为：i-nxt[i]， 改字符串可以看做：eeeex如果若干个e拼凑成一个S，使得S的数量为k，则满足题意。最后的x和前面若干个e组成A。具体判断的话我们可以分情况：下面是官方题解#include <bits/stdc++.h>using

刚睡醒，做点思维题活跃脑子。简单的三维DP，很容易想到从大往小取，但贪心的话，每个颜色的下一个的大小也要考虑，比较麻烦，直接DP就完事了。n<=200,复杂度n^3#include <bits/stdc++.h>using namespace std;typedef long long ll;#define re register#define ls (o<<1)#define rs (o<<1|1)#define pb push.

A：显然都取长度为1，不仅长度优，而且更容易构造。#include <bits/stdc++.h>using namespace std;typedef long long ll;#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e3+7;/*int head[M],cnt=1;void init()

A:枚举哪7个连续字串是abacaba即可，注意一些细节处理#include <bits/stdc++.h>using namespace std;typedef long long ll;#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e5+7; char s[110];char t[10]="a

容易发现：大部分情况下f[x+1]=f[x]+1；如果全部f[x]，满足这个性质，则直接可以求出f[x]进行构造。但由于x+k会发生进位，f[x]出现两个等差数列，中间出现断层。且只会出现2个等差数列，因为k小于等于9，即x最多进位1次。（个位往前进位）所以我们枚举个位c，如果k+c<=9,则不会发生进位。直接用等差数列求出f[x]即可。(f[x]+f[x]+1+k)*(k+1)/2 。然后从个位进行构造，低位尽量取大数，这样高位可以取少一点，使得整体尽量小。否则的话再枚举个位

一个经典的贪心套路。首先：正着找人吃饭考虑太多因素。我们可以倒着找。设s[i]为第i种food 的最大需求量。最后一个人吃饭时，假设他喜欢吃x,y种食物，那么无论前面人吃饭顺序如何，食物剩余量一定为：w[x]=w[x]-s[x]+1;w[y]=w[y]-s[y]+1;也就是说，必须至少一个w[i]>=s[i],才能保证最后一个人可能吃上饭。至此一个贪心策略出来了：如果存在一种食物i：s[i]<=w[i]，那么喜欢吃i的人一定都可以在最后吃（且最好放在最后吃，因为这

首先w[i]==1的情况肯定直接分配最大值。对于剩余情况：我如果我们预先把1-n的a[i]值都加上记为sm。对于w[i]==x的情况：相当于：选取一段区间[l,r] r-l+1=x,sm的值减去[l+1,r-1]区间内的a[i]。我们的目的是让所有w[i]对应的区间，减去的值和最小。显然，让w[i]最大的区间放在最前面，然后依次放下去，减的数和最小。否则只要变东任意一个区间，整体减去的区间会变大。#include <bits/stdc++.h>usi...

每个点最多两个出边。我们让第3*x层的点全部删去。假设第一层V1,第二层V2，第三层V3V3<=2*V2<=4*v1V1+V2+V3>=7/4* V34/7 * n >=V3#include <bits/stdc++.h>using namespace std;typedef long long ll;#define ls (o<<1)#define rs (o<<1|1)#define pb push_back

A:显然 交替加 增大最快#include <bits/stdc++.h>using namespace std;typedef long long ll;#define ls (o<<1)#define rs (o<<1|1)#define pb push_backconst double PI= acos(-1.0);const int M = 1e5+7;/*int head[M],cnt=1;void init(){cnt=1,memse