counting the buildings - 第一类斯特灵数

2017-08-10 21:10:08

writer：pprp

//TLE
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;
typedef long long ll;
const int maxn = ;

ll dp[maxn][maxn];

const int mod = 1e9 + ;

void S1()
{
    for(int i =  ; i <=  ; i++)
    {
        dp[i][] = ;
        dp[i][i] = ;
        for(int j = ; j < i ; j++)
            dp[i][j] = (i - ) * dp[i-][j] + dp[i-][j-];
    }
}

//a^b%m 快速幂
int quick_power_mod(int a, int b, int m)
{
    int result = ;
    int base = a;
    while(b > )
    {
        if(b& == )//如果b是奇数
        {
            result = (result * base) % m;
        }
        base = (base * base)%m;
        b>>=;
    }
    return result;
}

//组合数取模 C(a,b)%p
ll composition(ll a, ll b, int p)
{
    if(a < b)
        return ;
    if(a == b)
        return ;
    if(b > a - b) b = a - b;

    int ans = , ca  = , cb = ;
    for(ll i =  ; i < b; i++)
    {
        ca = (ca * (a - i))%p;
        cb = (cb * (b - i))%p;
    }

    ans = (ca * quick_power_mod(cb,p - , p)) % p;
    return ans;
}

ll lucas(ll n, ll m, ll p)
{
    ll ans = ;
    while(n && m && ans)
    {
        ans = (ans * composition(n%p, m%p, p))%p;
        n /= p;
        m /= p;
    }
    return ans;
}

int main()
{
    S1();
    int T;
    cin >> T;
    int N, F, B;

    while(T--)
    {
        cin >> N >> F >> B;
        cout << dp[N-][F+B-]*composition(F+B-,F-,mod) <<endl;
    }
    return ;
}

标解：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;
typedef long long ll;
const int maxn = ;

ll dps[maxn][maxn];
ll dpc[maxn][maxn];

const ll mod = 1e9 + ;

 void init()
 {
       for(int i = ; i < maxn ; i++)
       {
             dpc[i][] = dpc[i][i] = dps[i][i] = ;
             for(int j = ; j < i ; j++)
             {
                   dpc[i][j] = (dpc[i-][j-]+dpc[i-][j])%mod;
                   dps[i][j] = ((i-)*dps[i-][j])%mod + dps[i-][j-]%mod;
             }
       }
 }

int main()
{
    int T;
    cin >> T;
    long long N, F, B;
    init();

    while(T--)
    {
        cin >> N >> F >> B;
        cout << dps[N-][F+B-]*dpc[F+B-][F-]%mod <<endl;
    }
    return ;
}

标解中组合数是用杨辉三角求解的

杨辉三角dp法

dp[i][j]=dp[i-1][j-1]+dp[i-1][j]

O(n^2)~O(1)