计算我可以在数组中拥有唯一数字的方法数

Question

I am trying to find the number of ways to construct an array such that consecutive positions contain different values.

Specifically, I need to construct an array with elements such that each element 1 between and k, all inclusive. I also want the first and last elements of the array to be 1 and x.

Complete problem statement:

Here is what I tried:

 def countArray(n, k, x):
    # Return the number of ways to fill in the array.
    if x > k:
        return 0
    if x == 1:
        return 0
    
    def fact(n):
        if n == 0:
            return 1
        fact_range = n+1
        T = [1 for i in range(fact_range)]
        for i in range(1,fact_range):
            T[i] = i * T[i-1]
        return T[fact_range-1]
    
    ways = fact(k) / (fact(n-2)*fact(k-(n-2)))
    return int(ways)

In short, I did K(C)N-2 to find the ways. How could I solve this?

It passes one of the base case with inputs as countArray(4,3,2) but fails for 16 other cases.

Answer 1

Let X(n) be the number of ways of constructing an array of length n, starting with 1 and ending in x (and not repeating any numbers). Let Y(n) be the number of ways of constructing an array of length n, starting with 1 and NOT ending in x (and not repeating any numbers).

Then there's these recurrence relations (for n>1)

X(n+1) = Y(n)
Y(n+1) = X(n)*(k-1) + Y(n)*(k-2)

In words: If you want an array of length n+1 ending in x, then you need an array of length n not ending in x. And if you want an array of length n+1 not ending in x, then you can either add any of the k-1 symbols to an array of length n ending in x, or you can take an array of length n not ending in x, and add any of the k-2 symbols that aren't x and don't repeat the last value.

For the base case, n=1 , if x is 1 then X(1)=1 , Y(1)=0 otherwise, X(1)=0 , Y(1)=1

This gives you an O(n)-time method of computing the result.

def ways(n, k, x):
    M = 10**9 + 7
    wx = (x == 1)
    wnx = (x != 1)
    for _ in range(n-1):
        wx, wnx = wnx, wx * (k-1) + wnx*(k-2)
        wnx = wnx % M
    return wx

print(ways(100, 5, 2))

In principle you can reduce this to O(log n) by expressing the recurrence relations as a matrix and computing the matrix power (mod M), but it's probably not necessary for the question.

[Additional working]

We have the recurrence relations:

X(n+1) = Y(n)
Y(n+1) = X(n)*(k-1) + Y(n)*(k-2)

Using the first, we can replace the Y(_) in the second with X(_+1) to reduce it down to a single variable. Then:

X(n+2) = X(n)*(k-1) + X(n+1)*(k-2)

Using standard techniques, we can solve this linear recurrence relation exactly.

In the case x,=1: we have:

X(n) = ((k-1)^(n-1) - (-1)^n) / k

And in the case x=1, we have:

X(n) = ((k-1)^(n-1) - (1-k)(-1)^n)/k

We can compute these mod M using Fermat's little theorem because M is prime. So 1/k = k^(M-2) mod M.

Thus we have (with a little bit of optimization) this short program that solves the problem and runs in O(log n) time:

def ways2(n, k, x):
    S = -1 if n%2 else 1
    return ((pow(k-1, n-1, M) + S) * pow(k, M-2, M) - S*(x==1)) % M

Answer 2

could you try this DP version: (it's passed all tests) (it's inspired by @PaulHankin and take DP approach - will run performance later to see what's diff for big matrix)

def countArray(n, k, x):
    # Return the number of ways to fill in the array.
    big_mod = 10 ** 9 + 7
    dp = [[1], [1]]
    if x == 1: 
        dp = [[1], [0]]
    else:
        dp = [[1], [1]]
    
    for _ in range(n-2):
        dp[0].append(dp[0][-1] * (k - 1) % big_mod)
        dp[1].append((dp[0][-1] - dp[1][-1]) % big_mod)
    return dp[1][-1]