Problem:
問題 5

　IOI 宝飾店ではビーズのネックレスを売り出すことになった．
ビーズは n 色あり，
これらをそれぞれ m 個以上ずつ選んで r 個のビーズからなるネックレスとし，
１つずつ化粧箱に入れて販売したい．
色の組合せが違うものをすべて１つずつ用意したいが，
化粧箱を何個用意したらよいか店員の誰もわからない．
n, m, r によっては現実的でない個数の化粧箱が必要となるのではないかと店長は心配している．
IOI 宝飾店の店長に代わって，
必要な化粧箱の個数を出力するプログラムを作成しなさい．
n, m, r は整数で，0≦m＜n≦r≦10000 である．

　入力ファイルは１行で，
空白を区切りとして n, m, r がこの順に書いてある．
入力ファイル５つのうちの３つでは n≦10 である．

　出力ファイルにおいては，
出力の最後の行にも改行コードを入れること．

入出力例

入力例１

2 0 3

出力例１

4

入力例２

3 1 4

出力例２

3

入力例３

4 2 5

出力例３

0

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in C++11 (judge verdict: Accepted)

#include <iostream>
#include <iomanip>
#include <string>
#include <cassert>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long Int;
const Int B = 10000000000;      // base (power of 10)
const int BW = 10;         // log B
const int MAXDIGIT = 5000; // it can represent BW*MAXDIGIT digits (in base 10)
struct BigNum {
    Int digit[MAXDIGIT];
    int size;
    BigNum(int size = 1, Int a = 0) : size(size) {
        memset(digit, 0, sizeof(digit));
        digit[0] = a;
    }
};
const BigNum ZERO(1, 0), ONE(1, 1);

// Comparators
inline bool operator<(const BigNum & x, const BigNum & y) {
    if (x.size != y.size) return x.size < y.size;
    for (int i = x.size - 1; i >= 0; --i)
    if (x.digit[i] != y.digit[i]) return x.digit[i] < y.digit[i];
    return false;
}
inline bool operator >(const BigNum & x, const BigNum &  y) { return y < x; }
inline bool operator<=(const BigNum &  x, const BigNum &  y) { return !(y < x); }
inline bool operator>=(const BigNum &  x, const BigNum &  y) { return !(x < y); }
inline bool operator!=(const BigNum &  x, const BigNum &  y) { return x < y || y < x; }
inline bool operator==(const BigNum &  x, const BigNum &  y) { return !(x < y) && !(y < x); }

// Utilities
inline BigNum normal(BigNum x) {
    Int c = 0;
    for (int i = 0; i < x.size; ++i) {
        while (x.digit[i] < 0)
            x.digit[i + 1] -= 1, x.digit[i] += B;
        Int a = x.digit[i] + c;
        x.digit[i] = a % B;
        c = a / B;
    }
    for (; c > 0; c /= B) x.digit[x.size++] = c % B;
    while (x.size > 1 && x.digit[x.size - 1] == 0) --x.size;
    return x;
}
inline BigNum convert(Int a) {
    return normal(BigNum(1, a));
}
inline BigNum convert(const string &s) {
    BigNum x;
    int i = s.size() % BW;
    if (i > 0) i -= BW;
    for (; i < (int)s.size(); i += BW) {
        Int a = 0;
        for (int j = 0; j < BW; ++j)
            a = 10 * a + (i + j >= 0 ? s[i + j] - '0' : 0);
        x.digit[x.size++] = a;
    }
    reverse(x.digit, x.digit + x.size);
    return normal(x);
}
// Input/Output
ostream &operator<<(ostream &os, const BigNum & x) {
    os << x.digit[x.size - 1];
    for (int i = x.size - 2; i >= 0; --i)
        os << setw(BW) << setfill('0') << x.digit[i];
    return os;
}
istream &operator>>(istream &is, BigNum &x) {
    string s; is >> s;
    x = convert(s);
    return is;
}

