(转) 果巨的模板

最新推荐文章于 2024-09-14 20:47:15 发布
最新推荐文章于 2024-09-14 20:47:15 发布
阅读量452 收藏 1
点赞数
分类专栏： 模版

常用头文件和宏

/*
 #pragma warning (disable: 4786)
 #pragma comment (linker, "/STACK:0x800000")
 */
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <iterator>
#include <utility>
#include <bitset>
using namespace std;

template< class T > T _abs(T n){
    return (n < 0 ? -n : n);
}
template< class T > T _max(T a, T b){
    return (!(a < b) ? a : b);
}
template< class T > T _min(T a, T b){
    return (a < b ? a : b);
}
template< class T > T sq(T x){
    return x * x;
}
template< class T > T gcd(T a, T b){
    return (b != 0 ? gcd<T>(b, a%b) : a);
}
template< class T > T lcm(T a, T b){
    return (a / gcd<T>(a, b) * b);
}
template< class T > bool inside(T a, T b, T c){
    return a<=b && b<=c;
}
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define F(i, n) for(int (i)=0;(i)<(n);++(i))
#define rep(i, s, t) for(int (i)=(s);(i)<=(t);++(i))
#define urep(i, s, t) for(int (i)=(s);(i)>=(t);--(i))
#define repok(i, s, t, o) for(int (i)=(s);(i)<=(t) && (o);++(i))
#define MEM0(addr) memset((addr), 0, sizeof((addr)))
#define MP(x, y) make_pair(x, y)
#define REV(s, e) reverse(s, e)
#define SET(p) memset(pair, -1, sizeof(p))
#define CLR(p) memset(p, 0, sizeof(p))
#define MEM(p, v) memset(p, v, sizeof(p))
#define CPY(d, s) memcpy(d, s, sizeof(s))
#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
#define SZ(c) (int)c.size(
#define PB(x) push_back(x)
#define ff first
#define ss second
#define ll long long
#define ld long double
#define pii pair< int, int >
#define psi pair< string, int >
#define ls l,mid,rt<<1
#define rs mid+1,r,rt<<1|1
#define debug(x) cout << #x << " = " << x << endl

字符串算法

KMP算法
int s[MAXN],t[MAXM];
int m,n;
int nxt[MAXM];
void getnext(){
    nxt[0] = -1;
    int i = 0, j = -1;
    while(i < m){
        while(j != -1 && t[i] != t[j]) j = nxt[j];
        if(t[++i] == t[++j]) nxt[i] = nxt[j];
        else nxt[i] = j;
    }
}
int kmp(){
    int ans = -1;
    getnext();
    int i = 0,j = 0;
    while(i < n){
        while(j != -1 && s[i] != t[j]) j = nxt[j];
        i++,j++;
        if(j >= m){
            ans = i - m + 1;
            return ans;
        }
    }
    return ans;
}
扩展KMP
/*
* 给出模板串S和串T，长度分别为Slen和Tlen，要求在线性时间内，对于每个S[i]（0<=i<Slen)，求
*  出S[i..Slen-1]与T的最长公共前缀长度，记为extend[i]（或者说，extend[i]为满足S[i..i+z-1]==T[0..z-1]的最大的z值）。扩展KMP可以用来解决很多字符串问题，如求一个字符串的最长回文子串和最长重复子串。

例如:hdu4333
给一个数字，每一次把它的最后一位拿到最前面，一直那样下去，分别求形成的数字小于，等于和大于原来数的个数。
例如：134可以形成134，341，413三个数，所以分别是1，1，1。

分析：
由于长度为len的字符串形成题目要求的串的个数为len，那么我们可以把原来的两个串T连接起来形成字符串S，然后找S的每
个后缀的前len个元素即可。

这里主要是如何比较的问题，对于字符串的比较，我们可以先求出他们的最长公共前缀长度，然后只需要比较一次就可以知道结果了。那么最长公共前缀怎么求，由于这里是一个串T与另一个串S，来求S的所有后缀与T的最长公共前缀长度，所以用扩展
KMP。如果extend[i]>=len，就说明与原来的相等了，否则如果S[i+extend[i]]<T[extend[i]]就说明小于，否则就是大
于。
*/
#include <stdio.h>
#include <string.h>
#define N 500010

int next[N];
int nextval[N];
int extend[N];

char S[N];
char T[N];

void GetNext(char *T)
{
    int a=0;
    int Tlen=strlen(T);
    next[0]=Tlen;
    while(a<Tlen-1&&T[a]==T[a+1]) a++;
    next[1]=a;
    a=1;
    for(int k=2;k<Tlen;k++)
    {
        int p=a+next[a]-1,L=next[k-a];
        if((k-1)+L>=p)
        {
            int j=(p-k+1)>0? p-k+1:0;
            while(k+j<Tlen&&T[k+j]==T[j]) j++;
            next[k]=j;
            a=k;
        }
        else next[k]=L;
    }
}

