qq_37073764的博客

题目可以把这题，每张牌的两个颜色看作图的两个端点（一个颜色一个端点），然后每次取一种颜色，其实就是每条边只能取一个结点，问最后最多能取几个结点。我们可以发现，只要图的连通块，存在一个环，那么这个连通块所有结点都能选上。树的话就只能取n-1个，因为每条边只能选一个结点吗。所以只需要找出所有连通块，对边数和结点数取min就可以了。#include<cstdio>#include<algorithm>#include<iostream>#include<cstr

题目思路总体和我想的差不多，就是当时想的有一点问题。做法很简单，就是把树拆开，拆成一个一个bud，然后根据样例可以发现，每一个bud都可以去掉一个叶节点，最无论如何总有一个减不掉的，就这么求就行。#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include<string>#include<sstream>#include&lt

题目这玩意居然还能用并查集来做。首先贪心的想，每个球我们能往左边放就往左边放，那么我们就能尽可能的腾出位置了。那我们怎么知道这个球所能放的最左边的位置呢，我们可以用并查集来维护。设fa[x]为x这个位置能不能放，不能放的话fa[x]将告诉你最左边能放的位置在哪。具体怎么维护看代码就可以了。#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include&l

题目首先呢，每个数选与不选，总共有2^n-1种选数方案（因为除去所有不选），题目中给出一个要求，所有数的和%200相同，这个有什么用呢？我们总共2的n-1种选数方案，理论上说我们会有2的n次方-1种结果，那%200，就相当于把这么多结果放到200个盒子里，那我们就可以想到鸽巢原理。所以我们可以直接爆搜，反正最多两百种情况。#include<cstdio>#include<algorithm>#include<iostream>#include<cstrin

题目傻了，其实就像noip2017蚯蚓那题维护就行了。那怎么取最小呢，就用优先队列呀，干嘛一定要用队列呢，那对所有元素add该怎么办呢，那就对所有后面来的元素都减呀，根据相对论，我不动，你减，那不就等于我加了嘛。#include<bits/stdc++.h>#define rep(i,n) for(int i=0;i<(int)n;i++)#define fr first#define sc second#define P pair<int,int>#define

题目首先这题我们要输出两个答案，最大和最小，应该怎么做呢？首先我们考虑最小，我们可以这么想，如果某个位置xxx有人，那么[x,x+2][x,x+2][x,x+2]这三个位置都可以放到x+1x+1x+1位置当中，这样贪心就是最小了。那最大应该怎么办呢，对于某个位置，如果它的位置大于1个人，且左边有空位的话，那就让一个人过去呗，右边同理，能占则占，感觉和D差不多。然后这题就完成了，不懂的看一下代码就差不多懂了。#include<cstdio>#include<algorithm&g

题目这题一步一步来想，暴力的话我们该怎么做。对于每个区间l，r，我们以r为起点，往左一个一个试，看看当前这个数在划分的区间内是否与区间所有数互质，不互质直接新划分一个区间，否则继续往左找。下面我们考虑怎么加速这个过程，首先就是如何判断某个数x和一堆数（设这堆数的集合为s）是否互质。这个我们可以这么做：设集合s所有数的质因子的集合为ss，然后对x进行质因数分解，看看是不是x的所有 质因数都不在ss里面，是的话就互质，不是就不是互质。然后设dp[i][j]dp[i][j]dp[i][j]为j这个位置，往左

题目C首先，这类题肯定就是算贡献的了，那我们应该怎么算呢？首先，mex的值必定为1~n+1里面的数，毕竟它只有n个数。对于每一个可能的mex值，我们可以这么考虑，设这个值为x，那么[1,x−1][1,x-1][1,x−1]的值必须全部选上,x不能选，大于x的数随便选，然后统计答案就可以了。#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include&l

题目还是学长牛逼

题目这题其实就是，区间长度为x的区间个数，然后我们枚举x就可以了……#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include<string>#include<sstream>#include<queue>#include<list>#include<stack>#include&l

证明：这里#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include<string>#include<sstream>#include<queue>#include<list>#include<stack>#include<bitset>#include<cmath

