浅笑~如夏

题目大概就是队列变换，然后问一下能否达到最终状态。一开始完全不知道怎么做，学习了一下，发现这种题大概就是求差分或者前缀和就会有规律了。比如这道题，求一个前缀，每一次操作就成了交换两个前缀一样的，之后就挺简单的了。#include<bits/stdc++.h>#define N 100000using namespace std;int n,T;long long A[N+5],B[N+5];

题目我们先考虑暴力的做，显然会T，如何优化呢？把相同的合成一段，用链表连起来，修改时，按照长度合并就好了。#include<bits/stdc++.h>#define MAXN 2000000using namespace std;int m,n,id,ans,a,b;int A[MAXN+1],first[MAXN+1],nex[MAXN+1];int num[MAXN+1],len[M

题目如果只有两个人，就当然是水题了，只要找出lca就可以了。 那么，三个人呢。其实原理上应该是差不多的，先两两找出lca，得到三个lca，感性的认识一下，答案一定在这三个点之间，枚举一下就好了。其实，还可以优化一下，我们可以发现，三个lca，一定有两个是相同的，那么，答案就是另一个。#include<bits/stdc++.h>#define N 500000using namespace s

题目出现超过一半的数。我们每次取出两个数，如果不相等，就扔掉。最后留下来的数就是答案。剩下的就是细节处理了。#include<cstdio>int n,cnt,tmp,ans,i;char c;inline int read(){ tmp=0;c=getchar(); while(c<'0'||c>'9')c=getchar(); while(c<='9'&&c>='

题目貌似又是一道模板题，kruskal重构树233，合并时按秩合并，深度最多logn，这样以后，连倍增都可以不要，直接走就好了。#include<bits/stdc++.h>#define N 15000#define Max(x,y,z) max(max(x,y),z)using namespace std;int n,m,k,num,x,y;int f[N+1],siz[N+1];i

题目中位数判定日常做法。把比b大的设为1，比b小的设为-1，一样设为0。 区间和如果为0的话，中位数就是b。记录前缀和，如果有相等的就为一组1。 注意长度要为奇数。 要奇偶分开考虑。。。#include<bits/stdc++.h>#define N 100000using namespace std;int n,x,b;int f[N+1];int sum[N+1];int cn

题目有数数学题，关于mod的，这样，我们就可以转化为整除，再用根号n来计算，很是方便。 这题最大取到哪儿让我wa了好久233。#include<bits/stdc++.h>using namespace std;long long n,k,Ans,nex;long long sum(long long x){ return x*(x+1)/2;}int main(){

题目先把每个数的出现次数记录。然后，像筛素数一样把答案筛出来就好了。#define N 100000using namespace std;int n;int A[N+1];int cnt[10*N+1];int Ans[10*N+1];int main(){ scanf("%d",&n); for(int i=1;i<=n;i++) { sca

题目这道题，难道不是一眼秒吗233。当时学校模拟赛，1分钟打完233。 for(int i=1;i<=n;i++) ans+=(n/i)*i;即可。。不过，我为了练习一下欧拉函数233。作个死吧。。#include<bits/stdc++.h>using namespace std;int prime[1000001],d[1000001],sum[1000001],siz

题目同样的，经典的离线处理，线段树。 把前一个标记为1，前一个的前一个标记为0。#include<iostream>#include<algorithm>#include<cstdio>#include<cstdlib>#include<cmath>#include<string>#include<cstring>#define MAXN 1000000using namespac

题目我居然会做noi的题目233。还是比较简单的了，先把所有相等的用并查集放在一个集合中，最后再判断不相等的是否在同一集合中。由于数很大，我们应该先离散化，不过n<=1000000排序有点卡吧，所以我们尝试用map来记录父亲。#include<bits/stdc++.h>using namespace std;#define N 1000000map <int,int> f;int p[N+

题目usaco的题，（吐槽一下，现在uscao不能注册账号，如何科学上网233）。一个常见的思想，线段树处理。第一次出现时标记为1，第二次求和，再取消标记。对着样例画一画即可。#include<bits/stdc++.h>#define N 100000using namespace std;int n,cnt;int pos[N+1],x;int tmp[N+1];//struct T

