SmallSXJ的博客

前言其实网上关于解决这个问题的博客已经有很多了，但是我尝试了很多方法之后都或多或少有不满意的地方，终于自己也摸索出了一套自我感觉相对完美的解决方案，因此发出来供后人参考。正文经过查阅资料和自己摸索尝试后，我总结了下解决用VS写的代码中的中文提交后会乱码的方法。 这个问题的原因在于评测环境和VS的编码不一致，VS默认是以GBK编码代码文件，而评测环境是UTF-8编码，因此本地写好的代码交上去后会在评测机中乱码，所以解决方法就是把VS的编码改为UTF8。 网上的操作大概有这么几种：在文件-高级保存选项

BUAA OS实验环境配置指南-2020年版文章目录BUAA OS实验环境配置指南-2020年版前言为什么要配环境？配置环境过程中的尝试完整配置教程准备工作安装虚拟机安装ELDK编译器64位系统的准备工作正式安装安装gxemul小小的准备工作正式安装安装IDE前言时至2020年，实验指导书上的配环境方法有一部分已经不能使用，网上的资料很多也过时了。笔者踩了无数坑终于把OS环境配置好了，为了避免后人继续踩坑，故将配置经验分享出来。本文也许也会在未来的某一天过时，因此读者阅读时，请注意本文的发布时间。为

点击这里查看原题首先可以考虑，除了2和5之外，10k10^{k}不是任何素数的倍数，因此可以先解决p不为2或5的情况。对从每个位置开始的到末尾结束的子串求一下模p的值，再离散化一下（因为题目没有给出p的范围），这样的话如果两个位置i,j模p的值相同，那么S[i…j-1]就是符合条件的一个子串。莫队处理即可 再来考虑下2和5的情况，可以发现，如果某个数是2或5的倍数，那么它的个位一定也是2或5的倍数

点击这里查看原题DP，gig_{i}表示高度小于i的树的个数，gi=∑i−1j=0f(j)g_{i}=\sum_{j=0}^{i-1}f(j)， fif_{i}表示高度为i的树的个数。 于是可得fi=∑j=1n(nj)∗fji−1∗gn−ji−1f_{i}=\sum_{j=1}^{n} \binom{n}{j}*f_{i-1}^{j}*g_{i-1}^{n-j}此题需要用到高精度#include

点击这里查看原题此题太过丧心病狂，建议看这里 另外这题要学会卡时，一定要加inline才勉强在20.7s内跑过#include<bits/stdc++.h>#define ll long long#define inf 99999999using namespace std;const int M=1005,N=1e6+5;int n,m,a[M<<1],b[M<<1],cnt,pr[N

点击这里查看原题本题是有源汇上下界最小费用流，具体建图如下：从每个点u向它能到达的点v连容量inf费用为w的边，从s’向v连容量1费用w的边，从u向t’连容量1费用0的边从每个非根的点u向t连容量inf费用0的边（因为随时可以跳出这段剧情）从t向s连容量inf费用0的边#include<bits/stdc++.h>#define ll long long#define inf 99999

点击这里查看原题点击这里查看上下界网络流教程这个题很明显就是：从ss到所有点连下界00上界infinf的边（因为可以从任何点出发）从所有出度为零的点到tt连下界00上界infinf的边（最优方案一定是到达该点才结束）所有点向他能到达的点连下界11上界infinf的边（每条边至少走一次）那么实际建图就是这样的：对于每个点计算它的入度减出度的差d[i]d[i]，若d[i]>0d[i]>0，则从s

点击这里查看原题首先暴力判断哪些巫妖可以打到哪些小精灵，先判距离是否小于半径，然后判断树是否阻挡。判断树的方法是先计算出巫妖和小精灵连线的一般式ax+by+c=0，然后据此计算树的圆心到两点连线的距离dis=|ax+by+x|a2+b2√dis=\frac{\left | ax+by+x \right |}{\sqrt{a^{2}+b^{2}}}，是否小于树的半径。 接下来就是二分时间time，源

点击这里查看原题插入操作只会插入到末尾，因此可以用可持久化字典树，rt[i]表示维护的是前i-1个数的异或值，同时维护所有数的异或值tot，因此要得到a[i]~a[n]的异或值就是用rt[i]的查询值异或tot。 那么对于询问而言，我们在字典树上贪心即可/*User:SmallLanguage:C++Problem No.:3261*/#include<bits/stdc++.h>#d