题目链接找规律。我们可以发现，只要一个数是四的倍数，它乘以任何一个数都是的倍数，只要有两个2的倍数相乘，它也可以组成四的倍数。所以我们可以这么想，一个四的倍数可以带走两个位置，一个2的倍数只能带走它本身，只要能带走所有的数，这道题就完成了。#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include<string>#include&lt

A平时这种题，直接开个1e8的数组去存，然后就是一个除法的问题了，但这次我们的数组开不了这么大，那该怎么办呢？那我们是不是可以，只存一部分数据，剩下的数据再从一个起点开始，直接暴力求解。然后就很好做了。#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include<string>#include<sstream>#inclu

【问题描述】对于一个字符串 S，我们定义 S 的分值 f (S ) 为 S 中出现的不同的字符个数。例如 f (”aba”) = 2， f (”abc”) = 3, f (”aaa”) = 1。现在给定一个字符串 S [0::n − 1]（长度为 n），请你计算对于所有 S 的非空子串 S [i:: j](0 ≤ i ≤ j < n)， f (S [i:: j]) 的和是多少。【输入格式】输入一行包含一个由小写字母组成的字符串S。【输出格式】输出一个整数表示答案。【样例输入】aba

题目设dp[i]dp[i]dp[i]为和为i有多少种方式，然后dp就可以了……蠢了，居然没想到#include<cstdio>#include<algorithm>#include<iostream>#include<cstring>#include<string>#include<sstream>#include<queue>#include<list>#include<stack&g

题目逆向思维，正着做有点难想，但反着做，让每个人回到自己位置，这就比较好做了。贪心就行。#include<cstdio>#include<algorithm>#include<cstring>#include<iostream>#include<vector>#include<cmath>#include<map> #include<string>#include<queue>

题目这题还是很有意思的，一开始没想到，这题学会了如何处理区间交集。对于区间问题的解法，我们通常一般固定一个端点，然后枚举另一个端点。我们对左端点排序，然后用小根堆储存右端点，这样做取出来的区间一定是区间交集（这个非常妙，不懂的模拟一下样例，非常清楚），然后对每一个区间取max就可以了。注意，当不满足要求时，输出0.#include<cstdio>#include<algorithm>#include<cstring>#include<iostream

题目设si为到i点的前缀和（即s[1]加到s[i]），题目要求我们求满足s[i]-s[j]=i-j的个数，那我们可以对于每一个i，求有多少个满足条件的j，答案就出来了。（对于力扣的区间和为k的个数那题，也可以用这种方法）。我们把式子变形为s[i]-i=s[j]-j，就很好做了。要注意一点，我们要在0的位置先+1，否则对于前缀就是答案的case，是无法统计进去的（力扣那题也一样）#include<cstdio>#include<algorithm>#include<cs

当时怎么就没想到这个做法呢？首先我们枚举每一条边，作为三角形的第二条边，然后二分去找三角形的第三条边，由三角形两边之和大于第三边以及三角形两边之差小于第三边，我们可以确定一个取数范围，统计一下就可以了。#include<cstdio>#include<algorithm>#include<cstring>#include<iostream>#include<vector>#include<cmath>#include&l

题目我们发现其实无论两个串怎么移，都是同构的。所以我们直接判断B串中的字母与A串相对应字母的距离，用map存一下，距离一样且最多就是答案了。#pragma GCC optimize(2)#include<iostream>#include<cmath>#include<algorithm>#include<cstdio>#include<cstring>#include<string>#include<utili

题目好妙，可以用拓扑排序去做。首先我们要明白，我们先统计正数的，再去统计负数，这么做是最优的。正数的话，加上去另个一个数，一定会使得答案更优，而且题目说保证不会成环，所以拓扑排序是可以的。然后我们对负数的处理就是，按照拓扑序逆序处理。因为负数无论加到哪里，都会使得答案变差，按照拓扑序逆序，可以防止负数加到另一个数，具体细节看代码吧。#include<cstdio>#include<algorithm>#include<iostream>#include<

