80 lines
1.7 KiB
C++
80 lines
1.7 KiB
C++
/**
|
|
* [3405] Count the Number of Arrays with K Matching Adjacent Elements
|
|
*/
|
|
#include <bits/stdc++.h>
|
|
#include <gtest/gtest.h>
|
|
using namespace std;
|
|
|
|
|
|
// submission codes start here
|
|
|
|
constexpr long long MOD = 1e9 + 7;
|
|
constexpr long long UPPER_BOUND = 1e5;
|
|
|
|
static long long fact[UPPER_BOUND];
|
|
static long long inverseFact[UPPER_BOUND];
|
|
|
|
class Solution
|
|
{
|
|
static long long quickPower(long long x, int n)
|
|
{
|
|
long long result = 1;
|
|
|
|
while (n > 0)
|
|
{
|
|
if ((n & 1) == 1)
|
|
{
|
|
result = result * x % MOD;
|
|
}
|
|
|
|
x = x * x % MOD;
|
|
n >>= 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static long long combine(int n, int m)
|
|
{
|
|
return fact[n] * inverseFact[m] % MOD * inverseFact[n - m] % MOD;
|
|
}
|
|
|
|
static void init()
|
|
{
|
|
if (fact[0] != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
fact[0] = 1;
|
|
for (int i = 1; i < UPPER_BOUND; ++i)
|
|
{
|
|
fact[i] = fact[i - 1] * i % MOD;
|
|
}
|
|
|
|
// Modular Multiplicative Inverse is calculated by the quick power.
|
|
inverseFact[UPPER_BOUND - 1] = quickPower(fact[UPPER_BOUND - 1], MOD - 2);
|
|
for (int i = UPPER_BOUND - 1; i > 0; --i)
|
|
{
|
|
inverseFact[i - 1] = inverseFact[i] * i % MOD;
|
|
}
|
|
}
|
|
|
|
public:
|
|
int countGoodArrays(int n, int m, int k)
|
|
{
|
|
init();
|
|
const long long result = combine(n - 1, k) * m % MOD * quickPower(m - 1, n - k - 1) % MOD;
|
|
return result;
|
|
}
|
|
};
|
|
|
|
// submission codes end
|
|
|
|
TEST(P3405, Test1)
|
|
{
|
|
Solution s;
|
|
ASSERT_EQ(4, s.countGoodArrays(3, 2, 1));
|
|
ASSERT_EQ(6, s.countGoodArrays(4, 2, 2));
|
|
ASSERT_EQ(2, s.countGoodArrays(5, 2, 0));
|
|
} |