HDOJ 2294 - Pendant

Matrix Multiplication (& Quick Power)

Description

有个高富帅，要送个很装逼的吊坠给他女朋友。

他有k种珠子，然后要串成一个 珠子个数小于等于n 的链子。

因为要够装逼，所以这k种珠子都必须要用到。

好了，输入n和k。

输出他可以做出多少种不一样的项链。

Type

Matrix Multiplication
Quick Power

Analysis

一看又是爽歪歪的递推题。

我们来考虑如何递推出。

设f(x, y)为前x个位置，搞了y种不同的珠子。

然后我们考虑f(x, y)和f(x – 1, ...)关系。

而前后的关系，就差在第x个位置，要放什么类型的珠子。

我们可以放前面x – 1个位置已经放过的珠子，有y种颜色可以选。

那么就有 f(x – 1, y) * y种。

也可以放前面x – 1个位置还没放过的珠子，有k- (y – 1)种颜色可以选。

那么就有 f(x – 1, y – 1) * (k – y + 1) 种。

所以我们就得到递推公式 —— f(x, y) = f(x – 1, y) * y + f(x – 1, y – 1) * (k – y + 1)

好了，有了递推公式就碉堡了，剩下的就是矩阵乘法和快速幂。

当然，也要注意一些小的细节。

我们所求的不是f(x, y)，而是f(1, y) ~ f(x, y)的总和（因为珠子个数是小于等于n嘛）。

因此我们需要在矩阵的解向量中，增加一项sum(x – 1)，且 sum(x – 1) = sum(x – 2) + f(x - 1, y)。

这题对1234567891取余，有点那啥。

在矩阵乘法中，我们通常是每一个矩阵元素计算完后，再去取余，这样可以减少大量运算时间

（如果你不是这样的，那我告诉你，真的省很多）。

而这题由于这个除数真TMD的大，矩阵相乘的时候，两个元素相乘然后加加加加加...

最后你懂的，就超过long long的范围，溢出了，囧。

深一步讲，因为long long = int * int，而除数过于接近int。

导致我们计算的数接近于int * int * order（矩阵的阶），就爆了。

好吧，怎么办？

一种办法是用unsigned long long，的确可以A，速度还蛮快。

当然如果感觉不够妥妥的，可以每次在计算的时候，做完int * int马上mod，就不会悲剧啦。

（如果你现在不知道我在讲什么，那就等到你在写矩阵相乘函数的时候，你就懂了～）

Solution

// HDOJ 2294
// pendant
// by A Code Rabbit

#include <cstdio>
#include <cstring>

const int MAXO = 33;
const int MOD = 1234567891;

template <typename T>
struct Matrix {
T e[MAXO][MAXO];
int o;
Matrix(int ord) { memset(e, 0, sizeof(e)); o = ord; }
Matrix operator*(const Matrix& one) {
Matrix res(o);
for (int i = 0; i < o; i++)
for (int j = 0; j < o; j++)
for (int k = 0; k < o; k++)
res.e[i][j] += e[i][k] * one.e[k][j];
return res;
}
Matrix operator%(int mod) {
for (int i = 0; i < o; i++)
for (int j = 0; j < o; j++)
e[i][j] %= mod;
return *this;
}
};

template <typename T>
T QuickPower(T rdx, int exp, int mod) {
T res = rdx;
exp--;
while (exp) {
if (exp & 1) res = res * rdx % mod;
exp >>= 1;
rdx = rdx * rdx % mod;
}
return res;
}

int n, k;

int main() {
int tot_case;
scanf("%d", &tot_case);
while (tot_case--) {
// Input.
scanf("%d%d", &n, &k);
// Sovle.
Matrix<unsigned long long> mat_one(k + 1);
mat_one.e[0][0] = 1;
mat_one.e[k][0] = 1;
for (int i = 1; i < k + 1; ++i) {
mat_one.e[i][i] = i;
if (i > 1) mat_one.e[i - 1][i] = k - i + 1;
}
Matrix<unsigned long long> mat_ans = QuickPower(mat_one, n, MOD);
// Output.
printf("%d\n", k * mat_ans.e[1][0] % MOD);
}

return 0;
}