题目诶，国庆节玩了四天吧，几乎并没有干和学习有关的事233。5号开始做noip历年提高组的题，回想自己去年和前年多么的弱，哎。。 要是当时能看出前年D1T2是tarjan裸题的话，初三就是一等了233。 算了，今年继续努力吧。来刷刷水题。类似中位数的一种做法，然后让区间和为0，做前缀和就好了。学习学习结构体的重载。慢呀。#include<bits/stdc++.h>#define N 5000

题目显然转化为前缀再看相等即可。sj[j]-sj[i]==so[j]-so[i]==si[j]-si[i]转化一下(sj[j]-so[j])-(sj[j]-so[i])==(si[j]-so[j])-(si[i]-so[i])这样，就转化成两维的了，排一下序就可以统计出来了。#include<bits/stdc++.h>#define N 200005using namespace std;i

noi原题，不好评价。题目显然，我们选区间内的点不如就选区间端点，那就想到了离散化。由于要最大减最小，我们枚举最小的区间，依次加大区间，看加到何时该段成立，这就是线段树的操作了。注意枚举大区间时直接从上次开始就好了，稍微一想可得是单增。。。#include<bits/stdc++.h>#define N 600000using namespace std;struct Tree{ in

一道简单题题目朴素的想一想，直接枚举[l,r]就好了，当然会T。那就优化一下呗。考虑一个数的荒谬值，发现大概只与长度有关，我们每次就不加1，0前面的那一个数加1，语文不好233。举个栗子：1234500之后就成了1234600，这样就很快了（貌似有更快做法）。没有代码

题目只有询问，离线处理的典范，把询问按照右端点第一关键词，左端点第二关键词升序排序。 从左往右扫，把当前标记为1，之前的相同颜色取消标记，打右端点后询问。#include<bits/stdc++.h>#define N 50000using namespace std;struct ques{ int l; int r; int id;};ques B[4*N+1]

题目这，这，这不是noip普及组的题吗。。。。。 其实，向左向右传本质上只要向右传就好了，这样，设一个未知数就可以把代价表示出来，之后就是一个绝对值求最值了，这样问题就十分简单了。取中位数即可。#include<bits/stdc++.h>#define N 100000using namespace std;int n,tmp,mid;long long ans;int A[N+1],

题目来来来，数学推公式吧。。。。之后再用求和算一算就好了。。。#include<bits/stdc++.h>#define mod 19940417#define LL long longusing namespace std;LL m,n,ans,tmp1,tmp2,tmp3,last;inline char nc(){ static char buf[100000],*p1=

显然，这样题一定是要排序的，如何拍呢。我们先猜一猜，发现只要按照乘积大小来排序就好了。至于证明，我们这样想，如果只交换两个相邻的数，产生的影响只要它们两个数之间，然后讨论一下就可以了。然后，60%数据保证答案小于10^9，说明什么，之后的数据要上高精度，好麻烦呀。但其实还是可以写的，可以写在一个结构体内，但我好像不会233。就用的函数，貌似很丑，大家凑合看看。#include<bits/stdc++

一句话题意：求最长的波动子序列。其实可以当作一个结论记住，只要贪心地选就好了。注意判断相等情况，再用一个tmp记录一下上一次的大小关系，这样就十分简单了。#include<bits/stdc++.h>using namespace std;int last,now,tmp;int n,cnt;int main(){ scanf("%d",&n); scanf("%d",&l

嗯，这道题，有一种蜜汁优先队列既视感，既然，就用优先队列吧，但是，这样肯定超时，过不了呀。考虑优化一下，其实每次的长度增长都是一样的，我们可以最后再考虑这一增量。这样，长度肯定是单减的，我们开三个队列维护一下就好了。一个存初始的，剩下两个存砍断的。每次的增量差不多就是入队顺序，注意一下细节就好了。貌似bzoj过不了，不知道为何，但是官方数据和洛谷都是可以过的，求大神指正。#include<bits/

题目去年真题呀，原来写过，先粘过来，咦————，PE了。鬼了，，，，交别人的吧。。#include<bits/stdc++.h>#define N 8010000using namespace std;int n,m,q,u,v,t,tmp,mx,id,x,y;int Q[3][N+5],l[3],r[3];inline char nc(){ static char buf[10