void GetExtend(char *S,char *T)
{
    int a=0;
    GetNext(T);
    int Slen=strlen(S);
    int Tlen=strlen(T);
    int MinLen=Slen<Tlen? Slen:Tlen;
    while(a<MinLen&&S[a]==T[a]) a++;
    extend[0]=a;
    a=0;
    for(int k=1;k<Slen;k++)
    {
        int p=a+extend[a]-1,L=next[k-a];
        if((k-1)+L>=p)
        {
            int j=(p-k+1)>0? p-k+1:0;
            while(k+j<Slen&&j<Tlen&&S[k+j]==T[j]) j++;
            extend[k]=j;
            a=k;
        }
        else extend[k]=L;
    }
}

void NextVal(char *T)
{
    int i=0,j=-1;
    nextval[0]=-1;
    int Tlen=strlen(T);
    while(i<Tlen)
    {
        if(j==-1||T[i]==T[j])
        {
            i++;
            j++;
            if(T[i]!=T[j]) nextval[i]=j;
            else  nextval[i]=nextval[j];
        }
        else j=nextval[j];
    }
}

int main()
{
    int Slen,Tlen,i;
    int t,tt=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",S);
        strcpy(T,S);
        strcat(S,T);
        GetExtend(S,T);
        Tlen=strlen(T);
        Slen=strlen(S);
        NextVal(T);
        int MOD=Tlen-nextval[Tlen];
        int temp=1;
        if(Tlen%MOD==0) temp=Tlen/MOD;
        int ans1=0,ans2=0,ans3=0;
        for(i=0;i<Tlen;i++)
        {
            if(extend[i]>=Tlen) ans2++;
            else if(S[i+extend[i]]<T[extend[i]]) ans1++;
            else ans3++;
        }
        printf("Case %d: %d %d %d\n",tt++,ans1/temp,ans2/temp,ans3/temp);
    }
    return 0;
}
Manacher 最长回文子串
/*
 * 求最长回文子串 
 * 例如今年多校一道题
 */
//给一个序列，让求其最大子序列
//这个序列由三段组成，第一段和第二段对称,第一段和第三段一样
//manacher算法求得p[i]
//枚举第二段的起点和长度，得到结果
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std ;
const int maxn = 2e5 + 10 ;
int str[maxn] ;
int p[maxn] ;
void pk(int n)
{
    int i;
    int mx = 0;
    int id=0;
    for(i=0; i<n; i++)
    {
        if( mx > i )
            p[i] = min( p[2*id-i], mx-i );
        else
            p[i] = 1;
        for(; str[i+p[i]] == str[i-p[i]] && i - p[i] >= 0 && i + p[i] < n; p[i]++);
        if( p[i] + i > mx )
        {
            mx = p[i] + i;
            id = i;
        }
    }
}
int main()
{
    int t  ;
    int cas = 0 ;
    int  n ;
    scanf("%d" , &t) ;
    while(t--)
    {
        scanf("%d" , &n) ;
        for(int i = 0;i <= 2*n+1;i++)
        p[i] = 0 ;
        int len = 0 ;
        str[len++] = -1 ;
        for(int i = 1;i <= n;i++)
        {
            scanf("%d" , &str[len++]) ;
            str[len++] = -1 ;
        }
        int ans = 1 ;
        pk(len) ;
        for(int i = 2;i < len-1 ;i += 2)
          for(int j = ans;j <= p[i] ;j += 2)
            if(p[i + j -1]>= j)
              ans = j;
        ans = ans/2*3 ;
        printf("Case #%d: ",++cas) ;
        cout << ans << endl;
    }
    return 0 ;
}
字符串最小表示
//O(n),返回最小表示字符串起始位置
//最大表示把s[i+k] > s[j+k]改<,后一句同
string s;
cin >> s;      
int L = s.length();
s = s+s;
int i = 0, j = 1,k;
while(i<L && j<L){
   for(k=0;k<L;k++)
       if(s[i+k] != s[j+k])break;
           if(k == L)break;
   if(s[i+k]>s[j+k])i=i+k+1;
   else if(s[i+k]<s[j+k])j=j+k+1;
   if(i==j)j++;
}
cout << min(i,j) << endl;
字符串hash
//选择大素数
字符数组版:
unsigned int BKDRHash(char *str)  //处理字符数组
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;
    while (*str)
    {
        hash = hash * seed + (*str++);
    }
    return (hash & 0x7FFFF);  //1111111111111111111
}
字符串版:
unsigned int BKDRHash(string str)  //处理字符串
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0,i=0,len=str.length();
    while (i<len)
    {
        hash = hash * seed + str[i++];
    }
    return (hash & 0x7FFFF);  //0x7FFFF为十六进制，=524287=219-1
}

