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);  
         }
    }  
}