长度为k的十进制数，即严格单调

如果满足以下条件，我们将十进制数称为单调： $D[i] \leq D[i+1], 0 \leq i \leq |D|$

编写一个程序，该程序在输入上取正数n，然后返回严格单调的长度为n的十进制数。数字不能以0开头。

例子 ：

Input : 2
Output : 36
Numbers are 12, 13, ... 19, 23
24, ... 29, .... 89.

Input : 3
Output : 84

此问题的解释遵循与以下规则相同的规则：
单调的长度为k的十进制数的数量

唯一的区别是，现在我们不能进行重复操作，因此先前计算的值是左对角线和左上对角线的值。

C++

// CPP program to count numbers of k
// digits that are strictly monotone.
#include 
#include 
  
int static const DP_s = 9;
  
int getNumStrictMonotone(int len)
{
    // DP[i][j] is going to store monotone
    // numbers of length i+1 considering
    // j+1 digits (1, 2, 3, ..9)
    int DP[len][DP_s];
    memset(DP, 0, sizeof(DP));
   
    // Unit length numbers
    for (int i = 0; i < DP_s; ++i) 
        DP[0][i] = i + 1;    
  
    // Building dp[] in bottom up
    for (int i = 1; i < len; ++i) 
        for (int j = 1; j < DP_s; ++j) 
            DP[i][j] = DP[i - 1][j - 1] + DP[i][j - 1];        
      
    return DP[len - 1][DP_s - 1];
}
  
// Driver code
int main()
{
    std::cout << getNumStrictMonotone(2); 
    return 0;
}

Java

// Java program to count numbers of k
// digits that are strictly monotone.
import java.io.*;
import java.util.*;
  
class GFG {
  
    static int DP_s = 9;
      
    static int getNumStrictMonotone(int len) 
    {
        // DP[i][j] is going to store monotone
        // numbers of length i+1 considering
        // j+1 digits (1, 2, 3, ..9)
        int[][] DP = new int[len][DP_s];
      
        // Unit length numbers
        for (int i = 0; i < DP_s; ++i)
        DP[0][i] = i + 1;
      
        // Building dp[] in bottom up
        for (int i = 1; i < len; ++i)
             for (int j = 1; j < DP_s; ++j)
                DP[i][j] = DP[i - 1][j - 1] 
                             + DP[i][j - 1];
      
        return DP[len - 1][DP_s - 1];
    }
    public static void main(String[] args) 
    {
        int n = 2;
        System.out.println(getNumStrictMonotone(n));
    }
}
  
// This code is contributed by Gitanjali.

Python3

# Python3 program to count numbers of k
# digits that are strictly monotone.
  
DP_s = 9
  
def getNumStrictMonotone(ln):
      
    # DP[i][j] is going to store monotone
    # numbers of length i+1 considering
    # j+1 digits (1, 2, 3, ..9)
    DP = [[0] * DP_s for _ in range(ln)]
  
    # Unit length numbers
    for i in range(DP_s):
        DP[0][i] = i + 1 
  
    # Building dp[] in bottom up
    for i in range(1, ln):
          
        for j in range(1, DP_s):
              
            DP[i][j] = DP[i - 1][j - 1] + DP[i][j - 1]     
      
    return DP[ln - 1][DP_s - 1]
  
# Driver code
print(getNumStrictMonotone(2))
  
  
# This code is contributed by Ansu Kumari.

C#

// C# program to count numbers of k
// digits that are strictly monotone.
using System;
  
class GFG {
  
    static int DP_s = 9;
      
    static int getNumStrictMonotone(int len) 
    {
        // DP[i][j] is going to store monotone
        // numbers of length i+1 considering
        // j+1 digits (1, 2, 3, ..9)
        int[,] DP = new int[len,DP_s];
      
        // Unit length numbers
        for (int i = 0; i < DP_s; ++i)
        DP[0,i] = i + 1;
      
        // Building dp[] in bottom up
        for (int i = 1; i < len; ++i)
            for (int j = 1; j < DP_s; ++j)
                DP[i,j] = DP[i - 1,j - 1] 
                            + DP[i,j - 1];
      
        return DP[len - 1,DP_s - 1];
    }
      
    // Driver code
    public static void Main() 
    {
        int n = 2;
        Console.WriteLine(getNumStrictMonotone(n));
    }
}
  
// This code is contributed by vt_m.

输出 ：

36