BZOJ3157/3516 国王奇遇记/（加强版）

最新推荐文章于 2019-09-13 17:15:26 发布

neither_nor

最新推荐文章于 2019-09-13 17:15:26 发布

阅读量2k

点赞数

CC 4.0 BY-SA版权

分类专栏： BZOJ 数学

本文链接：https://blog.youkuaiyun.com/neither_nor/article/details/51883989

BZOJ 同时被 2 个专栏收录

382 篇文章

订阅专栏

数学

16 篇文章

订阅专栏

本文介绍了一种利用记忆化搜索解决特定组合数学问题的方法，通过递归计算并存储中间结果来避免重复计算，实现复杂度为O(m^2)。文章提供了完整的C++代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

推式子如下图

用类似记忆化搜索的东西即可求S

特判m=1

复杂度O(m^2)

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<queue>
#include<map>
#include<bitset>
#include<stack>
#include<vector>
#include<set>
using namespace std;
#define MAXN 1010
#define MAXM 1010
#define INF 1000000000
#define MOD 1000000007
#define ll long long
#define eps 1e-8
int n,m;
ll s[MAXN];
bool vis[MAXN];
ll fac[MAXN],ine[MAXN];
ll mimn1;
ll nim;
ll mn[MAXN];
ll mi(ll x,ll y){
    ll re=1;
    while(y){
        if(y&1){
            (re*=x)%=MOD;
        }
        (x*=x)%=MOD;
        y>>=1;
    }
    return re;
}
ll C(int n,int m){
    return fac[n]*ine[m]%MOD*ine[n-m]%MOD;
}
ll S(int x){
    if(vis[x]){
        return s[x];
    }
    vis[x]=1;
    if(x==0){
        s[x]=(mimn1-m+MOD)%MOD*nim%MOD;
        return s[x];
    }
    int i;
    for(i=0;i<x;i++){
        (s[x]+=C(x,i)*S(i))%=MOD;
    }
    (s[x]*=m)%=MOD;
    (s[x]+=m-mn[x]*mimn1%MOD+MOD)%=MOD;
    s[x]=MOD-s[x];
    (s[x]*=nim)%=MOD;
    return s[x];
}
int main(){
    int i;
    fac[0]=ine[0]=ine[1]=1;
    for(i=1;i<MAXN;i++){
        fac[i]=fac[i-1]*i%MOD;
    }
    for(i=2;i<MAXN;i++){
        ine[i]=(MOD-MOD/i)*ine[MOD%i]%MOD;
    }
    for(i=2;i<MAXN;i++){
        ine[i]=(ine[i]*ine[i-1])%MOD;
    }
    scanf("%d%d",&n,&m);
    mimn1=mi(m,n+1);
    nim=mi(m-1,MOD-2);
    mn[0]=1;
    for(i=1;i<MAXN;i++){
    <span style="white-space:pre">	</span>mn[i]=mn[i-1]*(n+1)%MOD;
    }
    if(m==1){
        printf("%lld\n",(ll)(1+n)*n%MOD*mi(2,MOD-2)%MOD);
        return 0;
    }
    printf("%lld\n",S(m));
    return 0;
}
 
/*
1000000000 2000
*/