Codeforces Gym 100342D Problem D. Dinner Problem Dp+高精度

Problem D. Dinner Problem
Time Limit: 20 Sec

Memory Limit: 256 MB

题目连接

http://codeforces.com/gym/100342/attachments

Description

A group of k students from Cooking University living in the campus decided that each day of the semester one of them will prepare the dinner for the whole company. The semester lasts for n days.
In sake of fairness they decided that each of the students must prepare the dinner at least once during the semester. Now they wonder how many ways are there to plan the semester — to decide for each day which student would make a dinner that day. Help them to find that out.

Input

The input file contains two integer numbers k and n (1 ≤ k ≤ n ≤ 100).

Output

Output one integer number — the number of different nice paintings of the cottages.

Sample Input

2 3

Sample Output

6

HINT

题意

有n天，有k个人，安排这k个人做饭，问你有多少种安排方案，每个人至少得做一天饭

题解：

简单DP，但是会爆longlong，要用高精度来搞一搞……

java不会真是太伤心了= =

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;

const int MAXN = ;

struct bign
{
    int len, s[MAXN];
    bign ()
    {
        memset(s, , sizeof(s));
        len = ;
    }
    bign (int num) { *this = num; }
    bign (const char *num) { *this = num; }
    bign operator = (const int num)
    {
        char s[MAXN];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    bign operator = (const char *num)
    {
        for(int i = ; num[i] == ''; num++) ;  //去前导0
        len = strlen(num);
        for(int i = ; i < len; i++) s[i] = num[len-i-] - '';
        return *this;
    }
    bign operator + (const bign &b) const //+
    {
        bign c;
        c.len = ;
        for(int i = , g = ; g || i < max(len, b.len); i++)
        {
            int x = g;
            if(i < len) x += s[i];
            if(i < b.len) x += b.s[i];
            c.s[c.len++] = x % ;
            g = x / ;
        }
        return c;
    }
    bign operator += (const bign &b)
    {
        *this = *this + b;
        return *this;
    }
    void clean()
    {
        while(len >  && !s[len-]) len--;
    }
    bign operator * (const bign &b) //*
    {
        bign c;
        c.len = len + b.len;
        for(int i = ; i < len; i++)
        {
            for(int j = ; j < b.len; j++)
            {
                c.s[i+j] += s[i] * b.s[j];
            }
        }
        for(int i = ; i < c.len; i++)
        {
            c.s[i+] += c.s[i]/;
            c.s[i] %= ;
        }
        c.clean();
        return c;
    }
    bign operator *= (const bign &b)
    {
        *this = *this * b;
        return *this;
    }
    bign operator - (const bign &b)
    {
        bign c;
        c.len = ;
        for(int i = , g = ; i < len; i++)
        {
            int x = s[i] - g;
            if(i < b.len) x -= b.s[i];
            if(x >= ) g = ;
            else
            {
                g = ;
                x += ;
            }
            c.s[c.len++] = x;
        }
        c.clean();
        return c;
    }
    bign operator -= (const bign &b)
    {
        *this = *this - b;
        return *this;
    }
    bign operator / (const bign &b)
    {
        bign c, f = ;
        for(int i = len-; i >= ; i--)
        {
            f = f*;
            f.s[] = s[i];
            while(f >= b)
            {
                f -= b;
                c.s[i]++;
            }
        }
        c.len = len;
        c.clean();
        return c;
    }
    bign operator /= (const bign &b)
    {
        *this  = *this / b;
        return *this;
    }
    bign operator % (const bign &b)
    {
        bign r = *this / b;
        r = *this - r*b;
        return r;
    }
    bign operator %= (const bign &b)
    {
        *this = *this % b;
        return *this;
    }
    bool operator < (const bign &b)
    {
        if(len != b.len) return len < b.len;
        for(int i = len-; i >= ; i--)
        {
            if(s[i] != b.s[i]) return s[i] < b.s[i];
        }
        return false;
    }
    bool operator > (const bign &b)
    {
        if(len != b.len) return len > b.len;
        for(int i = len-; i >= ; i--)
        {
            if(s[i] != b.s[i]) return s[i] > b.s[i];
        }
        return false;
    }
    bool operator == (const bign &b)
    {
        return !(*this > b) && !(*this < b);
    }
    bool operator != (const bign &b)
    {
        return !(*this == b);
    }
    bool operator <= (const bign &b)
    {
        return *this < b || *this == b;
    }
    bool operator >= (const bign &b)
    {
        return *this > b || *this == b;
    }
    string str() const
    {
        string res = "";
        for(int i = ; i < len; i++) res = char(s[i]+'') + res;
        return res;
    }
};

istream& operator >> (istream &in, bign &x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign &x)
{
    out << x.str();
    return out;
}

int n , k ;
bign dp[][];

bign dfs(int i ,int j)
{
    if (dp[i][j] != -) return dp[i][j];
    if (i > j)
    {
        return dp[i][j] = ;
    }
    else if(i ==  && j == ) return dp[i][j] = ;
    else if(i == ) return dp[i][j] = dfs(i,j-) * k;
    else return dp[i][j] = dfs(i-,j-) * i + dfs(i,j-) * (k-i);
}

int main()
{
    freopen("dinner.in","r",stdin);
    freopen("dinner.out","w",stdout);
    cin >> k >> n;
    for(int i =  ; i <=  ; ++ i)
     for(int j =  ; j <=  ; ++ j)
         dp[i][j] = -;
    bign ans = dfs(k,n);
    cout << ans << endl;
    return ;
}