题目我们显然发现，一个通道后边比它大的是没有意义的，所以我们把它全变为一样的。如 5 6 4 3 6 2 3 变成 5 5 4 3 3 2 2，就好了，这样就具有单调性，就可以二分解决了。#include<bits/stdc++.h>#define N 300000using namespace std;int n,m,tmp,mx;int A[N+5],x,l,r,mid;inline

题目神题呀，考虑从小往大加入，设目前最长的为x，给它放入，显然，比它小的一定可以放在上面，现在看它的下面可以放什么，显然是一段连续的区间，我们可以二分一下l。但是，又发现，它肯定是单增的，所以用一个变量加一下就好了。#include<bits/stdc++.h>#define N 620000#define mod 1000000009using namespace std;int n,d,

题目转化了一下的0/1背包问题，相当于体积和价值都是A[i],跑一遍就好了。#include<bits/stdc++.h>#define N 500using namespace std;int H,n;int A[N+5];int f[45005];inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; r

题目最近水题刷的有点多呀。。。。第一眼 a[i]|a[j] 的（i，j）个数，什么鬼a[i]或上a[j]后为真233。不是吧，看了hint，好吧，这是整除。记录每个数出现的次数，枚举最小的数，看它的倍数有多少。调和级数（nlogn）#include<bits/stdc++.h>#define N 2000000 using namespace std;int n,x;long long cn

题目双端队列233。把队列开两倍，l与r放在中间就好了。#include<bits/stdc++.h>#define N 100000 using namespace std;int n,cnt,x;int Q[N*2+5],l,r;char opt1,opt2;inline char nc(){ static char buf[100000],*p1=buf,*p2=buf;

题目如果没有k的限制的话，显然全部或起来最大啦。再想，k多小啊，如果n>=k+20，能有的都可以有，全部或起来就最大啦。不然，就简单dp一下。#include<bits/stdc++.h>#define N (1<<18)using namespace std;int n,k,ans;int A[N+5];int f[125][N+5];inline char nc(){ st

题目高精度（滑稽我们发现，只有极限数据爆unsigned long long ，特判一下即可。#include<cstdio>using namespace std;int main(){ int T; scanf("%d",&T); while(T>0) { T--; unsigned long long a,b

题目如果一条弧的长度为周长的一半，它肯定是直角（显然然后，前缀和维护一下就可以了。#include<bits/stdc++.h>#define N 100using namespace std;int n,tmp;int w[N+1];inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; return p1=

题目noip既视感。显然并查集。我们拆点，吧a拆成a与a’，如果是’F’的话，a与b连，否则，a与b’，a’与b。这样就好了。#include<bits/stdc++.h>#define N 5000 using namespace std;int m,n,x,y;int f[N+1],ans,tmp[N+1];char ch;inline char nc(){ static

题目区间开根，区间求和，一眼发现不可做。。。其实0和1，无论开几次都一样，而且一个正数开几次就成一了。 说以所谓的区间修改，毫无意义，直接全部单点改，判断能否继续改变打标记就好了。#include<bits/stdc++.h>#define N 100000#define LL long longusing namespace std;struct Tree{ int l;

题目最短路是很显然的吧。但是，如果每条边都建出来的话，怕是就算是spfa的O（m）都跑不出来（笑）。。。。所以，考虑优化建边，按照x排序，相邻两个之间建边就好了，再来y排序，这样，只有n条边了。#include<cstdio> #include<cstring> #include<algorithm> #include<queue> using namespace std; #

题目一道神题，一开始还想了很多，什么博弈论之类的，233，还是太年轻啊。看了看别人的题解后，茅塞顿开，可以说是很可以的。我们要知道每个杯子下的情况，就要知道每一个（废话），所以就是最小代价知道所有，一个区间[i,j],知道[1,i-1],[1,j],就知道了，而且三个是知二推一，所以我们把0~n连起来就好了（感性的认识一下），想到了什么？对，最小生成树！连i-1到j，再跑一遍就是答案了。#inclu