BestCoder Round #63 (div.1) A.sequence2

sequence2

 

 Accepts: 93

 

 Submissions: 358

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 65536/65536 K (Java/Others)

问题描述

给定长度为$n$的序列b_ib​i​​，求有多少长度为$k$的本质不同的上升子序列。
设该序列位置为a_1, a_2 ... a_ka​1​​,a​2​​...a​k​​一个序列为上升子序列，当且仅当a_1 < a_2 < ... < a_ka​1​​<a​2​​<...<a​k​​且b_{a_1} < b_{a_2} < ... < b{a_k}b​a​1​​​​<b​a​2​​​​<...<ba​k​​。
本质不同当且仅当两个序列$a$和$A$存在一个$i$使得a_i \neq A_ia​i​​≠A​i​​。

输入描述

若干组数据（大概$5$组）。
每组数据第一行两个整数$n(1\le n\le 100),k(1\le k\le n)$。
接下来一行$n$个整数b_i(0 \leq b_i \leq 10^{9})b​i​​(0≤b​i​​≤10​9​​)。

输出描述

对于每组的每个询问，输出一行。

输入样例

3 2
1 2 2
3 2
1 2 3

输出样例

2
3

很久没写dp了

推了好久的状态转移方程都没有推出来

c(100, 50)肯定会暴long long ，所以需要高精度

所以我就马上想到了java中的大数

import java.io.*;  
import java.math.BigInteger;  
import java.util.*;  
  
public class Main  
{  
    public static void main(String args[])  
    {  
        Scanner cin = new Scanner(System.in);  
         while(cin.hasNext())     
         {
        int n = cin.nextInt(); 
        int k = cin.nextInt();
        
        int a[] = new int[222];
        int i, j, kk;
        for(i = 1; i <= n; i++) a[i] = cin.nextInt();
        BigInteger [][]dp = new BigInteger[k*2][];
        for(i = 0; i < 2*k; i++)
            dp[i] = new BigInteger[2*n];
        BigInteger ans = BigInteger.ZERO;  
        for(i = 0; i <= k; i++)
        {
            for(j = 0; j <= n; j++)
                dp[i][j] = BigInteger.ZERO;
        }
        for(j = 1; j <= n; j++) dp[1][j] = BigInteger.ONE;
        
        for(i = 2; i <= k; i++)
        {
            for(j = 1; j <= n; j++)
            {
                for(kk = j+1; kk <= n; kk++)
                {
                    if(a[kk] > a[j])
                        dp[i][kk] = dp[i][kk].add( dp[i-1][j] );
                }
            }
        }
        for(i = 1; i <= n; ++i)  
            ans = ans.add(dp[k][i]);  
        System.out.println(ans);  
         }
    }  
}