frog77

非常明显的概率dp唯一要注意的就是n个里遇到m种类不是单纯的个数(m)/n信心题//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int

有点拓扑排序的感觉 用bfs来解决dp[j] = dp[i] + (i>j) j是i的子节点值得注意的是应该以最后合法到达某点的状态为准，而不是以它进入队列时为准。也就是允许在进入队列前转移状态 取最大值。//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#de

一棵树 有n个点 可以删掉1-k-1条边希望使得各部分的或异或和相等分情况讨论：1.所有数字异或和为0，则一定可以找到一个“分界点”2.如果异或和为x(x!=0)：a.能发现大于等于3个异或和为k的连通分量 (k>=3时可以切出足够的块)b.无法发现，不能分割出相同的连通分量//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-l

读错题hhh 考虑了半天奇偶性其实不难 n^2也能轻松通过的问题要注意检验合法性//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int

比较naive的dp~设dp[i][j] 为前i个删除j个的时满足条件的数字个数当数字个数大于k时 选出对应的j的最小值//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#defin

很有趣的题 因为在前x个 选取y个 可用空间为z时 必然存在最优解因为是一步步向前的 第一维可以处理成滚动数组如果认为水的总量为S 选取k个杯子最多水量为V那么能得到的最大值就是 (S-V)/2+V=(S+V)/2在最后要比较j和最大值的大小似乎是一道思路清晰就很好写的题却从上午debug到下午万万没想到是因为没限制好只能从 0 0 0 出发有点生锈了啊 (叹息//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx

很暴力的题很呆的解法很快的c++20//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i>=a;i--)#de

记录左边更优方案的方法很有趣一开始没想出来//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i>=a;i--)#d

比较好想的dp 注意限制不合法情况的转移//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i>=a;i--)#def

最暴力的做法就能做出来，就是有点烦躁有些细节 非常适合复健hhh//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i&gt

首先令a<b设某次要取出t组为什么要变换成相减的形式？emm 窝也不知道 再看看 说不定哪天就知道了(//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define p

博弈问题1.n为奇数时bob一定会赢n为奇数时，它的因子一定都是奇数且个数也是奇数，因为有奇数个因子，所以后手总会取得胜利2.n的因子只有2时如果2的次数是奇数 则后手会赢否则先手赢3.n的因子不只有2时先手一定可以把这个数字变为奇数 也就是自己能后手取胜的情况所以alice一定会胜利//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unro

树dp太久不做了，纠结于细节很久，到最后才写好 结果没时间交了 崩溃//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i

一道练习莫队的好题用vis维护范围内每个数的出现次数用cntvis维护出现某次数的数字的种类数//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n)

传送门明显是一道dp设dp[i][j] 第i个1 第j个0时 需要付出的最小代价可以找到递推式dp[i][j]=min(dp[i][j-1],dp[i-1][j-1]+abs(one[i]-zero[j]));如果cntp是1的个数cnt是0的个数最后的答案就是dp[cntp][cnt](比赛时一直在想类似区间dp的写法 应该是漏掉状态了）//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pra

首先处理行和列的异或和 如果二者不相等一定不能构造出矩阵把除了最后一行和最后一列之外的数都设成0，除了最右下角的元素都可以直接写上对应的异或和因为一定能构造出来，所以最后一行的值就可以直接算出来了//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep

可以知道有两种走法 一种是蛇形上下移动 另一种是直接移动到底再转回来那么可以先处理三种走法(走到底的情况分为从上开始和从下开始）在每个点的值，再加起来找出最大值很有趣的是：走到底的情况要走的相对顺序是一样的，所以只要补充前面蛇形运动多出来几步的部分就可以了//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include&lt

奇数次时显然不可能回到原来的位置偶数时就是求一半路程的最距离*2dp[i][j][k] 代表第k次运动在i,j位置时的最短距离一共有上下左右4种方向写转移式时千万注意是 i-1到i 或者 j-1到j 不要写反/写混//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>

dp[i][0]表示这位填0是合法情况需要的步骤数dp[i][1]表示这位填1是合法情况需要的步骤数填0时上一位合法就可以填1时min(1,i-k)位合法，改变中间的1 或者 将前面的1全改成0//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep

dfs 如果最后的值等于最大值(不可能超过1e7)的话就认为是无限的否则除4就是最大的值//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for

区间dp形成了回文串的话就可以一次消去dp[i][j]代表从i到j的最小代价应当令每个dp[i][j]=1若a[i]=a[i+1]则dp[i][i+1]=1（ 一次消去）否则 dp[i][i+1]=2 （ 2次消去）状态转移：如果a[i]=a[i+pace] dp[i][i+pace]=dp[i+1][i+pace-1]对于j∈[i,i+pace)范围的每个点dp[i][i+pace]=min(dp[i][i+pace],dp[i][j]+dp[j+1][i+pace])//cyc#p

区间dp和607B[题目]很相似从一个点开始向左右dp，pace代表长度，每一步选出上两个可能状态中更小的一个加上（最大值-最小值）//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)

dp[i][j]表示[i，j]范围是不是个回文串f[i][j]表示回文串[i，j]的回文串级数(k)把ans倒着加一次就是想要的答案转移方程：dp[i][j]=((dp[i+1][j-1])&&(s1[i]==s1[j]));f[i][j]=f[i][(i+j-1)/2]+1; (当[i，j]是回文串时）//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optim

思路很直接的一道dpdp[ i ][ j ] 表示在j时间 j%(2*k)是否可以合法在i位置上转移方程dp[i][j]|=dp[i-1][j-1];dp[i][j]|=dp[i][j-1];要注意边界位置的处理//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>

给出一个从0-n-1不重复的数列，可以置换一次任意两个元素的位置，求交换后逆序对最少的数量以及这样做的方法有几种large[i][j] 表示从i到j范围内a[i]<a[j]的数量small[i][j] 表示从i到j范围内a[i]>a[j]的数量这两个数组的i与j的关系可以(i<j)也可以(i>j)因为n足够小，可以n^2枚举先统计不置换时的数量如果(a[ i ]<a[ j ])置换i和j减少了small[ i ][ j ]+large[ j ][ i ] 个重复

通过推导不难发现，所有位数+1时只有9可以增长整个串的长度。每个数字的状态其实是相对独立的，不需要作为整体考虑如果根据输入来确定原状态再做dp，很难不TLEdp[i][j] 代表数字j做i次操作后一共有多少位倒着dp，可以得到转移方程if j==9 dp[i][j]=dp[i-1][1]+dp[i-1][0]else dp[i][j]=dp[i-1][j+1]初始状态应该设置成dp[0][j]=1，因为做0次操作就是0位//cyc#pragma GCC optimize("Of

由题意可知至少需要2个等于所有元素与运算的值的元素（前后各一个）总共有n个元素 值等于全体元素与运算的元素有cnt个计算时分成两部分。中间部分的摆放方法共有(n-2)!个。cnt个元素有序选取2个放在前后有(2 C cnt)*(2!)即 (cnt-1)*cnt个 那么最后的答案就是这两部分的乘积。//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unro

有点像素数筛的写法 每个数的值等于它的质因数的值的和，若i=j*j时，i的值应该计算两次j//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(

从前到后找出连续两个负数的距离，然后贪心枚举一下，注意要特别判断最后的情况 因为不需要再换回去了//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) f

挺简单的一道模拟…注意细节就行先确定最多的位数 然后从最高位向最低为用大于消耗最小的数逐个替换，如果不能替换了就退出来//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define

写了很久 感觉能考虑的条件都考虑过了，也参考测试数据改了又改，最终出现了一个不能完全展示的数据，彻底debug不动了150多行的代码 头都大了//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i

1和n固定 需要寻找a,b,c的值可以知道 只有在[a,b)之间和小于0时才会对答案产生正贡献那么就遍历a,c的值，遍历c时可以找到和为负的值，就让它作为b的值，每次找到和更小的c就更新//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n

有点绕的构造模拟时有些细节 要先想清楚再写//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i>=a;i--)#d

二分答案 要用dp处理分组dp[j] 代表从1到j是否可以合法分组//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i&g

记录每个点下一个节点的情况如果发现新的序列有相邻互质的情况就继续更新节点状态//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=

time limit per test2 seconds memory limit per test256 megabytesinputstandard input outputstandard output Polycarp is in reallyserious trouble — his house is on fire! It’s time to save the mostvaluable items. Polycarp estimated that it would take ti sec.

time limit per test2 seconds memory limit per test512 megabytesinputstandard input outputstandard output You are given three positive(greater than zero) integers c, d and x.You have to find the number of pairs of positive integers (a,b) suchthat equal.

time limit per test2 seconds memory limit per test256 megabytesinputstandard input outputstandard output There are n students at youruniversity. The programming skill of the i-th student is ai. As acoach, you want to divide them into teams to prepare t.

D. Bananas in a Microwave time limit per test3 seconds memory limitper test256 megabytes inputstandard input outputstandard output Youhave a malfunctioning microwave in which you want to put some bananas.You have n time-steps before the microwave stops.

//cyc#pragma GCC optimize("Ofast")#pragma GCC target("avx,avx2,fma")#pragma GCC optimization ("unroll-loops")#include<bits/stdc++.h>#define vector<int> VI#define rep(i,a,n) for(int i=a;i<=n;i++)#define per(i,a,n) for(int i=n;i>=a;i