点击这里查看原题建议看这里http://www.acyume.com/archives/1069/*User:SmallLanguage:C++Problem No.:1221*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int N=2005,M

点击这里查看原题 （那个链接里没有题面，题面在这里）单纯形裸题，因为题目中是求最大值，因此需要使用对偶原理/*User:SmallLanguage:C++Problem No.:3112*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const double

点击这里查看原题这道题应该把城市看成点，相邻的城市之间连边，这样会形成一棵树，答案即为树的直径。/*User:SmallLanguage:C++Problem No.:2657*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=2e5+5,

点击这里查看原题费用流经典好题。将每个维修人员拆成n个点，第i个维修人员的第j个点与第k辆车连边表示k是i修的倒数第j辆车，因此费用为v[k][i]*j。 将源点与所有车连容量为1费用为0的边，车与维修人员拆成的所有点连容量为1费用为v[k][i]*j的边，维修人员拆成的所有点与汇点连容量为1费用为0的边 （这道题我分别WA、RE了一次，WA是没注意到读入的顺序是m,n而不是n,m；RE是因为对

点击这里查看原题读入n，转为2进制，每次记录(x,x+1)两个值，如果当前位为1，转化为(2x+1,2x+2)，否则转化为(2x,2x+1)（用二进制来表示x就是n的当前位为1，则在x后面添1，否则添0），即可得到ana_{n}的值 高精度细节很多，要小心/*User:SmallLanguage:C++Problem No.:2656*/#include<bits/stdc++.h>#

点击这里查看原题极其复杂的题目……看了一早上题解才看懂 分类讨论 k=1时，考虑每一位对答案的影响，若至少存在一个数第j位为1，那么异或和中第j位为1的概率为0.5，否则为零。因为取到奇数个第j位为1的数的概率和取到偶数个的概率相等。 k=2时，把异或和转化为2进制，那么每个异或和的平方为∑i∑jbibj∗2i+j\sum _{i} \sum _{j}b_{i}b_{j}*2^{i+j}，那么

点击这里查看原题结论：答案一定是任意一条1~n的路径异或某些环得到的值 接下来是证明为什么每个环都可以取到：如果要取某个环，可以从1出发到这个环上，走一圈后原路回到1，这样就得到了这个环的异或值。 因此将所有的环加入线性基中求基，然后求一条从1到n的路径，贪心的从高位到低位与基异或/*User:SmallLanguage:C++Problem No.:2115*/#include<bi

点击这里查看原题线性基教程https://blog.sengxian.com/algorithms/linear-basis 本题要求第k小的异或和，那么可以将k转为2进制数，对于第i位，如果为1，那么答案异或上g[i]。注意的一点是如果基的元素数小于n，那么存在异或和为0的方案，因此需要将k减1/*User:SmallLanguage:C++Problem No.:3949*/#inc

点击这里查看原题主席树，建立权值线段树进行查询/*User:SmallLanguage:C++Problem No.:3524*/#include<bits/stdc++.h>#define ll long longusing namespace std;const int M=5e5+5;int n,q,cnt,rt[M];struct no{ int ls,rs,su

点击这里查看原题首先可以想到n^2做法，枚举每一条边，切断这条边变成两棵树，对两棵树各O(n)求一遍重心，加和即为答案 但是题目中有一个重要条件，高度h不超过100，因此可以O(h)求重心，即每次向权值和最大的儿子转移（维护时需要维护最大和次大）。 总复杂度O(nh)/*User:SmallLanguage:C++Problem No.:3302*/#include<bits/stdc