// Basic Operations 
inline BigNum operator+(BigNum x, const BigNum & y) {
    if (x.size < y.size) x.size = y.size;
    for (int i = 0; i < y.size; ++i)
        x.digit[i] += y.digit[i];
    return normal(x);
}
inline BigNum operator-(BigNum x, const BigNum & y) {
    assert(x >= y);
    for (int i = 0; i < y.size; ++i)
        x.digit[i] -= y.digit[i];
    return normal(x);
}
inline BigNum operator*(BigNum x, const BigNum & y) {
    BigNum z(x.size + y.size);
    for (int i = 0; i < x.size; ++i)
    for (int j = 0; j < y.size; ++j)
        z.digit[i + j] += x.digit[i] * y.digit[j];
    return normal(z);
}
inline BigNum operator*(BigNum x, Int a) {
    for (int i = 0; i < x.size; ++i)
        x.digit[i] *= a;
    return normal(x);
}
inline pair<BigNum, Int> divmod(BigNum x, Int a) {
    Int c = 0, t;
    for (int i = x.size - 1; i >= 0; --i) {
        t = B * c + x.digit[i];
        x.digit[i] = t / a;
        c = t % a;
    }
    return pair<BigNum, Int>(normal(x), c);
}
inline BigNum operator/(BigNum x, Int a) {
    return divmod(x, a).first;
}
inline Int operator%(BigNum x, Int a) {
    return divmod(x, a).second;
}
inline pair<BigNum, BigNum> divmod(BigNum x, BigNum y) {
    if (x.size < y.size) return pair<BigNum, BigNum>(ZERO, x);
    int F = B / (y.digit[y.size - 1] + 1); // multiplying good-factor
    x = x * F; y = y * F;
    BigNum z(x.size - y.size + 1);
    for (int k = z.size - 1, i = x.size - 1; k >= 0; --k, --i) {
        z.digit[k] = (i + 1 < x.size ? x.digit[i + 1] : 0) * B + x.digit[i];
        z.digit[k] /= y.digit[y.size - 1];
        BigNum t(k + y.size);
        for (int m = 0; m < y.size; ++m)
            t.digit[k + m] = z.digit[k] * y.digit[m];
        t = normal(t);
        while (x < t) {
            z.digit[k] -= 1;
            for (int m = 0; m < y.size; ++m)
                t.digit[k + m] -= y.digit[m];
            t = normal(t);
        }
        x = x - t;
    }
    return pair<BigNum, BigNum>(normal(z), x / F);
}
inline BigNum operator/(BigNum x, BigNum y) {
    return divmod(x, y).first;
}
inline BigNum operator%(BigNum x, BigNum y) {
    return divmod(x, y).second;
}

// Advanced Operations
inline BigNum shift(BigNum x, int k) {
    if (x.size == 1 && x.digit[0] == 0) return x;
    x.size += k;
    for (int i = x.size - 1; i >= k; --i) x.digit[i] = x.digit[i - k];
    for (int i = k - 1; i >= 0; --i) x.digit[i] = 0;
    return x;
}
inline BigNum sqrt(const BigNum & x) { // verified UVA 10023
    const BigNum _20 = convert(2 * B);
    BigNum odd = ZERO;
    BigNum rem(2, 0);
    BigNum ans = ZERO;
    for (int i = 2 * ((x.size - 1) / 2); i >= 0; i -= 2) {
        int group = (i + 1 < x.size ? x.digit[i + 1] : 0) * B + x.digit[i];
        odd = _20 * ans + ONE;
        rem = shift(rem, 2) + convert(group);
        int count = 0;
        while (rem >= odd) {
            count = count + 1;
            rem = rem - odd;
            odd.digit[0] += 2;
            odd = normal(odd);
        }
        ans = shift(ans, 1) + convert(count);
    }
    return ans;
}


int main(){
    int n, m, r; cin >> n >> m >> r;
    int x = r - n*m + n - 1;
    int y = r - m * n;
    BigNum ans;
    if (y < 0 || x < 0) ans = ZERO;
    else
    {
        ans = convert(1);
        for (int i = 1; i <= y; i++){
            ans = ans * (x - i + 1);
            ans = ans / i;
        }
    }
    cout << ans << endl;
}