月阁

可取的区间，为[a,b],[2a,2b],[3a,3b]…… 存在一个k，使得[ka,kb]与[(k+1)a,(k+1)b)]相连，即kb>=(k+1)a-1。 找出k，然后其他各种特判即可。 有一点麻烦。 //#include #include #include #include #include using namespace std; int main() { long lon

题解：http://blog.csdn.net/u010885899/article/details/48131075 #include using namespace std; const int MAXN=131173; int a1[110][MAXN],a2[MAXN][100]; int main() { int i,j,n,m,q; for(i=2;i<MAXN;i++)

由于xy范围比较小，所以可以枚举斜率进行计算。 #include using namespace std; const int MAXN=2020; const int inf=0x3f3f3f3f; const double eps=1e-6; long long x[MAXN],y[MAXN]; double slope[MAXN*MAXN]; int main() { long lo

用x=π/3带入可得。。。。 详细证明方式：Tabris_的博客 //#include #include #include #include #include using namespace std; int main() { long long n; while(~scanf("%lld",&n)) { n%=6; if(n==0) printf("2\n"); e

写个类似的递归过程，以k为目标数。 计算阶乘的时候，打表水过。。。 //#include #include #include #include #include using namespace std; const long long mod=1e9+7; long long a[110]={1,682498929,491101308,76479948,723816384,67347853

只有完全平方数会操作奇数次 //#include #include #include #include #include using namespace std; int main() { long long n,ans; while(~scanf("%lld",&n)) { ans=sqrt(n); printf("%lld\n",n-ans); } }

在区间[i,j]内，元素a[x]对答案的贡献，为a[x]*(2*x-i-j)。 然后通过一堆迷之前缀操作，就能得到答案了。。。 //#include #include #include #include #include using namespace std; void read(unsigned int&a){ char ch;while(!((ch=getchar())

purfer sequence的应用 #include using namespace std; const long long mod=1e9+7; const int MAXN=1000100; long long fac[MAXN],inv[MAXN]; long long powmod(long long x,long long p) { long long ret=1; whi

水题 #include using namespace std; int main() { long long a1,a2,b1,b2,sum1,sum2,s1_2,s1_3,s2_2,s2_3,ans; while(~scanf("%lld%lld%lld%lld",&a1,&b1,&a2,&b2)) { sum1=a1*b1; sum2=a2*b2; s1_2=s1_3=

用数学归纳法容易证明出，sor(x)=2^k-1。因此，计算出k即可。 对于较小的数，可以直接打表计算。（0~90） 对于较大的数，利用斐波那契数的通项公式，忽略其中 ((1-sqrt(5))/2)^n 项，可以计算出答案。 #include using namespace std; const long long mod=1e9+7; const int limit=90; long l

#include using namespace std; void read(int&a){ char ch;while(!((ch=getchar())>='0')&&(ch<='9')); a=ch-'0';while(((ch=getchar())>='0')&&(ch<='9'))a*=10,a+=ch-'0'; } const int MAXN=1000100; i

挺神奇的题目，最快一个人6s过题，第二个人50s过题。。。。 设m个数的和，为sum1，剩下n-m个数的和为sum2。 然后算期望，可以得到，从n-m个数中获得的分数的期望为sum2/m。 然而，从m个数中获得的分数的期望为sum1/m 所以，输入的那些a[i]，完全没有什么用。。。。 #include using namespace std; int main() { long l

坑爹的题意。。。 每次可以对这个石子堆拿走一个或者把这个石子堆分成等量的几份并只取其中一份（不能不变或只剩下一个）。 【只取其中一份】，不是【去掉其中一份】。 题解是这样的，但我总觉得很玄学。。。 最简单的做法就是找规律了，直接搜一下就能获得所有的胜负态。 仔细观察可以发现质数除了2和17就是败的，合数除了16,34和289都是赢的。 感觉这样是不太科学的，那就来讲讲道理。 我们

计算比2^m小的最大的10^k。 #include using namespace std; int main() { int m,ans,cas=1; while(~scanf("%d",&m)) { ans=m*log(2)/log(10); printf("Case #%d: %d\n",cas++,ans); } }

#include using namespace std; const int MAXN=5050; const long long mod=998244353; char ch[MAXN]; double L[MAXN]; int I[MAXN],A[MAXN],B[MAXN],C[MAXN],pd[MAXN]; int x[MAXN],y[MAXN],lenx,leny; int len,l

通过二项式，可以得出： bk=∑ni=0ci∗Cki∗biasn−ib_k=\sum_{i=0}^n{c_i*C_i^k*bias^{n-i}} bk=∑ni=0ci∗i!k!∗(i−k)!∗biasn−ib_k=\sum_{i=0}^n{c_i*\frac{i!}{k!*(i-k)!}*bias^{n-i}} k!∗bk=∑ni=0(ci∗i!)∗biasi−k(i−k)!k!*b_k=\s

出题人绝对星际玩多了。 设表示时刻拥有个SCV的概率，可以得到： 那么时刻生产的晶体矿数量期望为： 当数据量较小时，可以直接写两重循环处理。当数据较大时，需要用矩阵加速。 其中， 会发现会不断变化，而实际上，在时，最多只有种可能性，因此可以分段处理，将相同的情况视为同一段。 若当前段的起始点为，则这一段的终点为，易证明当时，为定值。初始。 #inc...

记录每个i的素因子，以及每个i的倍数j的a[j]之和。容斥一下。由于只考虑是否互质，因此容斥时考虑素因子即可。 #include using namespace std; const int MAXN=100100; vector fac[MAXN]; int sum[MAXN],npri[MAXN],a[MAXN]; int cal1(int x) { int ret=0; while

