2023-06-04：你的音乐播放器里有 N 首不同的歌，
在旅途中，你的旅伴想要听 L 首歌（不一定不同，即，允许歌曲重复，
请你为她按如下规则创建一个播放列表，
每首歌至少播放一次，
一首歌只有在其他 K 首歌播放完之后才能再次播放。
返回可以满足要求的播放列表的数量。
由于答案可能非常大，请返回它模 10^9 + 7 的结果。
输入：n = 3, goal = 3, k = 1。
输出：6。
答案2023-06-04：
# 大体步骤如下：
1.定义常量MOD和LIMIT，分别表示模数和阶乘表的最大值。
2.定义全局变量FAC和INV，分别表示阶乘表和阶乘结果的乘法逆元表。
3.编写init函数，用于初始化FAC和INV数组。在该函数中先将FAC[0]和INV[0]赋值为1，然后使用循环计算FAC[i]（i从1到LIMIT）的值，并使用费马小定理倒推计算出INV[i]（i从LIMIT到2）的值。
4.编写power函数，用于计算x的n次方并对MOD取模后的结果。
5.编写numMusicPlaylists函数，根据题目要求计算可以满足要求的播放列表数量。该函数中定义三个int64类型变量：cur、ans和sign。cur用于保存当前循环中需要累加到答案中的部分，ans则是最终结果。sign初始为1，在每次循环结束时将其乘以-1来实现交替相加或相减。
6.numMusicPlaylists函数中使用一个for循环遍历i从0到n-k。在每次循环中，首先计算cur = sign * pow(n-k-i, l-k) % MOD。其中pow函数调用了power函数来计算幂次方。
7.然后将cur乘以FAC[n]、INV[i]、INV[n-k-i]并分别对MOD取模，更新cur的值。
8.将cur加到ans中并对MOD取模，最后返回ans的int类型值。
时间复杂度：$O(n^2)$，其中n为歌曲数量。需要计算阶乘表和阶乘结果的乘法逆元表，时间复杂度均为O(n)。在numMusicPlaylists函数中使用了一个for循环，循环次数为n-k，每次循环中调用了power函数，时间复杂度为$O(logMOD)$，然后进行了常数次乘、除和取模运算，时间复杂度为O(1)。因此总时间复杂度为$O(n*(n-k)*logMOD)=O(n^2*logMOD)$。
空间复杂度：O(n)，主要是用来存储阶乘表和阶乘结果的乘法逆元表。
# go完整代码如下：
```go
package main
import "fmt"
const MOD int64 = 1000000007
const LIMIT int = 100
// 阶乘表
var FAC [LIMIT + 1]int64
// 阶乘结果的乘法逆元表
var INV [LIMIT + 1]int64
func init() {
FAC[0] = 1
INV[0] = 1
for i := 1; i <= LIMIT; i++ {
FAC[i] = (int64(i) * FAC[i-1]) % MOD
}
// 费马小定理计算乘法逆元，优化如下
// 这一块叫：阶乘的逆元倒推
INV[LIMIT] = power(FAC[LIMIT], int(MOD-2))
for i := LIMIT; i > 1; i-- {
INV[i-1] = (int64(i) * INV[i]) % MOD
}
}
// x的n次方，% mod之后，是多少？
func power(x int64, n int) int64 {
ans := int64(1)
for n > 0 {
if n&1 == 1 {
ans = (ans * x) % MOD
}
x = (x * x) % MOD
n >>= 1
}
return ans
}
func numMusicPlaylists(n int, l int, k int) int {
var cur, ans, sign int64 = 0, 0, 1
for i := 0; i <= n-k; i++ {
// cur ->
// FAC[n] -> n! % mod 的结果！
// INV[i] -> i! 的逆元！
// INV[n - k - i] -> (n - k - i)! 的逆元
// sign * 1 -> 1
// * -1 -> mod - 1
cur = (sign * power(int64(n-k-i), l-k)) % MOD
cur = (cur * FAC[n]) % MOD
cur = (cur * INV[i]) % MOD
cur = (cur * INV[n-k-i]) % MOD
ans = (ans + cur) % MOD
sign *= -1
}
return int(ans)
}
func main() {
n := 3
goal := 3
k := 1
result := numMusicPlaylists(n, goal, k)
fmt.Println(result)
}
```
# rust完整代码如下：
```rust
const MOD: i64 = 1_000_000_007;
const LIMIT: usize = 100;
// 阶乘表
static mut FAC: [i64; LIMIT + 1] = [0; LIMIT + 1];
// 阶乘结果的乘法逆元表
static mut INV: [i64; LIMIT + 1] = [0; LIMIT + 1];
unsafe fn init() {
INV[0] = 1;
FAC[0] = 1;
for i in 1..=LIMIT {
FAC[i] = ((i as i64) * FAC[i - 1]) % MOD;
}
// 费马小定理计算乘法逆元，优化如下
// 这一块叫：阶乘的逆元倒推
INV[LIMIT] = power(FAC[LIMIT], (MOD - 2) as i32);
for i in (2..=LIMIT).rev() {
INV[i - 1] = ((i as i64) * INV[i]) % MOD;
}
}
// x的n次方，% mod之后，是多少？
fn power(mut x: i64, mut n: i32) -> i64 {
let mut ans = 1;
while n > 0 {
if (n & 1) == 1 {
ans = (ans * x) % MOD;
}
x = (x * x) % MOD;
n >>= 1;
}
ans
}
pub fn num_music_playlists(n: i32, goal: i32, k: i32) -> i32 {
unsafe {
init();
let mut cur;
let mut ans = 0;
let mut sign = 1;
for i in 0..=n - k {
// cur ->
// FAC[n] -> n! % mod 的结果！
// INV[i] -> i! 的逆元！
// INV[n - k - i] -> (n - k - i)! 的逆元
// sign * 1 -> 1
// * -1 -> mod - 1
cur = (sign * power(n as i64 - k as i64 - i as i64, goal as i32 - k)) % MOD;
cur = (cur * FAC[n as usize]) % MOD;
cur = (cur * INV[i as usize]) % MOD;
cur = (cur * INV[(n - k - i) as usize]) % MOD;
ans = (ans + cur) % MOD;
sign *= -1;
}
ans as i32
}
}
fn main() {
let n = 3;
let goal = 3;
let k = 1;
let result = num_music_playlists(n, goal, k);
println!("{}", result);
}
```
# c++完整代码如下：
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
const int LIMIT = 100;
// 阶乘表
vector<int64_t> fac(LIMIT + 1);
// 阶乘结果的乘法逆元表
vector<int64_t> inv(LIMIT + 1);
int64_t pow2(int64_t x, int n);
void init() {
fac[0] = inv[0] = 1;
for (int i = 1; i <= LIMIT; i++) {
fac[i] = ((int64_t)i * fac[i - 1]) % MOD;
}
// 费马小定理计算乘法逆元，优化如下
// 这一块叫：阶乘的逆元倒推
inv[LIMIT] = pow2(fac[LIMIT], MOD - 2);
for (int i = LIMIT; i > 1; i--) {
inv[i - 1] = ((int64_t)i * inv[i]) % MOD;
}
}
// x的n次方，% mod之后，是多少？
int64_t pow2(int64_t x, int n) {
int64_t ans = 1;
while (n > 0) {
if (n & 1) {
ans = (ans * x) % MOD;
}
x = (x * x) % MOD;
n >>= 1;
}
return ans;
}
int numMusicPlaylists(int n, int l, int k) {
int64_t cur, ans, sign = 1;
ans = 0;
for (int i = 0; i <= n - k; ++i, sign = sign == MOD - 1 ? 1 : MOD - 1) {
// cur ->
// FAC[n] -> n! % mod 的结果！
// INV[i] -> i! 的逆元！
// INV[n - k - i] -> (n - k - i)! 的逆元
// sign * 1 -> 1
// * MOD-1 -> mod - 1
cur = (sign * pow2(n - k - i, l - k)) % MOD;
cur = (cur * fac[n]) % MOD;
cur = (cur * inv[i]) % MOD;
cur = (cur * inv[n - k - i]) % MOD;
ans = (ans + cur) % MOD;
}
return ans;
}
int main() {
init();
int n = 3, goal = 3, k = 1;
int result = numMusicPlaylists(n, goal, k);
cout << result << endl;
return 0;
}
```
# c完整代码如下：
```c
#include <stdio.h>
#include <stdint.h>
#define MOD 1000000007
#define LIMIT 100
// 阶乘表
int64_t fac[LIMIT + 1];
// 阶乘结果的乘法逆元表
int64_t inv[LIMIT + 1];
int64_t pow2(int64_t x, int n);
void init() {
fac[0] = inv[0] = 1;
for (int i = 1; i <= LIMIT; i++) {
fac[i] = ((int64_t)i * fac[i - 1]) % MOD;
}
// 费马小定理计算乘法逆元，优化如下
// 这一块叫：阶乘的逆元倒推
inv[LIMIT] = pow2(fac[LIMIT], MOD - 2);
for (int i = LIMIT; i > 1; i--) {
inv[i - 1] = ((int64_t)i * inv[i]) % MOD;
}
}
// x的n次方，% mod之后，是多少？
int64_t pow2(int64_t x, int n) {
int64_t ans = 1;
while (n > 0) {
if (n & 1) {
ans = (ans * x) % MOD;
}
x = (x * x) % MOD;
n >>= 1;
}
return ans;
}
int numMusicPlaylists(int n, int l, int k) {
int64_t cur, ans, sign = 1;
ans = 0;
for (int i = 0; i <= n - k; ++i, sign = sign == MOD - 1 ? 1 : MOD - 1) {
// cur ->
// FAC[n] -> n! % mod 的结果！
// INV[i] -> i! 的逆元！
// INV[n - k - i] -> (n - k - i)! 的逆元
// sign * 1 -> 1
// * MOD-1 -> mod - 1
cur = (sign * pow2(n - k - i, l - k)) % MOD;
cur = (cur * fac[n]) % MOD;
cur = (cur * inv[i]) % MOD;
cur = (cur * inv[n - k - i]) % MOD;
ans = (ans + cur) % MOD;
}
return ans;
}
int main() {
init();
int n = 3, goal = 3, k = 1;
int result = numMusicPlaylists(n, goal, k);
printf("%d\n", result);
return 0;
}
```
