HDU 5568 dp+大数板子

sequence2
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 329 Accepted Submission(s): 132

Problem Description
Given an integer array bi with a length of n, please tell me how many exactly different increasing subsequences.

P.S. A subsequence bai(1≤i≤k) is an increasing subsequence of sequence bi(1≤i≤n) if and only if 1≤a1 < a2 < … < ak ≤ n and ba1 < ba2 <…< bak.
Two sequences ai and bi is exactly different if and only if there exist at least one i and ai≠bi.

Input
Several test cases(about 5)

For each cases, first come 2 integers, n,k(1≤n≤100,1≤k≤n)

Then follows n integers ai(0≤ai≤109)

Output
For each cases, please output an integer in a line as the answer.

Sample Input
3 2
1 2 2
3 2
1 2 3

Sample Output
2
3

题意：
给一段序列，这个序列有很多个递增子序列，求长度为k的子序列的个数
题解：
dp[i][j]为第i个数在第j个位置时的序列个数，从i开始往前推，找到当a[j]< a[i]时，对每个dp[j][t],我们知道可以加到dp[i][t+1]上去。转移过程就出来了，将第一列元素全初始为1，其他位置初始为0.注意，总数可能很多，需要用的大数。这里看大神的答案扒了一个大数板子。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <sstream>
#define F(i,a,b) for(int i = a;i<=b;i++)
#define FI(i,a,b) for(int i = a;i<=b;i--)

using namespace std;

#define LEN 20
#define MOD 10000

//定义了+ - * / % = == != >> << < > <= >= += -= *= /= %= 操作
struct INT
{
    int num[LEN], len;
    bool sign;
    inline INT(long long x = 0)
    {
        *this = x;
    }
    inline INT(const string &str)
    {
        *this = str;
    }
    inline INT(const int a[], int b, bool c)
    {
        memcpy(num, a, sizeof num);
        len = b; sign = c;
    }
    inline INT &operator =(const string &str)
    {
        int start = 0;
        len = 0; sign = false;
        memset(num, 0, sizeof num);
        if (str[0] == '-') sign = true, start = 1;
        while (str[start] == '0') start++;
        for (int i = str.length() - 1; i >= start; i -= 4, len++)
            for (int j = max(start, i - 3); j <= i; j++)
                num[len] = (num[len] << 3) + (num[len] << 1) + str[j] - '0';
        if (!len) sign = false;
        if (len) len--;
        return *this;
    }
    inline INT &operator =(long long x)
    {
        len = 0; sign = false;
        memset(num, 0, sizeof num);
        if (x < 0) sign = true, x = -x;
        while (x)
            num[len++] = x % MOD,
                         x /= MOD;
        if (len) len--;
        return *this;
    }
    inline int length() const
    {
        int re = len << 2, t = num[len];
        while (t) t /= 10, re++;
        return re;
    }
    inline void print()
    {
        if (sign) putchar('-');
        printf("%d", num[len]);
        for (int i = len - 1; i >= 0; i--)
            printf("%04d", num[i]);
    }
    inline friend void print_to_string(const INT &x, string &y)
    {
        stringstream stream;
        stream << x;
        stream >> y;
    }
    inline friend INT pow(const INT &x, int y)
    {
        INT re = 1, _x = x;
        while (y)
        {
            if (y & 1)
                re *= _x;
            y >>= 1;
            _x *= _x;
        }
        return re;
    }
    inline friend INT pow(const INT &x, const INT &y)
    {
        INT re = 1, _x = x, _y = y;
        while (_y != 0)
        {
            if (_y.num[0] & 1)
                re *= _x;
            _y = shr(_y);
            _x *= _x;
        }
        return re;
    }
    inline friend istream &operator >>(istream &in, INT &x)
    {
        string str;
        in >> str;
        x = str;
        return in;
    }
    inline friend ostream &operator <<(ostream &out, const INT &x)
    {
        if (x.sign) out << '-';
        out << x.num[x.len];
        for (int i = x.len - 1; i >= 0; i--)
            out.fill('0'), out.width(4), out << x.num[i];
        return out;
    }
    inline INT operator -() const
    {
        return INT(num, len, !sign);
    }
    inline friend INT abs(const INT &x)
    {
        return INT(x.num, x.len, false);
    }
    inline friend bool operator <(const INT &x, const INT &y)
    {
        if (x.sign ^ y.sign) return x.sign;
        int lx = x.length(), ly = y.length();
        if (lx == ly)
        {
            for (int i = x.len; i >= 0; i--)
                if (x.num[i] != y.num[i])
                    return (x.num[i] < y.num[i])^x.sign;
            return false;
        }
        return (lx < ly)^x.sign;
    }
    inline friend bool operator >(const INT &x, const INT &y) { return y < x; }
    inline friend bool operator <=(const INT &x, const INT &y) { return !(y < x); }
    inline friend bool operator >=(const INT &x, const INT &y) { return !(x < y); }
    inline friend bool operator ==(const INT &x, const INT &y) { return !(x < y || y < x); }
    inline friend bool operator !=(const INT &x, const INT &y) { return !(x == y); }