数学

素数筛选
//prime[0]存素数个数
int prime[MAXN+5];
void init(){
    memset(prime,0,sizeof(prime));
    for(int i = 2; i <= MAXN ; i++){
        if(!prime[i]) prime[++prime[0]] = i;
        for(int j = 1;j <= prime[0] && prime[j] <= MAXN/i;j++){
            prime[prime[j]*i] = 1;
            if(i % prime[j] == 0) break;
        }
    }
}
大区间素数筛选
//poj 2689
/*
输入区间[l,u]，其中l和u为int范围的整数，区间最大为1000000。求出[l,u]中，相邻素数只差最大和最小的素数对。当存在多个时，输出较小的素数对。
题解：l,u范围太大，不能直接求int范围的素数。而区间间隔比较小，只有1e6，而且对于int范围内的合数来说，最小质因子必定小于2^16。所以可以求出[l,u]中合数，转而求出素数，然后暴力枚举所有素数对即可。
如何求区间[l,u]中的合数：上面已经说了，合数的最小质因子小于2^16，即小于50000。所以先求出小于50000的所有素数。则区间[l,u]中的合数，必定可以表示为小于50000的素数的倍数。对于素数p来说，令a=(l-1)/p+1,b=u/p。则枚举j=a到b，j*p可以枚举所有[l,u]中质因子含有p的合数。枚举所有小于50000的素数，然后用上述方式枚举倍数，即可找出[l,u]中所有的合数。
由于l,u在int范围，所以不能直接用数组标记。需要加个偏移量，取l，则数组大小小于1e6的f[0,u-l]，即可标记。
接着枚举区间中所有的相邻素数对即可。
特别注意：由于1不是小于50000的素数的倍数，所以在与合数相斥中，会被当成素数。需要特别处理下。
*/
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
const int INF=1e9;
const int maxn=5e4+10;
const int maxm=1e6+10;
int l,u,prime[maxn],vis[maxn],f[maxm],t;
void init()//求出50000内的素数，int范围内的合数最小质因子必定小于2^16。
{
    int i,j,k,m;
    t=0;
    m=(int)sqrt(maxn+0.5);
    memset(vis,0,sizeof(vis));
    for(i=2;i<=m;i++)
    {
        if(!vis[i])
        {
            for(j=i*i;j<maxn;j+=i)
            vis[j]=1;
        }
    }
    for(i=2;i<maxn;i++)if(!vis[i])prime[t++]=i;
}
int main()
{
    init();
    while(cin>>l>>u)
    {
        if(l==1)l=2;//注意l=1会出问题。
        int i,j,k,a,b;
        memset(f,0,sizeof(f));
        for(i=0;i<t;i++)
        {
            a=(l-1)/prime[i]+1;
            b=u/prime[i];
            for(j=a;j<=b;j++)if(j>1)f[j*prime[i]-l]=1;//[l,u]区间小于1e6，而l，u数值范围为int，所以偏移l们就能用数组存了
        }
        int p=-1,max_ans=-1,min_ans=INF,x1,y1,x2,y2;
        for(i=0;i<=u-l;i++)//暴力枚举。。
        {
            if(f[i]==0)
            {
                if(p==-1){p=i;continue;}
                if(max_ans<i-p){max_ans=i-p;x1=p+l;y1=i+l;}
                if(min_ans>i-p){min_ans=i-p;x2=p+l;y2=i+l;}
                p=i;
            }
        }
        if(max_ans==-1)cout<<"There are no adjacent primes."<<endl;
        else cout<<x2<<","<<y2<<" are closest, "<<x1<<","<<y1<<" are most distant."<<endl;
    }
    return 0;
}
合数分解
//fatCnt为因子个数
//factor[i][0]是第i个素因子,factor[i][1]是第i个素因子的个数
int prime[MAXN+5];
void init(){
    memset(prime,0,sizeof(prime));
    for(int i = 2; i <= MAXN ; i++){
        if(!prime[i]) prime[++prime[0]] = i;
        for(int j = 1;j <= prime[0] && prime[j] <= MAXN/i;j++){
            prime[prime[j]*i] = 1;
            if(i % prime[j] == 0) break;
        }
    }
}
long long factor[100][2];
int fatCnt;
int getFactors(long long x){
    fatCnt = 0;
    long long tmp = x;
    for(int i=1;prime[i]<=tmp/prime[i];i++){
        factor[fatCnt][1] = 0;
        if(tmp % prime[i] == 0){
            factor[fatCnt][0] = prime[i];
            while(tmp%prime[i] == 0){
                factor[fatCnt][1]++;
                tmp/=prime[i];
            }
            fatCnt++;
        }
    }
    if(tmp != 1){
        factor[fatCnt][0] = tmp;
        factor[fatCnt++][1] = 1;
    }
    return fatCnt;
}
扩展欧几里得算法(求解 ax+ay = gcd 的解和逆元素)
//返回d = gcd(a,b);和对应等式中的x,y
long long extend_gcd(long long a,long long b,long long &x,long long &y){
    if(a == 0 && b == 0) return -1;
    if(b == 0) {x = 1; y = 0; return a;}
    long long d = extend_gcd(b,a%b,y,x);
    y -= a/b*x;
    return d;
}
//求逆元素
//ax = 1(mod n)
long long mod_reverse(long long a,long long n){
    long long x,y;
    long long d = extend_gcd(a,n,x,y);
    if(d == 1) return (x % n + n) % n;
    else return -1;
}
逆元
//a < m 且 a 和 m 互质
long long inv(long long a,long long m){
    if(a == 1)return 1;
    return inv(m%a,m)*(m-m/a)%m; 
}

