以 K 为基数的 N 位数字的计数，没有两个连续的零

给定两个整数N和K ，任务是找到基数K中满足以下条件的所有整数的计数：

1. 整数必须正好是N位数字。
2. 不应该有前导0 。
3. 不能有任何连续的数字对，使得两个数字都是0 。

例子：

Input: N = 3, K = 10 
Output: 891 
All 3-digit numbers in base 10 are from the range [100, 999] 
Out of these numbers only 100, 200, 300, 400, …, 900 are invalid. 
Hence valid integers are 900 – 9 = 891
Input: N = 2, K = 10 
Output: 90 
 

幼稚的方法：编写一个函数count_numbers(int k, int n, bool flag) 它将返回基数K可能的N位数字的计数，flag 将判断先前选择的数字是否为0 。对count_numbers(int k, int n-1, bool flag)递归调用该函数，使用该标志可以避免连续出现两个0。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
int count_numbers(int k, int n, bool flag)
{
 
    // Base case
    if (n == 1) {
 
        // If 0 wasn't chosen previously
        if (flag) {
            return (k - 1);
        }
        else {
            return 1;
        }
    }
 
    // If 0 wasn't chosen previously
    if (flag)
        return (k - 1) * (count_numbers(k, n - 1, 0)
                          + count_numbers(k, n - 1, 1));
    else
        return count_numbers(k, n - 1, 1);
}
 
// Driver code
int main()
{
    int n = 3;
    int k = 10;
    cout << count_numbers(k, n, true);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
     
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
static int count_numbers(int k, int n,
                         boolean flag)
{
 
    // Base case
    if (n == 1)
    {
 
        // If 0 wasn't chosen previously
        if (flag)
        {
            return (k - 1);
        }
        else
        {
            return 1;
        }
    }
 
    // If 0 wasn't chosen previously
    if (flag)
        return (k - 1) * (count_numbers(k, n - 1, false) +
                          count_numbers(k, n - 1, true));
    else
        return count_numbers(k, n - 1, true);
}
 
// Driver code
public static void main (String[] args)
{
    int n = 3;
    int k = 10;
    System.out.println(count_numbers(k, n, true));
}
}
 
// This code is contributed by AnkitRai01

Python3

# Python3 implementation of the approach
 
# Function to return the count of
# n-digit numbers that satisfy
# the given conditions
def count_numbers(k, n, flag) :
 
    # Base case
    if (n == 1) :
 
        # If 0 wasn't chosen previously
        if (flag) :
            return (k - 1)
        else :
            return 1
 
    # If 0 wasn't chosen previously
    if (flag) :
        return (k - 1) * (count_numbers(k, n - 1, 0) +
                          count_numbers(k, n - 1, 1))
    else :
        return count_numbers(k, n - 1, 1)
 
# Driver code
n = 3
k = 10
print(count_numbers(k, n, True))
 
# This code is contributed by
# divyamohan123

C#

// C# implementation of the approach
using System;
                     
class GFG
{
     
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
static int count_numbers(int k, int n,
                         bool flag)
{
 
    // Base case
    if (n == 1)
    {
 
        // If 0 wasn't chosen previously
        if (flag)
        {
            return (k - 1);
        }
        else
        {
            return 1;
        }
    }
 
    // If 0 wasn't chosen previously
    if (flag)
        return (k - 1) * (count_numbers(k, n - 1, false) +
                          count_numbers(k, n - 1, true));
    else
        return count_numbers(k, n - 1, true);
}
 
// Driver code
public static void Main (String[] args)
{
    int n = 3;
    int k = 10;
    Console.Write(count_numbers(k, n, true));
}
}
 
// This code is contributed by 29AjayKuma

Javascript

// Javascript implementation of the approach
 
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
function count_numbers(k, n, flag)
{
 
    // Base case
    if (n == 1) {
 
        // If 0 wasn't chosen previously
        if (flag) {
            return (k - 1);
        }
        else {
            return 1;
        }
    }
 
    // If 0 wasn't chosen previously
    if (flag)
        return (k - 1) * (count_numbers(k, n - 1, 0)
                          + count_numbers(k, n - 1, 1));
    else
        return count_numbers(k, n - 1, 1);
}
 
// Driver code
    let n = 3;
    let k = 10;
    document.write(count_numbers(k, n, true));
 
// This code is contributed by souravmahato348.

输出：

891

有效的方法：既然问题已经用递归解决了，那么可以使用二维 DP 来解决这个问题dp[n + 1][2]其中dp[i][0]将给出第i 个数字的个数可能以0和dp[i][1]结尾将给出可能以非零结尾的i位数字的数量。
递推关系为：

dp[i][0] = dp[i – 1][1]; 
dp[i][1] = (dp[i – 1][0] + dp[i – 1][1]) * (K – 1); 
 

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
int count_numbers(int k, int n)
{
 
    // DP array to store the
    // pre-caluclated states
    int dp[n + 1][2];
 
    // Base cases
    dp[1][0] = 0;
    dp[1][1] = k - 1;
    for (int i = 2; i <= n; i++) {
 
        // i-digit numbers ending with 0
        // can be formed by concatenating
        // 0 in the end of all the (i - 1)-digit
        // number ending at a non-zero digit
        dp[i][0] = dp[i - 1][1];
 
        // i-digit numbers ending with non-zero
        // can be formed by concatenating any non-zero
        // digit in the end of all the (i - 1)-digit
        // number ending with any digit
        dp[i][1] = (dp[i - 1][0] + dp[i - 1][1]) * (k - 1);
    }
 
    // n-digit number ending with
    // and ending with non-zero
    return dp[n][0] + dp[n][1];
}
 