好题。 如果答案为YES，则m可以表示为： m=a[0]*w^0+a[1]*w^1+…… 如果除了a[0]*w^0，即1、-1或者0，等式右边必然是w的倍数。 也就是说，如果m、m-1或者m+1其中有一个为w的倍数，那么才能使得等式成立。（必要不充分条件） 等式左右两边同时消除a[0]*w^0的影响，再同除w，那么就变成了一个新的等式 m'=a[1]*w^0+a[2]*w^1+……

设dp[i]表示能打败第i-1个怪兽的概率。 dp[i+1]=dp[i]*(sum[i]-i)/(n-i) sum[i] 代表能量值不高于i的怪兽数量。 递推出所有的 dp[i] 后，对每种情况进行求解。 若最多能打败x个怪兽， 其概率为 dp[x]-dp[x+1] 。 #include using namespace std; const long long mod=1e9+7;

素数筛预处理一下就好了。 #include using namespace std; void read(int&a){ char ch;while(!((ch=getchar())>='0')&&(ch<='9')); a=ch-'0';while(((ch=getchar())>='0')&&(ch<='9'))a*=10,a+=ch-'0'; } inline void

，我们简单列下前几组数据 x     1  2  3  4  5  6  7  8  9  10  11  12  13      *  *  *     *       *                * F(x)   1  1  1  2  1  2  2  1  2   2   2   3   1   G(x)   1  2  3     6       11

找规律。。。边界要特殊考虑。。。 #include using namespace std; const long long mod=1e9+7; long long multimod(long long x,long long y,long long mod) { long long ret=0; while(y) { if(y&1) ret=(ret+x)%mod;

矩阵快速幂XJB乱搞一下，没严格证明准确性。 #include using namespace std; const int siz=2; long long mod=1e9+7; struct mtx { long long a[siz][siz]; }unit; mtx multi(mtx m1,mtx m2) { int i,j,k; mtx ret; memset(ret.

(x-n!)*(y-n!)=(n!)^2 分解 n! 的质因数即可。分解时，需要优化下。 #include using namespace std; const int MAXN=1000100; const long long mod=1e9+7; int npri[MAXN],prime[MAXN],sum[MAXN]; long long powmod(long long x,lon

大家都熟悉堆栈操作。一个堆栈一般有两种操作，push和pop。假设所有操作都是合法的并且最终堆栈为空。我们可以有很多方法记录堆栈的操作， （1） 对每个pop操作，我们记录它之前一共有多少个push操作。 （2） 对每个pop操作，我们记录这个被Pop的元素曾经被压上了几个。 对于第二种记录方式，上面压的个数，即为该元素的push和pop操作之间，另外push和pop的元素个数。也就是说，如

对于每种颜色，为了符合题意可以先将最后的球单独考虑。 对于第1种颜色，除去最后的球，有 c[1]-1 个球。在为空的序列上随机放置，有 C(c[i]-1,c[i]-1)=1 种放法，然后将被单独考虑的球放在末尾。 对于第2种颜色， 除去最后的球，有 c[2]-1 个球。在已有c[1]个球的序列上随机放置，有 C(c[1]+c[2]-1,c[2]-1) 种方法，然后将被单独考虑的球放在末尾。

加读入优化，或者等式两边乘以一个列向量，验证是否成立。 #include using namespace std; void read(int&a){ char ch;while(!((ch=getchar())>='0')&&(ch<='9')); a=ch-'0';while(((ch=getchar())>='0')&&(ch<='9'))a*=10,a+=ch-'0';

默慈金数的应用 在一个“网格”上，若限定“每步只能向右移动一格(可以向右上、右下横向向右)，并禁止移动到y=0以下的地方”，则以这种走法用n步从(0,0)移动至(n,0)的可能形成的路径的总数为n的默慈金数。 初始状态： M[0]=1 M[1]=1 M[2]=2 递推公式： M[n+1]=((2n+3)*M[n]+3n*M[n-1])/(n+3) 直接计算比较困难，可以计算

传说中的尺取法。就两个指针移来移去。。。。 #include using namespace std; const int MAXN=10001000; long long a[MAXN]; int main() { long long n,k,t,b,c,p,ans,sum,p1,p2,i; while(~scanf("%lld%lld%lld%lld%lld%lld%lld",&n,

开始以为是数论题，求 x*k=(2y+1)*n 时的最小x值。然后WA了。后来发现，每个硬币翻面次数可以不同，比如样例：7 3 做法参造曾加老师的解法：https://www.zhihu.com/question/26570175/answer/33312310 #include using namespace std; int main() { long long n,k,ans; w

一开始以为询问是在线的，然后各种GG。。。 按照题意，询问是预先确定好的，所以直接询问 是素数的多少次方就行了 。 例如，n=10时，询问 2 2^2 2^3 3 3^3 5 7。 #include using namespace std; const int MAXN=1010; int npri[MAXN],pri[MAXN]; int main() { int i,j,ans,

找规律可以得到，经过k次变换后，a[j]在i上的累加是a[j]*C(i-j+k-1,k-1)。 由于k-1不变，因此可以用递推公式 C(n+1,m)=C(n,m)*(n+1)/(n-m+1) 计算组合数。 #include using namespace std; const long long mod=1e9+7; const int MAXN=5050; long long a[MA

每次修改，都能直接更新答案。数据可以用树状数组或线段树维护。 #include using namespace std; const int MAXN=200100; char op[MAXN]; int discnum; long long disc[MAXN],v[MAXN]; long long c[2][2][MAXN],a[MAXN]; void update(int num,int