//欧拉函数,mod为素数且a和m互质,pow_m为快速幂取mod
long long inv(long long a,long long mod) {
    return pow_m(a,mod-2,mod);
}
欧拉函数
//筛欧拉函数
int euler[MAXN+5];
long long eular(long long n){
    memset(euler,0,sizeof(euler));
    euler[1] = 1;
    for(int i=2;i <= MAXN;i++){
        if(!euler[i]){
            for(int j = i; j <= MAXN ; j += i){
                if(!euler[j]) euler[j] = j;
                euler[j] = euler[j] / i * (i-1);
            }
        }
    }
}

//求单个欧拉函数
long long euler(long long n){
    long long ans = n;
    for(int i = 2;i * i <= n;i++){
        if(n % i == 0){
            ans -= ans / i;
            while(n % i == 0) n /= i;
        }
    }
    if(n > 1) ans -= ans/n;
    return ans;
}

//线性筛求出欧拉函数和素数表
bool check[MAXN + 10];
int phi[MAXN + 10];
int prime[MAXN + 10];
int tot;
void phi_ans_prime_table(int N){
    memset(check,false,sizeof(check));
    phi[1] = 1;
    tot = 0;
    for(int i = 2;i <= N;i++){
        if(!check[i]){
            prime[tot++] = i;
            phi[i] = i - 1;
        }
        for(int j = 0;j < tot;j++){
            if(i * prime[j] > N) break;
            check[i * prime[j]] = true;
            if(i % prime[j] == 0){
                phi[i * prime[j]] = phi[i] * prime[j];
                break;
            }else{
                phi[i * prime[j]] = phi[i] * (prime[j] - 1);
            }
        }
    }
}
数论中若干结论
1.素数定理:给你一个整数N(N<1e9)，如果小于10^N的整数中素数的个数为π(N)，求π(N)的位数是多少。 
思路：题目的数据量很大，直接求肯定TLE，所以考虑素数定理。 
素数定理：记π(N)是<=N的素数个数，那么有π(N)跟N/ln(N)是等阶无穷小,极限为1
一个数x的位数可以用lg(x)+1来求，所以本题中lg(N/InN)+1就是所求，因为N=10^N，所以位数=lg(10^N)-lg(In(10^N))+1=N-lgN-lg(In(10))+1.
int main()
{
    double n,m;
    while(~scanf("%lf",&n)) {
        m=(n-log10(n)-log10(log(10)));
        printf("%d\n",(int)m+1);
    }
    return 0;
}
2.定理:设a > 1, m,n > 0,那么有gcd(a^m-1,a^n-1) = a^gcd(m,n) - 1
3.定理:设a > b, gcd(a,b) = 1, 那么gcd(a^m - b^m,a^n - b^n) = a^gcd(m,n) - b^gcd(m,n)
4.定理:设G = gcd(C(n,1),C(n,2),....C(n,n-1)),那么
    (1)n为素数,那么答案就是n
    (2)n为多个素因子,那么答案就是1
    (3)n只有一个素因子,那么答案就是该素因子
5.定理:设F_n为Fib数,那么有gcd(F_m,F_n) = F_gcd(m,n)
6.定理:给定两个互素的正整数A和B,那么它们最大不能组合的数为A*B-A-B,不能组合的数的个数为
num = (A - 1)*(B - 1) / 2
7.定理:sigma(gcd(i,N)){i:1~N} = sigma(phi[N/d]){d|N}
8.定理:(n+1)*lcm(C(n,0),C(n,1),...,C(n,n-1),C(n,n)) = lcm(1,2,3,...,n+1)
9.定理:任何n个连续的正整数的乘积均可被n!整除
两个推广结论:(1)如果p是素数,那么C(p,1),C(p,2)...C(p,p-1)均可被p整除
           (2)如果p是素数,那么有(x+y...+w) = (x^p + y^p + ... w^p)(mod p)