    inline friend INT operator +(const INT &x, const INT &y)
    {
        if (x.sign ^ y.sign)
            return x - (-y);
        INT re;
        re.sign = x.sign;
        re.len = max(x.len, y.len);
        for (int i = 0; i <= re.len; i++)
        {
            re.num[i] += x.num[i] + y.num[i];
            re.num[i + 1] = re.num[i] / MOD;
            re.num[i] %= MOD;
        }
        if (re.num[re.len + 1]) re.len++;
        return re;
    }
    inline friend INT operator -(const INT &x, const INT &y)
    {
        if (x.sign ^ y.sign)
            return x + (-y);
        INT re, _x = x, _y = y;
        re.sign = _x < _y;
        if (re.sign ^ _x.sign)
            swap(_x, _y);
        for (int i = 0; i <= _x.len; i++)
        {
            re.num[i] += _x.num[i] - _y.num[i];
            if (re.num[i] < 0)
                re.num[i] += MOD,
                             re.num[i + 1]--;
        }
        re.len = _x.len;
        while (!re.num[re.len] && re.len >= 0) re.len--;
        return re;
    }
    inline friend INT operator *(const INT &x, const INT &y)
    {
        INT re, _x = x, _y = y;
        while (_y != 0)
        {
            if (_y.num[0] & 1)
                re += _x;
            _y = shr(_y);
            _x += _x;
        }
        if (y.sign) re.sign ^= 1;
        return re;
    }
    inline friend INT operator /(const INT &x, const INT &y)
    {
        if ((!y.len && !y.num[0]) || (!x.len && !x.num[0]) || abs(x) < abs(y)) { return INT(); }
        INT re, left, _y = abs(y);
        re.sign = x.sign ^ y.sign;
        re.len = x.len - y.len + 1;
        left.len = -1;
        for (int i = x.len; i >= 0; i--)
        {
            memmove(left.num + 1, left.num, sizeof(left.num) - sizeof(int));
            left.len++;
            left.num[0] = x.num[i];
            int l = 0, r = MOD - 1, mid;
            if (left < y) r = 1;
            while (l < r)
            {
                mid = (l + r) >> 1;
                INT t = mid;
                if (t * _y <= left)
                    l = mid + 1;
                else r = mid;
            }
            re.num[i] = r - 1;
            INT t = r - 1;
            left = left - (t * _y);
        }
        while (re.num[re.len] == 0 && re.len) re.len--;
        return re;
    }
    inline friend INT operator %(const INT &x, const INT &y)
    {
        if ((!y.len && !y.num[0]) || (!x.len && !x.num[0])) { return INT(); }
        INT left, _y = abs(y);
        left.sign = (x.sign && !y.sign);
        left.len = -1;
        for (int i = x.len; i >= 0; i--)
        {
            memmove(left.num + 1, left.num, sizeof(left.num) - sizeof(int));
            left.len++;
            left.num[0] = x.num[i];
            int l = 0, r = MOD - 1, mid;
            while (l < r)
            {
                mid = (l + r) >> 1;
                INT t = mid;
                if (t * _y <= left)
                    l = mid + 1;
                else r = mid;
            }
            INT t = r - 1;
            left = left - (t * _y);
        }
        return left;
    }
    inline friend INT shr(const INT &x)
    {
        INT re;
        re.len = x.len;
        for (int i = re.len; i >= 0; i--)
        {
            if (x.num[i] & 1 && i - 1 >= 0)
                re.num[i - 1] += MOD >> 1;
            re.num[i] += x.num[i] >> 1;
        }
        if (re.len && !re.num[re.len]) re.len--;
        return re;
    }
    INT &operator +=(const INT &x) { return *this = *this + x; }
    INT &operator -=(const INT &x) { return *this = *this - x; }
    INT &operator *=(const INT &x) { return *this = *this * x; }
    INT &operator /=(const INT &x) { return *this = *this / x; }
    INT &operator %=(const INT &x) { return *this = *this % x; }
};

int G[200];
INT dp[200][200];

int main()
{
//    freopen("data.in","r",stdin);
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF){
        F(i,1,n)
            scanf("%d",&G[i]);

        F(i,1,100){
            F(j,1,100)
                dp[i][j] = 0;
            dp[i][1] = 1;
        }

        F(i,1,n)
            F(j,1,i-1)
                if(G[j]<G[i]){
                    F(t,1,j)
                        dp[i][t+1]+=dp[j][t];
                }

        INT sum = 0;
        F(i,1,n) sum+=dp[i][k];
        cout << sum <<endl;
    }
    return 0;
}