点击这里查看原题设球心坐标为（x1,x2,x3,…,xn），某个点的坐标为(y1,y2,y3,…,yn），点到球心的距离为L，那么 L2=(y12−2∗x1∗y1+x12)+(y22−2∗x2∗y2+x22)+(y32−2∗x3∗y3+x32)+...+(yn2−2∗xn∗yn+xn2)L^{2}=({y_{1}}^{2}-2*x_{1}*y_{1}+{x_{1}}^{2})+({y_{2}}^{

点击这里查看原题实际上是求n以内因数最多的数。初看数据范围会以为是数论题，实际上可以贪心，素数的次数相同时小素数比大素数更优。预处理出前若干个素数，发现前10个素数之积已超过2e9，因此可以搜索。/*User:SmallLanguage:C++Problem No.:1053*/#include<bits/stdc++.h>#define ll long long#define inf

点击这里查看原题按秩合并，即深度小的根的fa指向深度大的根；如果深度相同，那么随便合并，之后深度+1/*User:SmallLanguage:C++Problem No.:3674*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=2e5+

点击这里查看原题将所有路径按a升序排序，用LCT维护路径上最大的b，将边权化为点权，如果加入一条边x，其两端点分别为u,v，那么将u与i+x连边，v与i+x连边。 如果(u,v)路径最大的b值大于当前边的b，那么删去b最大的边。 注意：access操作中必须pushup，因为这个调了好久/*User:SmallLanguage:C++Problem No.:3*/#include<bi

点击这里查看原题cnt[i]表示从i出发，经过cnt[i]次nex[i]到达0。于是做两次KMP，第一次求nex[i]和cnt[i]，第二次求i一直nex[i]到达的第一个≤i/2的位置/*User:SmallLanguage:C++Problem No.:5*/#include<bits/stdc++.h>#define ll long long#define inf ((ll)1<

点击这里查看原题二叉哈夫曼树教程：http://blog.csdn.net/shuangde800/article/details/7341289 这里是k叉哈夫曼树，依然采取贪心策略，不过需要注意的是首先要判断(n-1)%(k-1)是否为0，不为0则要添加权值为0的节点直到(n-1)%(k-1)=0 这是因为，每次合并操作会取出k个点，放进1个点，即每次减少k-1个点。而最终目标是使n个点变为

点击这里查看原题首先用后缀数组求出每个串和上个串的公共前缀长度，然后按公共前缀长度由长到短进行合并，用并查集维护。/*User:SmallLanguage:C++Problem No.:131*/#include<bits/stdc++.h>#define ll long long#define inf ((ll)1<<60)using namespace std;const in

点击这里查看原题把蛐蛐视为障碍，其他视为空地，那么对答案有影响的只有蛐蛐周围24个方格（八连通）中的空地，其中，八连通的空地为1级空地，八连通外围的空地为2级空地，然后分类讨论跳蚤数量<2或跳蚤数量等于2且相邻，无解某个蛐蛐周围的方格不在同一连通块内，0某个空地是一级空地且为割点，1n或m=1,1其他情况，2最初用map写的，然后有两个点TLE了，于是只好手写hash 然而调了一早上交

点击这里查看原题贴一个杜教筛教程http://blog.csdn.net/skywalkert/article/details/50500009预处理n^(2/3)+记忆化注意虽然n的范围是2^31-1，没有爆int，但是n+1爆了，所以要用ll/*User:SmallLanguage:C++Problem No.:2301*/#include<bits/stdc++.h>#define

点击这里查看原题经过一系列反演，得到 （看不懂的建议先去做BZOJ 2820） 于是接下来就是要对求前缀和，这个需要分类讨论，具体看代码/*User:SmallLanguage:C++Problem No.:4804*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace s

点击这里查看原题类似于BZOJ 1101，不过要多套个容斥 注意，a和c要先-1再/k（我因为先/k后-1 WA了一次）/*User:SmallLanguage:C++Problem No.:1101*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const

点击这里查看原题和BZOJ 2154类似，但是是多组数据，需要转化 http://blog.csdn.net/PoPoQQQ/article/details/42078725（注意取模的问题，我因为输出答案时没有+mod%mod而WA了一次）/*User:SmallLanguage:C++Problem No.:2693*/#include<bits/stdc++.h>#define

点击这里查看原题太强了……还是看PoPoQQQ的题解吧 于是进行两次分块，求F(x,y)为sqrt(n),求ans也为sqrt(n)，总复杂度O(n)/*User:SmallLanguage:C++Problem No.:2154*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using names

点击这里查看原题设，即f(n)表示的对数； 设，即g(n)表示的对数于是可得 经过莫比乌斯反演可得 将a,b分别除d，得到a’，b’，问题转化为求g(1)的值（下文的d不等于题中的d） 因为d在一定范围内，的值是不变的，所以对求个前缀和，然后分块去做/*User:SmallLanguage:C++Problem No.:1101*/#include<bits/stdc++.h>

点击这里查看原题因为最多有10位，所以最多有2+4+…+1024=2046个数，去掉存在倍数关系的数，对剩余的数做容斥/*User:SmallLanguage:C++Problem No.:1853*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;int hea

点击这里查看原题f[i]表示在不考虑硬币数量的情况下，达到i元的方案数。 于是进行容斥，答案=所有方案数-有一种硬币超出限制（即使用d[i]+1枚硬币）+有两种超出限制-有三种超出限制+有四种超出限制/*User:SmallLanguage:C++Problem No.:1042*/#include<bits/stdc++.h>#define ll long long#define

点击这里查看原题显然，对于每个（x,y）（x,y均不为1），（x,y）能被看到的条件是gcd(x-1,y-1)=1，因此我们需要求gcd(x-1,y-1)=1的对数，由于第一排、第一列分别有一个可以看到的，因此答案还需要加2。对每一排，x<=y中，满足条件的x的个数等于phi(y)；对每一列同理（但是（2,2）被算了两次），因此答案=2*sigma(phi(i))-1+2（1<=i<=n）/*Us

点击这里查看原题求sigma(gcd(i,n))，枚举n的约数k，s(k)表示满足gcd(i,n)=k(1<=i<=n)的i的个数，所以答案为sigma(k*s(k))，求s(k)即为求gcd(i/k,n/k)，即为phi(n/k)。/*User:SmallLanguage:C++Problem No.:2705*/#include<bits/stdc++.h>#define ll lo

点击这里查看原题首先可以得到结果为phi(m!) * (n!/m!)%r，那么难点在于phi(m!)如何求。 因为phi(m!)=m! * (p-1)/p，p为小于m!的质数，所以可以用一个数组ans[i]表示phi(m!)/m!的结果，ans[i]=ans[i-1]，如果i为质数，那么ans[i]=ans[i] * (i-1) * inv[i]%r。另附上递推逆元的证明（以前只会写不会证） By

点击这里查看原题题解见出题人blog http://blog.csdn.net/popoqqq/article/details/43951401/*User:SmallLanguage:C++Problem No.:3884*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace

点击这里查看原题推导很强，建议看这里我最初主要是没看懂线性筛求g[i]的部分，在这里补充下： g[i * prime[j]]中如果prime[j] | i，那么i * prime[j]/pp（pp为素数）只有两种情况：pp==prime[j]，那么g[i * prime[j]]+=mu[i];pp!=prime[j]，那么i * prime[j]/pp一定是prime[j]^2的倍数，根据莫比

点击这里查看原题学习费用流的好题，最开始用了zkw本人的zkw费用流模板，然后过不了样例，被坑一早上；果断换hzw的zkw费用流模板，顺利通过；此外还尝试了下SPFA版费用流，悲惨TLE。（还是黄学长对我们最好）简单说下这个的思路：从汇点出发，倒着做SPFA，每次增广只走是最短路的路径。具体的还是建议去看http://www.cnblogs.com/acha/p/6735037.html这个题的建图

点击这里查看原题扩展Lucas定理教程 此题即为C(n,w1) * C(n-w1,w2) * …%mod/*User:SmallLanguage:C++Problem No.:2142*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;ll mod,n,m,w[

点击这里查看原题这里是教程/*User:SmallLanguage:C++Problem No.:2891*/#include<stdio.h>#include<iostream>#include<iomanip>#include<string.h>#include<algorithm>#include<queue>#include<stack>#include<math.h

点击这里查看原题点击这里查看扩展BSGS教程 扩展BSGS也可以拿来做普通BSGS哦/*User:SmallLanguage:C++Problem No.:1467*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;ll a,b,c;map<ll,ll> mp

点击这里查看原题模板题，这里贴BSGS教程/*User:SmallLanguage:C++Problem No.:2417*/#include<stdio.h>#include<iostream>#include<iomanip>#include<string.h>#include<algorithm>#include<queue>#include<stack>#includ

点击这里查看原题依然好题，不过这题时限比糖果公园短很多，坑点是查询mex值的时候不能O(n)去查，会超时，因此需要sqrt(n)分块，记录每个块内是否每个值都有至少一个。/*User:SmallLanguage:C++Problem No.:4129*/#include<bits/stdc++.h>#define ll long long#define inf 999999999us

点击这里查看原题此题乃莫队系列问题的集大成者，既需要树上莫队，又需要修改，注意以下问题：因为带修改，块大小为n^(2/3)修改时必须严格按时间顺序，对于当前时间大于询问时间的，时间必须倒着遍历；小于的，时间必须正着遍历（没注意到这个问题所以WA了好几次）/*User:SmallLanguage:C++Problem No.:3052*/#include<bits/stdc++.h>

点击这里查看原题建议先看这里的讲解 树上莫队大体思路就是把树分成块，区间与区间之间实现O(sqrt(n))的转换，然后当成莫队去做。/*User:SmallLanguage:C++Problem No.:BZOJ 3757*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace

点击这里查看原题旋转卡壳模板题，建议看这里的讲解旋转卡壳的代码只比凸包多几行，非常好写。/*User:SmallLanguage:C++Problem No.:2187*/#include<stdio.h>#include<iostream>#include<iomanip>#include<string.h>#include<algorithm>#include<queue>

点击这里查看原题半平面交模板题，这个讲解挺好的，http://blog.csdn.net/accry/article/details/6070621/*User:SmallLanguage:C++Problem No.:1279*/#include<stdio.h>#include<iostream>#include<iomanip>#include<string.h>#inclu

点击这里查看原题随机增量法的思路： A：如果遇到某个点i在圆外，那么扩圆后这个点一定在圆上。 B：进行扩圆，如果有之前的点j在当前的圆外，那么i,j一定都在圆上，以i,j两点的连线作为圆的直径。 C：继续检查，如果有j之前的点k在圆外，那么i,j,k三个点一定都在圆上，于是做出三角形ijk的最小覆盖圆/*User:SmallLanguage:C++Problem No.:1336*/

点击这里查看原题f[i][j]表示前i个学校中，第i个学校出j个船的方案数，于是f[i][j]=sigma{f[i’][j’]}(i’ < i , j’ < j ) 但是这样会时间空间双LE，因此需要优化。 考虑到n只有500，因此可以对区间进行离散化，把左闭右闭区间换成左闭右开区间，然后f[i][j]表示第i个学校出的船的数量在区间j的方案数。 此时，状态转移分为两个部分： 小于区间j的，

点击这里查看原题分块思路：记录在块内需要跳几次进入别的块以及进入别的块的位置。/*User:SmallLanguage:C++Problem No.:2002*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=2e5+5;int n,m,

点击这里查看原题由题目要求可知，最终得到的图是一棵树。因为要求类型为0的边恰好有k条，所以先对类型为1的边做生成树，再对类型为0的边做，得到必须有的0边。将这些0边加入，然后优先做类型为0的边，再做类型为1的边即可/*User:SmallLanguage:C++Problem No.:3624*/#include<bits/stdc++.h>#define ll long long#d

点击这里查看原题对于每个点，可以选择守横向或者守纵向。每行为一个点，每列为一个点，于是对于w[i][j]，在i与j+n之间连一条权值为w[i][j]的边，然后去求带一个环的最小生成树，这样刚好有n+m条边，而且每条边都连了一个横行和一个纵行，也就是每条边代表了一个守卫。/*User:SmallLanguage:C++Problem No.:4883*/#include<bits/stdc+

点击这里查看原题其实思路不难，对于每个点分三种情况。没走过这个点，但却有颜色，无解走过这个点，有颜色，那么最早时刻在最后一次经过该点之后走过这个点，没有颜色，那么最晚时刻在最后一次经过该点之前于是，将所有点加入set，倒序模拟一遍，依次删除所有走过的点，同时更新答案即可/*User:SmallLanguage:C++Problem No.:4879*/#include<bits/s

点击这里查看原题思路比较复杂，细节也很多，具体的讲解写在代码的注释里好了/*User:SmallLanguage:C++Problem No.:2811*/#include<bits/stdc++.h>#define ll long long#define inf 999999999#define pii pair<int,int>#define mp make_pairusin

点击这里查看原题对于每个忍者被作为管理者的情况，我们需要知道这个忍者管理的忍者中最多能选多少忍者，而要使选的忍者尽可能多，就需要从薪水最低的忍者开始选。 于是可以建立一颗权值线段树，按DFS序将忍者的薪水依次加入，每次求总薪水小于等于k可以选多少忍者。 注意long long，因为这个WA了好几次/*User:SmallLanguage:C++Problem No.:2809*/#in

点击这里查看原题首先可以想到这题求最短路，那肯定是SPFA（没有负权边，Dijkstra当然也可以啦），难点在于如何构图。 将坐标离散化，然后将矩形的边和顶点分别做不同的标记。从每个矩形的四个顶点出发，将到达的第一个有标记的点（也就是其他矩形上的点）标记为mark[i][j]=1。 将所有mark[i][j]=1或是矩形的四个顶点的点加入，在同一行或同一列的点之间连边，然后做SPFA即可。 因

点击这里查看原题黄学长的题解没完全看懂，留坑待填 http://hzwer.com/6678.html/*User:SmallLanguage:C++Problem No.:2303*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=1e

点击这里查看原题思维好题，具体还是看http://blog.csdn.net/qpswwww/article/details/45334033的吧/*User:SmallLanguage:C++Problem No.:1913*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespac

点击这里查看原题这个题k只有两种情况，因此可以分类来考虑。 k=1时显然将树的直径两端连起来可以省下的路径最多。 k=2时，再建一条路一定会形成一个新的环，因为建的路必须走，所以环上每一条边都需要走一次。环上的是树的直径的边越多，则损失越大（因为重复走了），环上的不是树的直径的边越多，则节省的路径越多。因此需要将树的直径上的每一条边权变为-1，然后再做一次树的直径。/*User:SmallL

点击这里查看原题这题是POJ 2411的升级版。dp[i][j]表示长为i宽为j的方案数，打个表预处理一下。然后枚举列的切割方案，因为一共有m-1条竖线，因此有2^(m-1)种情况。cnt[i]表示按当前的列分割方案，宽为i的矩形的方案数，f[i]表示在当前列分割情况下，前i行的情况数，f[i]=cnt[i]-sigma{f[j]*cnt[i-j]}(0/*User:SmallLanguage:

点击这里查看原题当时校赛的时候没做出来，现在才知道状压DP可以按格点转移。 按格点转移的状压DP可以先参考POJ 2411，这个题不同的地方是按2k进制压位，因为矩形的短边不会超过6，所以最大状态数为8^6，即2^18。对于每一位，如果值小于k，表示在这一列连续出现了1次，如果大于等于k，则表示在这一列连续出现了两次，放置的时候既要考虑横行也要考虑纵行。/*User:SmallLanguage

点击这里查看原题第一问简单，贪心即可，难在第二问如何求字典序最小的。可以考虑，按字典序尝试所有区间，若加入该区间后总的区间数不变，则一定加入该区间，因此需要实现的就是logn查询区间内的区间数。 我们用getans函数来求区间内的区间数，如果要加入一个[l0,r0]的区间，那么需要满足getans(l,r)=getans(l,l0-1)+getans(r0+1,r)+1，其中l为之前加入的区间中小

点击这里查看原题比HDU1565更复杂的一道状压DP，需要多记录一位左上角的情况。每次换行的时候不需要考虑左上角，但是需要将每一位左移一位图转自http://blog.csdn.net/sf____/article/details/15026397 /*User:SmallLanguage:C++Problem No.:2167*/#include<bits/stdc++.h>#def

点击这里查看原题格点转移/*User:SmallLanguage:C++Problem No.:1565*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;int n,p,q,a[20][20];ll f[2][1<<20],ans;void solve(){

点击这里查看原题以往的做法是按行进行转移，需要预处理出各种状态间的转移。一种更快的做法是按格点进行转移，状态表示的是每个已被处理过的格点的下一行的状态。具体可以参考http://blog.csdn.net/sf____/article/details/15026397 /*User:SmallLanguage:C++Problem No.:2411*///#include<bits/st

点击这里查看原题数位DP，最后一位一位输出即可/*User:SmallLanguage:C++Problem No.:4606*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=5e4+5;int n,m,a[M];ll f[M][5]

点击这里查看原题先缩点，然后把负的点权当做边权，用SPFA求最短路（取反即为最长路），在所有有酒吧的点中取dis最大的点即为答案/*User:SmallLanguage:C++Problem No.:1179*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;co

点击这里查看原题s[i][j]表示以(i,j)为右下角的正方形的面积 因为用两条直线可以把矩形分为三个部分且使三个正方形分别在三个矩形内，所以枚举每种分割情况，用分割后每块内的面积最大的正方形的值更新答案 具体分割情况如图： 1.可以通过两条互相垂直的线分成三块，如下图 2.可以通过两条平行的平行的线分成三块，如下图 /*User:SmallLanguage:C++Problem No

点击这里查看原题点数为1000，因此可以使用n^2算法。p[i][j]表示聪聪在i，可可在j，聪聪下一步走的点。先从每个点出发做一次BFS，预处理出p数组。然后记忆化搜索，f[i][j]表示聪聪在i，可可在j，聪聪追上可可的期望步数，于是f[i][j]=sigma{f[i往j走两步到达的点][j或j临近的点]}/(reg[j]+1)+1/*User:SmallLanguage:C++Probl

点击这里查看原题还是看别人的题解吧，很简单易懂/*User:SmallLanguage:C++Problem No.:2318*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;int n;double p,q,f[1005],g[1005];void sol

点击这里查看原题f[i][j]表示玩i局赢j局的概率，则f[i][j]=f[i-1][j] * (1-p)+f[i-1][j-1] * p，于是对于每天而言，失败的概率q为f[n][i] (0<=i<=a*n/b)。 可以得到，第一天失败的概率为q，第二天失败的概率为(1-q) * q，第三天失败的概率为(1-q)^2 * q…… 因此，总的期望ex=q * 1+ (1-q) * q * 2+(

点击这里查看原题f[i]表示一只毛球及其后代在前i天全死掉的概率，则f[i]=p[0]+p[1] * f[i-1]+p[2] * f[i-1]^2+p[3] * f[i-1]^3+…… 因为各个毛球间的生存概率相互独立，所以答案为f[m]^k。/*User:SmallLanguage:C++Problem No.:11021*/#include<bits/stdc++.h>#defin

点击这里查看原题挺神奇的一道题，我自己没完全看懂题解，还是放别人的链接吧。这里/*User:SmallLanguage:C++Problem No.:1426*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;double f[10005],g[10005];i

点击这里查看原题设l为当前期望长度，分为三种情况：当前位为‘x’，l清零当前位为‘o’，ans+=(l+1)^2-l^2，l++当前位为‘?’，那么l可能变成l+1，也可能变成0，因此l的期望变为(l+1)/2，ans+=(2l+1)/2。/*User:SmallLanguage:C++Problem No.:3450*/#include<bits/stdc++.h>#defin

点击这里查看原题先把每个人按k升序排序， f [ i ] 表示完成状态i的最小花费，计算出显示器数量分别为 k [ j ] 时 f [ ( 1 < < m ) - 1 ] 的最小值，ans = min { f [ ( 1 < < m ) - 1 ] + k [ j ] * b }。/*User:SmallLanguage:C++Problem No.:417D */#include<bit

点击这里查看原题f[i][j]表示状态为i，以奶牛j结尾的情况数/*User:SmallLanguage:C++Problem No.:1231*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=(1<<16)+5;int a[20],n

点击这里查看原题因为每加入一天都要确保该天的r值大于等于已选中天的l的最大值，因此维护l值的递减队列。/*User:SmallLanguage:C++Problem No.:2096*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=1e6

点击这里查看原题维护两个单调队列，一个递增，一个递减。/*User:SmallLanguage:C++Problem No.:2096*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=3e6+5;int lx,rx,mx[M],mn[M

点击这里查看原题f[i][j]表示第i张卡在第j回合被轮到（但不一定发动）的概率。 f[i][j]= f[i-1][j] * ( 1-p[i-1] ) ^ j + f[i-1][j+1] * ( 1- ( 1-p[i-1] ) ^ ( j+1 ) ) ,ans+=f[i][j] * ( 1 - ( 1 - p[i] ) ^ j ) * d[i]。/*User:SmallLanguage:C++

点击这里查看原题f[i]表示从i到N的期望，因此f[i]为i能到的各个点的期望+边权的和除k。/*User:SmallLanguage:C++Problem No.:3036*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=1e5+5;

点击这里查看原题f[i][j][k]表示前i个挑战中挑战成功j次，目前背包容量-碎片数为k的概率。 直接开这么大的数组会MLE，因此需要使用滚动数组。/*User:SmallLanguage:C++Problem No.:3029*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using names

点击这里查看原题一道综合了各种数论的神题。其实不难，主要是需要组合在一起运用。 1.费马小定理：求G^P时使用，因为G^(mod-1)%mod=1，所以需要P%=mod-1 2.Lucas定理&中国剩余定理：计算组合数取模时使用，但是本题中mod-1不为素数，因此需要结合中国剩余定理使用（即扩展Lucas定理） 3.扩展欧几里得：中国剩余定理要求逆元/*User:SmallLanguage

点击这里查看原题统计长度在1到N之间，元素大小都在L到R之间的单调不降序列的数量。 设M=R−L+1 长度为i，元素大小在1…M之间的单调不降序列的数量有C ( M−1 , i+M−1 ) 个 ，于是长度在1~N之间的数量有C ( M , N+M ) -1 个。 点击这里查看公式推导/*User:SmallLanguage:C++Problem No.:BZOJ 4403*/#inc

点击这里查看原题类似于最长上升子序列，但是只有m^2做法，不过可以使用一个优化，用mx[i]表示前i项中最大的f[i]值，一旦mx[j]+1<=f[i]就break，实测优化前1920ms，优化后60ms。/*User:SmallLanguage:C++Problem No.:1207*/#include<bits/stdc++.h>#define ll long long#defin

点击这里查看原题用二进制串表示每一行的摆放情况，预处理出各个状态间的转移关系即可。 f[i][j]表示第i行按状态j摆放的方案数。/*User:SmallLanguage:C++Problem No.:1725*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;

点击这里查看原题状压DP，sum[i]表示状态i时的面积和，f[i]表示状态i时可以少操作的次数。 因为可以把所有块合成一大块然后分裂，所以操作最多不超过n+m-2次，而如果有某个子集中的块面积和为0，则可以少操作2次，因此最终答案为n+m-f[1<<(n+m)-1]。/*User:SmallLanguage:C++Problem No.:2064*/#include<bits/stdc

点击这里查看原题f[i][j]表示到第i次，吃完后状态为j的期望，则f[i][j]=上一步的期望+这一步的得分/n。 为了方便整理答案，使用倒推，答案即为f[1][0]。/*User:SmallLanguage:C++Problem No.:1076*/#include<bits/stdc++.h>#define ll long long#define inf 999999999u

点击这里查看原题f[i][j][k]表示到第i行，摆放了j个国王且第i行摆法为k的方法数。 先预处理出所有摆法和摆法之间的转移关系，然后DP/*User:SmallLanguage:C++Problem No.:1087*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace

点击这里查看原题f[i]表示不选i且前面的都合法的最小损失，f[i]=min{f[j]+e[i]}(i-j<=k)/*User:SmallLanguage:C++Problem No.:2442*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int

点击这里查看原题f[i]表示i~n堆叠成的最底层边的最小值，f[i]=min { sum[j-1]-sum[i-1] } ( i < j 且 sum[j-1]-sum[i-1]>=f[j] ) 对于i < j < k，j一定比k更优，如果只能选k，则说明j不满足条件，k满足条件。即，f[j] - sum[j-1]>f[k] - sum[k-1] /*User:SmallLanguage:C+

点击这里查看原题把所有珠子读进来，按位置排序，做单调队列。 讨论区有人说inf要设成2^31-1，于是就把ans设为了0x7fffffff。/*User:SmallLanguage:C++Problem No.:1293*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace

点击这里查看原题做两次单调栈，栈里存序号/*User:SmallLanguage:C++Problem No.:1657*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=5e4+5;int n,h[M],c[M],ans,sum[M],

点击这里查看原题水题/*User:SmallLanguage:C++Problem No.:1660*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=8e4+5;int n,c[M],s[M],tp;ll ans;int main(

点击这里查看原题/*User:SmallLanguage:C++Problem No.:1113*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=25e4+5;int t,x,ans,n,tp,s[M];int main(){

点击这里查看原题维护一个单调递减的栈，如果要加入的元素x大于栈顶元素s[top]，分两种情况： 如果s[top-1]>x，ans+=x； 如果s[top-1]<=x，ans+=s[top-1]。/*User:SmallLanguage:C++Problem No.:1345*/#include<bits/stdc++.h>#define ll long long#define in

点击这里查看原题单调栈模板题，注意答案要乘3。/*User:SmallLanguage:C++Problem No.:3039*/#include<bits/stdc++.h>#define ll long long#define inf 999999999using namespace std;const int M=1e3+5;int a[M][M],s[M],l[M],tp

点击这里查看原题最终得到的一定是一个下凸壳，因此把所有直线以k升序为第一关键字，b降序为第二关键字进行排序。若当前直线能完全覆盖栈顶直线，即i与s[top]的交点在s[top]与s[top-1]的交点左侧，则将栈顶元素弹出。/*User:SmallLanguage:C++Problem No.:1007*/#include<bits/stdc++.h>#define ll long lo