lucas(组合数取MOD,复杂度跟mod相关)
网赛题目:
#include<iostream>  
#include<cstdio>  
#include<algorithm>  
#include<cmath>  
#include<cstring>  
#include<queue>  
#include<string>  
typedef long long LL;  
using namespace std;  
LL p;  
LL A[12],M[12];  
LL mod_mul(LL a,LL b,LL mod)  
{  
    LL ret=0;  
    while(b)  
    {  
        if(b&1) ret=(ret+a)%mod;  
        a=(a+a)%mod;  
        b>>=1;  
    }  
    return ret;  
}  
LL qpow(LL a,LL b)  
{  
    LL ans;  
    for(ans=1;b;b>>=1,a=a*a%p)  
        if(b&1)ans=mod_mul(ans,a,p);  
    return ans;  
}  
LL getc(LL n,LL m)  
{  
    if(n<m)return 0;  
    if(m>n-m)m=n-m;  
     LL  s1=1,s2=1;  
    for(LL i=0;i<m;i++)  
    {  
        s1=mod_mul(s1,(n-i),p);  
        s2=mod_mul(s2,(i+1),p);  
    }  
    return mod_mul(s1,qpow(s2,p-2),p);  
}  
LL lucas(LL n,LL m)  
{  
    if(m==0)return 1;  
    return mod_mul(getc(n%p,m%p),lucas(n/p,m/p),p);  
}  

LL Extended_Euclid(LL a,LL b,LL &x,LL &y)     
{  
    LL d;  
    if(b==0)  
    {  
        x=1;y=0;  
        return a;  
    }  
    d=Extended_Euclid(b,a%b,y,x);  
    y-=a/b*x;  
    return d;  
}  

LL crt(LL a[],LL w[],LL len)      
{  
    LL i,d,x,y,m,n,ret;  
    ret=0;  
    n=1;  
    for (i=0;i<len;i++)  
        n*=w[i];  
    for (i=0;i<len;i++)  
    {  
        m=n/w[i];  
        d=Extended_Euclid(w[i],m,x,y);  
        //ret=(ret+y*m*a[i])%n;  
        ret=ret%n+mod_mul(mod_mul(y,m,n),a[i],n);  
    }  
    return (n+ret%n)%n;  
}  

int main()  
{  

    LL n, m,k;  
    int t;  
    scanf("%d",&t);  
    while(t--)  
    {  
        scanf("%I64d%I64d%I64d", &n, &m, &k);  
        p=1;  

        for(LL i=0;i<k;i++)  
        {  
            scanf("%I64d",&p);  
            M[i]=p;  
            A[i]=lucas(n, m);  
        }  

        printf("%I64d\n",crt(A,M,k));  
    }  
    return 0;  
}
//注意上面的快速乘法是取mod版本
//对于不取mod版本,防止爆ll
ll calc(ll a,ll b){
    ll ans = 1;
    while(b){
        if(b & 1){
            double judge = 1.0 * INF / ans;
            if(a > judge) return -1;
            ans *= a;
        }
        b >>= 1;
        if(a > INF1 && b > 0) return -1;
        a = a * a;
    }
    return ans;
}
常见的组合数模型
第一类Stirling数 s(p,k) 
s(p,k)的一个的组合学解释是：将p个物体排成k个非空循环排列的方法数。
s(p,k)的递推公式： s(p,k)=(p-1)*s(p-1,k)+s(p-1,k-1) ,1<=k<=p-1
边界条件：s(p,0)=0 ,p>=1  s(p,p)=1  ,p>=0

递推关系的说明：
考虑第p个物品，p可以单独构成一个非空循环排列，这样前p-1种物品构成k-1个非空循环排列，方法数为s(p-1,k-1)；
也可以前p-1种物品构成k个非空循环排列，而第p个物品插入第i个物品的左边，这有(p-1)*s(p-1,k)种方法。

第二类Stirling数 S(p,k)