题目B一开始想的是dp，但写不下去，因为不知道怎么找当前的位置在哪里（毕竟限制了不能连续往左走），看了官方题解才知道是k-2*z+1，有了这个就好弄很多了。设f[i][j][k]f[i][j][k]f[i][j][k]为当前走了i步，已经往左走了j次，这一步是向右移动过来的还是向左移动过来的（有限制我们也可以多开状态去储存），转移和细节就直接看代码吧。#include<cstdio>#include<algorithm>#include<iostream>#

题目首先我们可以知道，倒入冷水之后温度一定是（h+c）/2，这是由题目给的式子算出来的。所以当t<=（h+c）/2，那就直接输出2（为什么等等说）。然后我们二分倒入热水的次数，温度函数为(hx+h+cx)/(2*x+1)，这个函数当x>=0时，会在无穷处收敛，收敛值为（h+c）/2，然后再判断一下就可以了。#include<bits/stdc++.h>#define ll long longusing namespace std; long double h,c,t,sb;

题目D我们可以把公式变一下，变成−(ai−bi)<(aj−bj)-(a_{i}-b_{i})<(a_{j}-b_{j})−(ai​−bi​)<(aj​−bj​)，然后我们就可以按照ai-bi的差进行从小到大的排序，然后用upper_bound去算一下，就可以了。#include<cstdio>#include<algorithm>#include<cstring>#include<iostream>#include<sst

题目A不管选哪个棋子作为矩形的右下角，棋盘左上角都包含在被选矩形中。若轮到你时，左上角为黑，你行动完，它变为白，对手行动完，它必会变成黑，即，你已经立于不败之地了。结论：若左上角为黑，先手必胜；若左上角为白，后手必胜。#include<bits/stdc++.h>using namespace std;int main(){ int t; cin>>t; while(t--){ int n,m; cin>&g

题目我们找一下规律可以发现，我们可以每一次都把最小可以变的变成当前要变的最小的，例如第一个样例，把两个a全部变成b，两个b变成c，这么做一定不会使答案更差。那我们可以用什么去维护呢？看了这个大佬的博客才知道可以用并查集维护：连接在同一个并查集内的元素，除了起始点以外，都是即将一步一步跳大的元素，所以对连通块里面元素格式求和就可以了。#include<cstdio>#include<algorithm>#include<cstring>#include<i

题目要求构造一个数列，使得数列最长且最长上升子序列长度为a以及最长下降子序列长度为b。长度为a*b，分b个块，每块长度为a的最长上升子序列，那么这么做最长下降子序列还是为b。#include<cstdio>#include<cstring>#include<iostream>#include<cmath>#include<algorithm>#include<set>//#define int long longus

题目也算半个博弈问题了，就是一个海盗能随便拿，另一个只拿当前第一个，求随便拿的那个最多能拿多少。那就先当他们轮流拿，随便拿的先拿，若当只拿当前第一个拿的比随便拿的那个大，那随便拿的那个就可以反悔，这个就用set去维护就可以了，就是只拿当前第一个的那个拿的比随便拿的那个最小的都要大，那就反悔。#include<cstdio>#include<cstring>#include<iostream>#include<cmath>#include<a

题目我们可以找到规律，当出现最多的字符<=n/2次，必定可以。#include<cstdio>#include<cstring>#include<iostream>#include<cmath>#include<algorithm>#include<map>//#define int long longusing namespace std;int n,a[100005],m,cnt;char s[40000

题目一开始以为全部匹配第一次最多就可以，交了几次wa了才发现不是，因为这样第二次以后都会死的很惨。模拟了几下发现最优解法是直接取字符出现次数最多的那个。#include<stdio.h>#include<string.h>#include<iostream>#include<string>#include<math.h>#include<algorithm>using namespace std;int main(){

题目左边那条车道唯一加快的办法就是越过停止线后右转，横穿过去，就是第二个样例。如果撞车了咋办，那就时间+1，无论是等待还是继续往前走，都一个样。#include<cstdio>#include<map>#include<algorithm>#include<iostream>#include<cstring>using namespace std;int test,n,ans;int main(){ cin>&gt

题目很直观的就是全部排一条直线就可以了，可以用三角形不等式证明，主要是怎么去推导这个距离和。根据题意，一个人就是0，从第二个人开始，对于a[i]−a[i−1](i>=2)a[i]-a[i-1](i>=2)a[i]−a[i−1](i>=2)这段距离用了多少次，我们可以这么推导：对于第i位，这段必须要经过（i-1）次，而这个人后面（包括第i位）还有（n-i+1）个人也要做同样的事情，所以就是（i-1）*（n-i+1）。不懂的用纸画一下再看代码就懂了。#include<cstdio&