// Driver code
int main()
{
    int k = 10;
    int n = 3;
    cout << count_numbers(k, n);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
static int count_numbers(int k, int n)
{
 
    // DP array to store the
    // pre-caluclated states
    int [][]dp = new int[n + 1][2];
 
    // Base cases
    dp[1][0] = 0;
    dp[1][1] = k - 1;
    for (int i = 2; i <= n; i++)
    {
 
        // i-digit numbers ending with 0
        // can be formed by concatenating
        // 0 in the end of all the (i - 1)-digit
        // number ending at a non-zero digit
        dp[i][0] = dp[i - 1][1];
 
        // i-digit numbers ending with non-zero
        // can be formed by concatenating any non-zero
        // digit in the end of all the (i - 1)-digit
        // number ending with any digit
        dp[i][1] = (dp[i - 1][0] +
                    dp[i - 1][1]) * (k - 1);
    }
 
    // n-digit number ending with
    // and ending with non-zero
    return dp[n][0] + dp[n][1];
}
 
// Driver code
public static void main(String[] args)
{
    int k = 10;
    int n = 3;
    System.out.println(count_numbers(k, n));
}
}
 
// This code is contributed by Rajput-Ji

蟒蛇3

# Python3 implementation of the approach
 
# Function to return the count of
# n-digit numbers that satisfy
# the given conditions
def count_numbers(k, n):
 
    # DP array to store the
    # pre-caluclated states
    dp = [[0 for i in range(2)]
             for i in range(n + 1)]
 
    # Base cases
    dp[1][0] = 0
    dp[1][1] = k - 1
    for i in range(2, n + 1):
 
        # i-digit numbers ending with 0
        # can be formed by concatenating
        # 0 in the end of all the (i - 1)-digit
        # number ending at a non-zero digit
        dp[i][0] = dp[i - 1][1]
 
        # i-digit numbers ending with non-zero
        # can be formed by concatenating any non-zero
        # digit in the end of all the (i - 1)-digit
        # number ending with any digit
        dp[i][1] = (dp[i - 1][0] +
                    dp[i - 1][1]) * (k - 1)
 
    # n-digit number ending with
    # and ending with non-zero
    return dp[n][0] + dp[n][1]
 
# Driver code
k = 10
n = 3
print(count_numbers(k, n))
 
# This code is contributed by Mohit Kumar

C＃

// C# implementation of the approach
using System;
                     
class GFG
{
 
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
static int count_numbers(int k, int n)
{
 
    // DP array to store the
    // pre-caluclated states
    int [,]dp = new int[n + 1, 2];
 
    // Base cases
    dp[1, 0] = 0;
    dp[1, 1] = k - 1;
    for (int i = 2; i <= n; i++)
    {
 
        // i-digit numbers ending with 0
        // can be formed by concatenating
        // 0 in the end of all the (i - 1)-digit
        // number ending at a non-zero digit
        dp[i, 0] = dp[i - 1, 1];
 
        // i-digit numbers ending with non-zero
        // can be formed by concatenating any non-zero
        // digit in the end of all the (i - 1)-digit
        // number ending with any digit
        dp[i, 1] = (dp[i - 1, 0] +
                    dp[i - 1, 1]) * (k - 1);
    }
 
    // n-digit number ending with
    // and ending with non-zero
    return dp[n, 0] + dp[n, 1];
}
 
// Driver code
public static void Main(String[] args)
{
    int k = 10;
    int n = 3;
    Console.WriteLine(count_numbers(k, n));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript implementation of the approach
 
// Function to return the count of
// n-digit numbers that satisfy
// the given conditions
function count_numbers(k, n)
{
 
    // DP array to store the
    // pre-caluclated states
    let dp = new Array(n + 1);
    for (let i = 0; i < n + 1; i++)
        dp[i] = new Array(2);
 
    // Base cases
    dp[1][0] = 0;
    dp[1][1] = k - 1;
    for (let i = 2; i <= n; i++) {
 
        // i-digit numbers ending with 0
        // can be formed by concatenating
        // 0 in the end of all the (i - 1)-digit
        // number ending at a non-zero digit
        dp[i][0] = dp[i - 1][1];
 
        // i-digit numbers ending with non-zero
        // can be formed by concatenating any non-zero
        // digit in the end of all the (i - 1)-digit
        // number ending with any digit
        dp[i][1] = (dp[i - 1][0] +
                    dp[i - 1][1]) * (k - 1);
    }
 
    // n-digit number ending with
    // and ending with non-zero
    return dp[n][0] + dp[n][1];
}
 
// Driver code
    let k = 10;
    let n = 3;
    document.write(count_numbers(k, n));
 

输出：

891

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。