S(p,k)的一个组合学解释是：将p个物体划分成k个非空的不可辨别的（可以理解为盒子没有编号）集合的方法数。
k!S(p,k)是把p个人分进k间有差别(如：被标有房号）的房间(无空房）的方法数。
　　 
S(p,k)的递推公式是：S(p,k)=k*S(p-1,k)+S(p-1,k-1) ,1<= k<=p-1
边界条件：S(p,p)=1 ,p>=0    S(p,0)=0 ,p>=1
　　
递推关系的说明：
考虑第p个物品，p可以单独构成一个非空集合，此时前p-1个物品构成k-1个非空的不可辨别的集合，方法数为S(p-1,k-1)；
也可以前p-1种物品构成k个非空的不可辨别的集合，第p个物品放入任意一个中，这样有k*S(p-1,k)种方法。
　　
第一类斯特林数和第二类斯特林数有相同的初始条件，但递推关系不同。

Bell数

Bell数的定义：第n个Bell数表示集合{1,2,3,...,n}的划分方案数，即：B[0] = 1;

每一个Bell数都是第二类Stirling数的和，即

第二类Stirling数的意义是：S(n,k)表示将n个物体划分成k个非空的不可辨别的（可以理解为盒子没有编号）集合的方法
数。很明显，每一个Bell是对应的第二类Stirling数之和。

Bell三角形的构造方法：
第一行第一个元素是1，即a[1][1] = 1
对于n>1，第n行第一项等于第n-1行最后一项，即a[n][1] = a[n-1][n-1];
对于m,n>1，第n行第m项等于它左边和左上方的两个数之和，即a[n][m] = a[n][m-1] + a[n-1][m-1];
Bell数的预处理:
void Bell(int T[],int MOD)
{
    B[0] = 1;
    B[1] = 1;
    T[0] = 1;
    for(int i=2;i<N;i++)
    {
        T[i-1] = B[i-1];
        for(int j=i-2;j>=0;j--)
            T[j] = (T[j]+T[j+1])%MOD;
        B[i] = T[0];
    }
}

错排公式

如lightoj 1095 求n个数的排列,前m个中有k个在自己位置上的方法数
设D[n]为n个元素的错排数. 
于是我们有D[1] = 0 D[2] = 1； 
D[n] = (D[n-1] + D[n-2]) * (i-1) 
考虑问题本身,我们首先从前m个数选k个数不动.即C(m,k)。对于没有选的前m中的m-k个数肯定是参与了错排,而后面n-m个数中参加错排的个数不定,所以我们枚举一个后面n-m个数中选出i(0 <= i <= n - m)个数有没有参与错排。总共就有n-k-i参与了错排. 
综上所述,ans公式就是C[m][k] * sigma(C[n-m][i] * D[n-k-i]) % mod; 
预处理出组合数和错排数,然后就乱搞了。 
注意有个坑点。。D[0]要赋值为1

int m,n,k;
ll D[maxn+5];
ll C[maxn+5][maxn+5];
void init(){
    C[0][0] = 1;
    rep(i,1,maxn){
        C[i][0] = C[i][i] = 1;
        rep(j,1,i-1) C[i][j] = (C[i-1][j-1] + C[i-1][j]) % mod;
    }
    D[1] = 0,D[0] = D[2] = 1;
    rep(i,3,maxn) D[i] = (i-1) * (D[i-1] + D[i-2]) % mod;
}
ll solve(int n,int m,int k){
    ll ans = 0;
    rep(i,0,n-m) ans = (ans + C[n-m][i] * D[n-k-i]) % mod;
    return ans * C[m][k] % mod; 
}
int main(){
    //READ("in.txt");
    int t,kase = 1;
    scanf("%d",&t);
    init();
    while(t--){
        scanf("%d%d%d",&n,&m,&k);
        printf("Case %d: %llu\n",kase++,solve(n,m,k));
    }
    return 0;
}
博弈论

Bash Game——巴什博奕
只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。
(1)最后取光者得胜。
bool solve(int n,int m){return n%(m+1);}
(2)最后取光者失败。
bool solve(int n,int m){return (n-1)%(m+1);}
Wythoff Game——威佐夫博奕
有两堆各若干个物品，两个人轮流从某一堆或同时从两堆中取同样多的物品，规定每次至少取一个，多者不限。
(1)最后取完者获胜。
const double fai=(sqrt(5.0)+1)*0.5;//黄金分割数
bool solve(int a,int b){
if(a>b)swap(a,b);
int k = b - a;
return a!=int(k*fai);
}
(2)最后取完者失败。（试解/没刷过例题）
const double fai=(sqrt(5.0)+1)*0.5;//黄金分割数
bool solve(int a,int b){
if(a>b)swap(a,b);
if(a==0)return b!=1;
if(a==2)return b!=2;
return b!=int(a/fai)+a+1;
}
树上删边游戏：
给你一些圆圈的圆心坐标和半径,保证这些圆圈是包含或者相离的。现在两个人做博弈操作,拿掉一个圆圈,然后这个圆圈所包含的都要移除掉。两个人一直拿下去,直到某个人找不到一个可以移除的圈他就输了。
思路
学习的姿势。这是一个树上删边游戏模型；
首先按照半径升序排序,然后对于每一个圆找第一个包含它的圆,然后连一条边。建树完成。
叶子节点的SG值为0;
中间节点的 SG 值为它的所有子节点的 SG 值加 1 后的异或和;
这里可以建立成森林或者直接一棵树,没有太大区别。建成一棵树估计要方便一些吧。 

struct Point{
    int x,y,r;
}point[MAXN];
int cmp(Point a,Point b){
    return a.r < b.r;
}
int dist(int i,int j){
    return (ll)(point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y-point[j].y) * (point[i].y - point[j].y);
}
struct Edge{
    int to,next;
}edge[MAXN];
int head[MAXN],tail;
void add(int from,int to){
    edge[tail].to = to;
    edge[tail].next = head[from];
    head[from] = tail++;
}
int dfs(int from){
    int res = 0;
    for(int i = head[from];i != -1; i = edge[i].next)
        res ^= dfs(edge[i].to)+1;
    return res;
}
int main(){
    //READ("in.txt");
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        rep(i,0,n-1){
            scanf("%d%d%d",&point[i].x,&point[i].y,&point[i].r);
        }
        sort(point,point+n,cmp);
        tail = 0;
        MEM(head,-1);
        rep(i,0,n-1){
            int flag = 0;
            rep(j,i+1,n-1){
                int rr = (ll)point[j].r * point[j].r;
                int dis = dist(i,j);
                if(rr > dis){  
                    flag = 1;
                    add(j,i);
                    break;
                }
            }
            if(!flag) add(n,i);
        }
        if(dfs(n) != 0)
            puts("Alice");
        else
            puts("Bob");
    }
    return 0;
}
dont_say_sorry
关注
专栏目录
拉肚子差评回复模板_吃了拉肚子的差评怎么回复？
weixin_42682925的博客
12-24 2万+
原标题：吃了拉肚子的差评怎么回复？很多商家有一个误区，就是以为回复差评真的是跟差评的用户进行沟通。这是完全错误的认识，实际上给你差评的用户90%不会再来你这家店消费了，也没有那么在乎你怎么解释。而真正会认真看你回复的往往是那些第一次进店想下单的用户去看的，所以回复差评最忌讳的就是千篇一律，不管客户说什么，你都是一个模板回复，给看的人一种你根本就没读过这些差评的错觉，对店铺的形象会产生负面影响。今天...
什么是自适应模板？自适应模板有什么优点缺点
苹果cms10好看的模板
02-18 1239
1.背景介绍 自适应模板，顾名思议，网站本身是现成做好的自适应网站。用户获得自适应模板后，只需把原本网站的素材改成自己的东西，网站就能实现电脑、手机的自适应，不同终端获得同样的呈现效果。 现在人们通过手机浏览网页占了大多数，随着浏览方式的改变，网页实现多终端自适应，无论对于避免工程师无谓的重复劳动或者是项目管理的便捷性上来说重要性都是十分巨大的。 2.知识剖析 由于移动设备越来...
水果超市php代码,【PHP源码】ECSHOP仿本来生活网商城源码，水果特产生鲜超市模板源码，含微信分销手机版...
weixin_29817863的博客
03-13 680
仿本来生活商城多商户多地区B2B2C电商系统(PC+WAP+微信)swtshop这套源码是由ecshop二次开发而来，pc+wap+app+微信端，挺不错的，外面卖一千多。特色说明：ECSHOP官方本来生活网2017水果生鲜超市模板，生鲜产品电子商务，简称生鲜电商，指用电子商务的手段在互联网上直接销售生鲜类产品，如新鲜果蔬、生鲜肉类等。近几年，国内频发食品安全事件，导致很多消费者产生了对品质高、安...
基于vue.js前后端分离 水果商城毕业设计源代码开题报告
杭州.黄老师
09-14 1521
他们运用先进的技术手段，如物联网、区块链等，实现对水果从采摘到配送全过程的追溯和监控，确保水果的品质和安全。同时，通过收集用户的购物习惯和偏好数据，系统能够为用户提供更加精准的商品推荐和优惠活动，提升用户的购物体验和满意度。国内在水果商城系统的技术实现上取得了显著进展。一方面，只要有能上网的电脑，系统的管理员在任何地方任何时候都可以管理，工作效率进一步提高从而节省人力、物力，只要会打字即可，不需要很高的学历；基于Vue.js的水果商城系统能够满足国外消费者的购物需求，提供丰富的水果种类和便捷的购物体验。
velocity模板引擎帮助
woaini886353的博客
04-27 486
Velocity用户手册是帮助页面设计者和内容提供者认识Velocity和其简单而功能强大的脚本语言――Velocity模板语言（VTL）。在手册上的许多例子，都是用Velocity插入动态的内容到网页上，但是所有的VLT例子都能应用到其他的页面和模板中。 感谢使用 Velocity！ Velocity是什么？ Velocity是一个基于java的模板引擎（template engine）。它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。 当Veloc
23种设计模式（4）：模板模式
东语的专栏
02-02 495
1 辉煌工程——制造悍马  周三，9:00，我刚刚坐到位置上，打开电脑准备开始干活。 “小三，小三，叫一下其他同事，到会议室开会”，老大跑过来吼，带着坏笑。还没等大家坐稳，老大就开讲了： “告诉大家一个好消息，昨天终于把××模型公司的口子打开了，要我们做悍马模型，虽然是第一个车辆模型，但是我们有能力、有信心做好，我们一定要……”（中间省略20分钟的讲话，如果你听过领导人的讲话，这个你
互联网架构模板
程序员学习圈
11-24 1270
互联网的标准技术架构如下图所示，这张图基本涵盖了互联网技术公司的大部分技术点，不同的公司只是在具体的技术实现上稍有差异，但不会跳出这个框架的范围。 1.存储层 1.1 SQL层 1.2 NOSQL层 1.3 小文件存储 开源的，HBase，Hadoop，Hypertable，FastDFS等都可以作为小文件存储的底层平台。如果使用了阿里云，有存储系统OSS。 1.4 大文件...
基于MATLAB的水果分级设计
热门推荐
nogi46的博客
06-14 3万+
基于MATLAB的水果分级识别技术研究摘 要本次毕业设计介绍了基于MATLAB的水果分级自动识别，利用手机端获取苹果的样本图像，应用MATLAB软件编程实现了对样本图像的预处理，包括图像滤波、图像填充、图像灰度化、图像二值化以及特征量提取等。水果分级自动识别我们通过四个不同方面来对基于MATLAB的苹果分级进行探索研究。主要工作如下：1. 在苹果大小识别方面，比较了不同的大小计算方法，选择了利用图...
基于Django的智能水果销售系统设计【源码+LW+部署指导】
BS009的博客
08-12 1861
本系统主要包括：用户管理模块，个人中心，水果类别管理模块，用户下单，用户信息，水果信息模块等。随着智能水果销售的系统的正式启用，水果的购买率得到了提高，给老百姓的出行带来了巨大的方便，更是促进了共享经济社会的良好发展。
企业数字化转型战略权威指南
AI天才研究院
03-05 1万+
企业数字化转型战略权威指南 企业数字化转型 数字化转型是推动企业界数十亿投资重塑业务方式的大趋势。CIOPages.com的数字化转型最终指南是针对企业高管和企业家的全面而深入的见解，他们对如何思考，规划，实施和运行在数字时代取得成功的事物进行了深入的了解。 在企业数字化转型指南中，我们将解决以下主题，以帮助您掌握数...
【苹果cms模板】MxPro主题V2.0 全解密源码.zip
01-17
【苹果CMS模板】MxPro主题V2.0是一款针对苹果CMS内容管理系统设计的专业主题，全解密源码提供给了用户深度定制的可能性。苹果CMS是一款流行的PHP开发的视频网站管理系统，广泛应用于搭建视频分享、电影播放等类型的...
水果品牌策划书模板.doc
09-20
**品牌名称与标识**：品牌命名为“倾果倾诚”，巧妙利用成语“倾国倾城”的谐音，暗示产品的高质量和精美的包装，同时也传达了品牌致力于提供健康、美味水果的诚意。品牌标识以三角形为基础，象征稳定发展，融合...
腾飞之路-讲述社会发展迅速的卡通情景剧ppt动画电影模板PPT模板.pptx
02-02
【标题】"腾飞之路"是一部以卡通情景剧形式展现社会发展迅速的PPT动画电影模板，设计旨在通过生动的视觉效果，展示国家各个领域的繁荣进步。该模板由作者"zcg337（果子）"创作，名为"2011之飞腾路"，在"Rapid Design...
花好月圆中秋节PPT模板
11-23
词客看花心意苦，坠粉零香，果是谁相误。三十六陂飞细雨，明朝颜色难如故。 - **作用**：这部分可以通过引用古代或现代有关中秋节的诗歌来增加演示文稿的艺术性和文学价值，同时也展现了中秋节的文化底蕴。 ### 三...
乔布斯创新密码PPT模板.ppt
01-21
【乔布斯创新密码PPT模板】是基于苹果公司创始人史蒂夫·乔布斯的创新理念和成功原则设计的一款演示文稿模板。乔布斯是全球公认的创新者，他的创业经历和对个人电脑行业的革新影响深远。在全球经济衰退背景下，人们...
numexpr-2.8.3-cp38-cp38-win_amd64.whl
10-14
numexpr-2.8.3-cp38-cp38-win_amd64.whl
ujson-5.3.0-cp311-cp311-win_amd64.whl
10-14
ujson-5.3.0-cp311-cp311-win_amd64.whl
基于MATLAB车牌识别程序技术实现面板GUI.zip
最新发布
10-14
vos3000
RJFireWall-maste赛资源
10-14
RJFireWall-maste赛资源
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值