https://codeforces.com/contest/1379A：我们可以直接暴力匹配两个字符串，因为匹配串是常数大小，所以这个操作是O(n)O(n)O(n)的。具体我们可以暴力枚举每一位为起点，注意不要超过模式串长度，当模式串第i位为？或者这位跟匹配串相等，就继续匹配下一位，否则就可以直接让下一个字符为起点了。注意一些细节，我们匹配完成后，让剩下的问号都为‘z’，不一定这个字符，总之不能有新的匹配串出现。以及我们在开始的时候可以直接判断是否已经有匹配串出现，是的话看有几个，有两个以上就可以

题目可以发现确定第一个合并点后，无论你之后第二个合并点如何确定，最后的产生贡献的结果一定是间隔取的，因为他成环，环长又为奇数，所以最后会有两个点看起来是相邻的，但是实际上把这个断点拉开以后就是完全间隔的形式。#include<iostream>#include<cstring>#include<cstdio>#include<algorithm>#include<cmath>#define int long longusing na

题目有点像1996noip的第一题。首先我们可以确定0是最大的那个字母，然后去找第二大，第三大……那我们怎么找呢，b数组不是距离吗，第二大减去最大的距离，一次类推，就可以全部找出来了。记录一下，然后直接输出就可以了（这里需要点细节，代码有解释）#include<iostream>#include<algorithm>#include<cstdio>//#include<iostream>#include<cstring>#includ

题目对于这题，很容易想到的是，如果题目给的有向边已经形成环了，那肯定NO。否则一定能满足题目要求。为什么呢？根据拓扑图的性质，对于dep[u]<dep[v]，我们只要往u to v连边，一定不会形成环（画个图就懂了），否则有可能形成环。所以对于所有拥有无向边的结点，我们给它一个时间戳（即dep，深度，随便给即可），然后跑拓扑排序，这样就可以得到答案了。cf还是比较人性的，输出所有的边……好处理很多。只要按照拓扑序连边，一定会形成DAG。#include<iostream>#inc

题目一开始不知道怎么去弄，后来经过学长指点一下就知道了，但是因为代码问题（边界处理不好）没有过，赛后过了，记录一下。我们可以每次枚举一半，全部改成某一个字符，需要多少次，然后另一边也枚举一次，取最小的值，这个就是最终答案了。#include<iostream>#include<algorithm>#include<cstdio>#include<cstring>#include<list>#include<cmath>

题目这题比较有趣。首先呢，我们可以发现，当选择的区间长度为奇数时，答案是不会改变的，所以我们必须选择长度为偶数的区间。其次我们可以观察到一个性质，每选择一个区间进行修改时，每一个偶数位置只可能变成它的前一位和后一位，所以我们是不是可以比较每一个位置究竟是变成前一位还是后一位呢？那然后我们该怎么实现呢，我们可以计算每一次交换的贡献，然后求一个最大子段和，这样就可以了。不懂可以仔细想一想。#include<iostream>#include<algorithm>#include

题目要注意，在此题里，除法的本质是每x（x为除数）个位置放置一个东西首先是判断有没有1，如果没有，我们可以让整个序列+k再除以k+1，+k是因为每k+1个位置放置一个人嘛，所以这样做可以确定第一个人放在第一位。然后就是一段区间内，两边都有1和只有一边有1，只有一边有1直接0个数/k+1就可以了，两边都有1需要减去k再/k+1，这样是因为保证右边也有足够的空间#include<iostream>#include<cstdio>#include<algorithm&gt

题目这题其实不难，以前也做过类似的。我们先用floyd传递闭包，求出任意两个字母的最短路径。轮到字符串变换的时候，注意要枚举26个字母，不一定把a[i] 换成b[i]是最优的，有可能换成其他的更优，注意这点和其他细节就好了。#include<cstdio>#include<algorithm>#include<cstring>#include<iostream>#include<string>using namespace std;