比赛链接

A. Cloud Studio的共享连接

题目大意 && Solution

给定 $T$ 组长度均为 $12$ 的字符串 $s$。

对每个 $s$，将其按从左到右的顺序两两分组形成 $6$ 个 $\mathrm{ASCII}$ 码，对这 $6$ 个 $\mathrm{ASCII}$ 码都 $+50$，作为输出的字符串（即长度为 $6$ 的新字符串）。

直接模拟即可。

时间复杂度 $O(12\cdot T)$

C++ Code

#include <bits/stdc++.h>using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;constexpr f64 pi = std::numbers::pi;std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());void solve() {std::string s;std::cin >> s;std::string ans;for (int i = 0; i + 2 <= s.size(); i += 2) {ans += char(std::stoi(s.substr(i, 2)) + 50);}std::cout << ans << "\n";
}int main() {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout << std::fixed << std::setprecision(12);int T = 1;std::cin >> T;while (T--) {solve();}return 0;
}

B. 都是绘绘，都是早凉的老婆

题目大意

给定 $T$ 组数据，每组数据给定一棵树。

对于每棵 $n$ 个节点的树，$\mathrm{Alice}$ 和 $\mathrm{Bob}$ 想玩博弈论，但是不想玩得太简单，于是让 $\mathrm{Bob}$ 一开始选择一个点集 $V$，两人就在 $V$ 的 生成子图 $G=(V,E)$ 上开始玩，$\mathrm{Alice}$ 先手。

当前玩家可以选择删掉 $G$ 中的一条边，也可以删掉一个点及其所有相连的边。不能操作的玩家将输掉比赛；特别的，若 $G$ 为空，视为 $\mathrm{Bob}$ 胜利。

当然这都不重要，因为这是 $2023CCPC$ 哈尔滨的题目，结论是：

奇数个点的树的 $\mathrm{SG}$ 值为 $1$，偶数个点的树 $\mathrm{SG}$ 值为 $2$，$\mathrm{Bob}$ 选择的点集 $V$ 只需要满足每个连通块的 $\mathrm{SG}$ 值异或起来等于 $0$ 就有必胜策略。

特别的，空集的 $\mathrm{SG}$ 值为 $0$。

在此基础上，本题想问：$\mathrm{Bob}$ 有多少种方案选择点集 $V$ 能够获胜。

两种方案不同，当且仅当两次选择的点集 $V$ 不同。答案对 $998244353$ 取模。

数据范围

• $1\le \sum n\le 10^6$。

Solution

我们把异或起来为零翻译一下，可以得到：

• $|V|$ 一定为偶数，因为最终异或值要为 $0$，即不论出现多少个 $1$ 还是 $2$，都要求出现偶数个奇数点连通块或偶数个偶数点连通块；
• $|E|$ 一定为偶数，因为对每个连通块来说都有 $|E_i|=|V_i|-1$（树中拆出来的连通块的性质）。

定义 $\mathrm{dp}[\mathrm{x}][0/1][0/1][0/1]$ 为总方案数，细节如下。

• 对当前结点 $x$，
• 第一个 $0/1$ 表示 $\mathrm{不选}/\mathrm{选}$ $x$ 加入 $V$，
• 第二个 $0/1$ 表示已经选择的点集 $V$ 大小的奇偶，$|V|$ 为偶（奇）时为 $0$（$1$），
• 第三个 $0/1$ 表示由已选择点集 $V$ 导出的边集 $E$ 大小的奇偶，$|E|$ 为偶（奇）时为 $0$（$1$）。

下面我们定义 二维矩阵的三个运算（$\oplus$ 为异或运算）。

• 加法 $+$：与正常的矩阵一样，对于 $c=a+b$，有 $$c[i][j]=a[i][j]+b[i][j],0\le i,j<2.$$
• 乘法 $\times$：乘法被重新定义，对于 $c=a\times b$，有 $$c[i\oplus u][j\oplus v]=c[i\oplus u][j\oplus v]+a[i][j]\times b[u][v],0\le i,j,u,v<2.$$ 这里的乘法意思是：$i$ 和 $u$ 分别表示点集大小 $|V|$ 的奇偶，$j$ 和 $v$ 分别表示边集大小 $|E|$ 的奇偶，这样合并二者的方案数只需要枚举 $2^4$ 种情况；而最终新的奇偶性就是 $i\oplus u$ 和 $j\oplus v$。
• 取反 $!$：也是重新定义，对于 $c=!a$，有 $$c[i][j\oplus 1]=a[i][j],0\le i,j<2.$$ 这里的取反意思是：$i$ 表示点集 $|V|$ 大小的奇偶，$j$ 表示边集大小 $|E|$ 的奇偶，当我确定我加入了 $1$ 条新的边，边集的奇偶性就发生改变，所以最后一个维度的方案数应该调换。

下面考虑状态转移。

• $\mathrm{dp}[\mathrm{x}][0]=\mathrm{dp}[\mathrm{x}][0]\times (\mathrm{dp}[\mathrm{y}][0]+\mathrm{dp}[\mathrm{y}][1])$，这表示对于 $x$ 及其子树，不选择 $x$，那么选择 $y$ 不会 引起边的奇偶性变化，只要将其合并到 $\mathrm{dp}[\mathrm{x}][0]$ 中即可；
• $\mathrm{dp}[\mathrm{x}][1]=\mathrm{dp}[\mathrm{x}][1]\times (\mathrm{dp}[\mathrm{y}][0]+!\mathrm{dp}[\mathrm{y}][1])$，这表示对于 $x$ 及其子树，选择了 $x$，那么选择 $y$ 会 引起边的奇偶性变化，需要取反并将其合并到 $\mathrm{dp}[\mathrm{x}][1]$。

初始化：对于 $x\in [1,n]$，均有 $\mathrm{dp}[\mathrm{x}][0][0][0]=\mathrm{dp}[\mathrm{x}][1][1][0]=1$，分别表示 $0$ 个点 $0$ 条边，以及 $1$ 个点 $0$ 条边，都是一种方案。

最终答案 $\mathrm{dp}[0][0][0][0]+\mathrm{dp}[0][1][0][0]$。

时间复杂度 $O(2^4\sum \mathrm{n})$

• 常数会稍大，$10^6$ 的递归栈消耗很大。

C++ Code

#include <bits/stdc++.h>using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;constexpr f64 pi = std::numbers::pi;std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());template<class T>
constexpr T power(T a, i64 b) {T res = 1;for (; b; b /= 2, a *= a) {if (b % 2) {res *= a;}}return res;
}
template<int P>
struct MInt {int x;constexpr MInt() : x{} {}constexpr MInt(i64 x) : x{norm(x % getMod())} {}static int Mod;constexpr static int getMod() {if (P > 0) {return P;} else {return Mod;}}constexpr static void setMod(int Mod_) {Mod = Mod_;}constexpr int norm(int x) const {if (x < 0) {x += getMod();}if (x >= getMod()) {x -= getMod();}return x;}constexpr int val() const {return x;}explicit constexpr operator int() const {return x;}constexpr MInt operator-() const {MInt res;res.x = norm(getMod() - x);return res;}constexpr MInt inv() const {assert(x != 0);return power(*this, getMod() - 2);}constexpr MInt &operator*=(MInt rhs) & {x = 1LL * x * rhs.x % getMod();return *this;}constexpr MInt &operator+=(MInt rhs) & {x = norm(x + rhs.x);return *this;}constexpr MInt &operator-=(MInt rhs) & {x = norm(x - rhs.x);return *this;}constexpr MInt &operator/=(MInt rhs) & {return *this *= rhs.inv();}friend constexpr MInt operator*(MInt lhs, MInt rhs) {MInt res = lhs;res *= rhs;return res;}friend constexpr MInt operator+(MInt lhs, MInt rhs) {MInt res = lhs;res += rhs;return res;}friend constexpr MInt operator-(MInt lhs, MInt rhs) {MInt res = lhs;res -= rhs;return res;}friend constexpr MInt operator/(MInt lhs, MInt rhs) {MInt res = lhs;res /= rhs;return res;}friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {i64 v;is >> v;a = MInt(v);return is;}friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {return os << a.val();}friend constexpr bool operator==(MInt lhs, MInt rhs) {return lhs.val() == rhs.val();}friend constexpr bool operator!=(MInt lhs, MInt rhs) {return lhs.val() != rhs.val();}
};template<>
int MInt<0>::Mod = 998244353;template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();constexpr int P = 998244353;
using Z = MInt<P>;using Vector = std::array<Z, 2>;
using Matrix = std::array<Vector, 2>;
using Tensor = std::array<Matrix, 2>;Matrix operator+(const Matrix &a, const Matrix &b) {Matrix c{};for (int i = 0; i < 2; i++) {for (int j = 0; j < 2; j++) {c[i][j] = a[i][j] + b[i][j];}}return std::move(c);
}
Matrix operator*(const Matrix &a, const Matrix &b) {Matrix c{};for (int i = 0; i < 2; i++) {for (int j = 0; j < 2; j++) {if (a[i][j] == 0) {continue;}for (int u = 0; u < 2; u++) {for (int v = 0; v < 2; v++) {c[i ^ u][j ^ v] += a[i][j] * b[u][v];}}}}return std::move(c);
}
Matrix operator!(const Matrix &a) {auto c = a;for (int i = 0; i < 2; i++) {std::swap(c[i][0], c[i][1]);}return std::move(c);
}void solve() {int n;std::cin >> n;std::vector<std::vector<int>> adj(n);for (int i = 1; i < n; i++) {int u, v;std::cin >> u >> v;u--, v--;adj[u].push_back(v);adj[v].push_back(u);}std::vector<Tensor> dp(n);auto dfs = [&](auto &&self, int x) -> void {dp[x][0][0][0] = 1;dp[x][1][1][0] = 1;for (int y: adj[x]) {adj[y].erase(std::ranges::find(adj[y], x));self(self, y);auto res = dp[y][0] + dp[y][1];dp[x][0] = dp[x][0] * res;res = dp[y][0] + !dp[y][1];dp[x][1] = dp[x][1] * res;}};dfs(dfs, 0);auto ans = dp[0][0] + dp[0][1];std::cout << ans[0][0] << "\n";
}int main() {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout << std::fixed << std::setprecision(12);int T = 1;std::cin >> T;while (T--) {solve();}return 0;
}

C. Anon也想玩双影奇境

题目大意

给定 $T$ 组数据，每组有两个正整数 $n,m$。

对每个 $n,m$，要求算出其二进制表示有多少位是相同的（如果长度不一样就补前导零）。

例如 $n=2,m=19$，其二进制表示分别是 $00010,10011$，有 $3$ 位相同。

Solution

用短除法将 $n,m$ 转化为二进制字符串，并补齐前导零后，直接遍历比较即可。

时间复杂度 $O(\sum \log \max (\mathrm{n},\mathrm{m}))$

C++ Code

#include <bits/stdc++.h>using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;constexpr f64 pi = std::numbers::pi;std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());void solve() {int n, m;std::cin >> n >> m;auto get = [&](int x) {std::string ans;for (int y = x; y > 0; y /= 2) {ans += char(y % 2 + '0');}return ans;};auto sn = get(n);auto sm = get(m);while (sn.size() < sm.size()) {sn += '0';}while (sm.size() < sn.size()) {sm += '0';}int N = sn.size();std::cout << std::ranges::count_if(std::views::iota(0, N), [&](int i) {return sn[i] == sm[i];}) << "\n";
}int main() {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout << std::fixed << std::setprecision(12);int T = 1;std::cin >> T;while (T--) {solve();}return 0;
}

D. 诗寇蒂Skuld

题目大意

给定 $n$ 朵花的信息 $a_i,l_i,r_i$，分别表示第 $i$ 朵花的 美丽值 以及 开花的区间 $[l_i,r_i]$。再给定一个 $m$ 表示你可以施展魔法的次数；每次施展魔法你可以做如下操作一次：

• 选定一个下标 $i$，要么令 $l_i:=l_i-1$，要么令 $r_i:=r_i+1$。

现在规定某一天的美丽值 $A$ 为** 所有盛开的花的美丽值之和**，求出最多使用 $m$ 次魔法后的 $\max (A)$。

数据范围

• $1\le n\le 100$；
• $0\le m\le 2025$；
• $1\le a_i,l_i,r_i\le 10^9$。

Solution

首先给出结论，这种题目的 某一天 一定可以在某个端点 $l_i$ 或 $r_i$ 处取到。

假设我们是在 非端点处 $d$ 求得了 $\max (A)$，那么一定存在一些 $i$ 使得 $d\in (l_i,r_i)$，否则去到区间并 $\bigcup _{i=1}^n[l_i,r_i]$ 都没有覆盖的地方，一定不会最优。此时对于那些不包含 $d$ 的区间 $[l_j,r_j]$，一定有 $d<l_j$ 或 $d>r_j$（因为 $d$ 一定不在端点）。

设对于当前 $d$，

• 包含 $d$ 的区间下标集合为 $C$；
• 左边有 $c_l$ 个区间可以通过魔法改变右端点到达 $d$，操作 $s_l$ 次；
• 右边有 $c_r$ 个区间可以通过魔法改变左端点到达 $d$，操作 $s_r$ 次。

下面说明我们可以将 $d$ 移到端点而保持答案不变甚至更优。

• $c_l<c_r$，那我们可以找到一个 $i\in C$，使得 $r_i=\underset{k\in C}{\min }{r}_k$，此时将 $d$ 右移到 $r_i$，那么 $$\begin{gathered} s_l:=s_l+c_l, \\ {s}_r:=s_r-c_r, \end{gathered}$$ 这样一来总的操作次数 $s=s_l+s_r$ 就变小了，而且美丽值不变；
• $c_l>c_r$，那我们可以找到一个 $i\in C$，使得 $l_i=\underset{k\in C}{\max }{l}_k$，此时将 $d$ 左移到 $l_i$，那么 $$\begin{gathered} s_l:=s_l-c_l, \\ {s}_r:=s_r+c_r, \end{gathered}$$ 这样一来总的操作次数 $s=s_l+s_r$ 就变小了，而且美丽值不变；
• $c_l=c_r$，那我们随便往上述的 $l_i$ 或 $r_i$ 移，总操作次数 $s$ 不变。

综上，在端点处一定可以取到 $\max (A)$。

下设 $cos{t}_i(d)$ 函数（$i\in [1,n]$）：

$$cos{t}_i(d)=\{\begin{array}{ll}{l}_i-d,& d<l_i,\\ 0,& d\in [l_i,r_i]\\ d-r_i,& d>r_i.\end{array}$$

对于当前的 $d$，可以把 $cos{t}_i(d)$ 看成物品体积，把 $a_i$ 看成物品价值，这样就变成了背包容量为 $m$ 的一个 $01$ 背包问题了。

时间复杂度 $O({\mathrm{n}}^2\mathrm{m})$

C++ Code

#include <bits/stdc++.h>using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;constexpr f64 pi = std::numbers::pi;template<class T, size_t L>
std::istream &operator>>(std::istream &is, std::array<T, L> &a) {for (auto &x: a) {is >> x;}return is;
}
template<class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {for (auto &x: v) {is >> x;}return is;
}int main() {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);int n, m;std::cin >> n >> m;std::vector<std::array<int, 3>> flower(n);std::cin >> flower;std::vector<int> days;for (const auto &[a, l, r]: flower) {days.push_back(l);days.push_back(r);}std::ranges::sort(days);days.erase(std::unique(days.begin(), days.end()), days.end());i64 ans = 0;for (int d: days) {i64 sum = 0;std::vector<std::pair<int, int>> obj;for (const auto &[a, l, r]: flower) {if (d < l) {obj.emplace_back(l - d, a);} else if (d > r) {obj.emplace_back(d - r, a);} else {sum += a;}}std::vector<i64> dp(m + 1);for (const auto &[v, w]: obj) {for (int s = m; s >= v; s--) {dp[s] = std::max(dp[s], dp[s - v] + w);}}ans = std::max(ans, sum + dp[m]);}std::cout << ans << "\n";return 0;
}

E. 乌尔德+Urd

题目大意

给定 $T$ 组数据，每组给定三个正整数 $n,m,p$。

设有无穷多项的斐波那契数列 $f_1=1,f_2=1,f_3=2,\cdots$。

对每个 $n,m,p$，求 $$\sum _{i=1}^n[m\mid i]\cdot f_i.$$

其中 $m\mid i$ 表示 $m$ 可以整除 $i$，例如 $2\mid 4$；$f_i$ 表示斐波那契数列的第 $i$ 项。

数据范围

• $1\le T\le 10^5$；
• $1\le n,m\le 10^{18}$；
• $1\le p\le 10^9$。

Solution

其实在斐波那契这里看见这么大的数据范围，就应该立即想到矩阵快速幂了。

我们特别规定 $f_0=0$。考虑一个二维向量 $F_n=[f_n,f_{n+1}]$，以及一个转移矩阵

$$A=\left[\begin{array}{cc}0& 1\\ 1& 1\end{array}\right],$$

这样一来就有 $F_{n+1}=F_n\times A$，根据矩阵的结合律，有 $F_n=F_0\times A^n$。

那么求和式可以化简为（$F_n[0]=f_n$）

$$\begin{array}{rl}\sum _{i=1}^n[m\mid i]\cdot f_i& =\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }{f}_{i\cdot m}\\ & =\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }{F}_{i\cdot m}[0]\\ & =\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }(F_0\times A^{i\cdot m})[0]\\ & =(F_0\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }(A^m{)}^i)[0]\\ & =([0,1]\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }(A^m{)}^i)[0]\\ & =\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }(B^i)[1][0].\end{array}$$

其中 $B=A^m$，$B[1][0]$ 表示 $B$ 这个二维矩阵第 $1$ 行第 $0$ 列的元素（下标从 $0$ 开始）。

那么我们其实可以求出 $\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }{B}^i$ 后，再取其第 $1$ 行第 $0$ 列的元素。而考虑单位阵 $$E=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]$$ 的左下角是 $0$，所以我们可以求 $E+\sum _{i=1}^{\lfloor \frac{n}{m}\rfloor }{B}^i=\sum _{i=0}^{\lfloor \frac{n}{m}\rfloor }{B}^i$。

下设 $N=\lfloor \frac{n}{m}\rfloor$，我们考虑分治求解 $\sum _{i=0}^N{B}^i$。

• 当 $N=0$，直接返回 $E$；
• 当 $N$ 为奇数，那么式子可以拆成长度相同的两部分，分别是 $$\begin{gathered} E+A+A^2+\cdots +A^{\lfloor \frac{N}{2}\rfloor }, \\ {A}^{\lfloor \frac{N}{2}\rfloor +1}+A^{\lfloor \frac{N}{2}\rfloor +2}+\cdots +A^N. \end{gathered}$$ 而把下面提一个 $A^{\lfloor \frac{N}{2}\rfloor +1}$ 就可以得到上面，所以直接算前一半，最后乘以 $(E+A^{\lfloor \frac{N}{2}\rfloor +1})$ 即可。
• 当 $N$ 为偶数，先把 $E$ 去掉，再对后面的式子提一个 $A$，就可以得到 $$E+A(E+A+A^2+\cdots +A^{N-1}),$$ 后面的 $(E+A+A^2+\cdots +A^{N-1})$ 就是 $N-1$ 为奇数的情况。

时间复杂度 $O(\sum (\log m+\log \lfloor \frac{n}{m}\rfloor ))=O(\sum \log n)$

• 其中 $2\times 2$ 矩阵的常数基本可以忽略。

C++ Code

#include <bits/stdc++.h>using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;constexpr f64 pi = std::numbers::pi;std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());template<int P>
struct MInt {int x;constexpr MInt() : x{} {}constexpr MInt(i64 x) : x{norm(x % getMod())} {}static int Mod;constexpr static int getMod() {if (P > 0) {return P;} else {return Mod;}}constexpr static void setMod(int Mod_) {Mod = Mod_;}constexpr int norm(int x) const {if (x < 0) {x += getMod();}if (x >= getMod()) {x -= getMod();}return x;}constexpr int val() const {return x;}explicit constexpr operator int() const {return x;}constexpr MInt operator-() const {MInt res;res.x = norm(getMod() - x);return res;}constexpr MInt inv() const {assert(x != 0);return power(*this, getMod() - 2);}constexpr MInt &operator*=(MInt rhs) & {x = 1LL * x * rhs.x % getMod();return *this;}constexpr MInt &operator+=(MInt rhs) & {x = norm(x + rhs.x);return *this;}constexpr MInt &operator-=(MInt rhs) & {x = norm(x - rhs.x);return *this;}constexpr MInt &operator/=(MInt rhs) & {return *this *= rhs.inv();}friend constexpr MInt operator*(MInt lhs, MInt rhs) {MInt res = lhs;res *= rhs;return res;}friend constexpr MInt operator+(MInt lhs, MInt rhs) {MInt res = lhs;res += rhs;return res;}friend constexpr MInt operator-(MInt lhs, MInt rhs) {MInt res = lhs;res -= rhs;return res;}friend constexpr MInt operator/(MInt lhs, MInt rhs) {MInt res = lhs;res /= rhs;return res;}friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {i64 v;is >> v;a = MInt(v);return is;}friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {return os << a.val();}friend constexpr bool operator==(MInt lhs, MInt rhs) {return lhs.val() == rhs.val();}friend constexpr bool operator!=(MInt lhs, MInt rhs) {return lhs.val() != rhs.val();}
};template<>
int MInt<0>::Mod = 998244353;template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();constexpr int P = 0;
using Z = MInt<P>;template<class T>
T power(T a, i64 b) {T res;res.unit(a.n);for ( ; b; b /= 2, a *= a) {if (b & 1) {res *= a;}}return res;
}
template<class T>
struct Matrix {int n, m;std::vector<std::vector<T>> g;Matrix() {}Matrix(int _n, int _m) {init(_n, _m);}Matrix(int _n) {init(_n);}template<class T2>Matrix(std::vector<std::vector<T2>> _g) {init(_g);}void init(int _n, int _m) {n = _n, m = _m;g.resize(n);for (int i = 0; i < n; i += 1) {g[i].resize(m);}}void init(int _n) {init(_n, _n);}void unit(int _n) {init(_n, _n);for (int i = 0; i < n; i += 1) {g[i][i] = 1;}}template<class T2>void init(std::vector<std::vector<T2>> _g) {init(_g.size(), _g[0].size());for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {g[i][j] = T(_g[i][j]);}}}std::vector<T> &operator[](int i) { return g[i];}void fill(const T v) {for (int i = 0; i < n; i += 1) {g[i].assign(m, v);}}// 0：逆时针，1：顺时针void rotate(int d, int x1, int y1, int x2, int y2) {assert(d == 0 or d == 1);Matrix<T> G(n, m);if (x2 - x1 == n and y2 - y1 == m) {G.init(m, n);}if (d == 0) {for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {if (i >= x1 and i < x2 and j >= y1 and j < y2) {G[x2 - (j - y1) - 1][y1 + (i - x1)] = g[i][j];} else {G[i][j] = g[i][j];}}}} else {for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {if (i >= x1 and i < x2 and j >= y1 and j < y2) {G[x1 + (j - y1)][y2 - (i - x1) - 1] = g[i][j];} else {G[i][j] = g[i][j];}}}}*this = G;}void rotate(int d) {rotate(d, 0, 0, n, m);}// 0：上下翻转，1：左右翻转void flip(int d, int x1, int y1, int x2, int y2) {assert(d == 0 or d == 1);Matrix<T> G(n, m);if (d == 0) {for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {if (i >= x1 and i < x2 and j >= y1 and j < y2) {G[(x1 + x2) - i - 1][j] = g[i][j];} else {G[i][j] = g[i][j];}}}} else {for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {if (i >= x1 and i < x2 and j >= y1 and j < y2) {G[i][(y1 + y2) - j - 1] = g[i][j];} else {G[i][j] = g[i][j];}}}}*this = G;}void flip(int d) {flip(d, 0, 0, n, m);}Matrix<T> transpose() {Matrix<T> res(m, n);for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {res[j][i] = g[i][j];}}return res;}template<class T2>Matrix<T> &operator+=(Matrix<T2> A) & {assert(n == A.n and m == A.m);for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {g[i][j] += T(A[i][j]);}}return *this;}template<class T2>friend Matrix<T> operator+(Matrix<T> A, Matrix<T2> B) {Matrix<T> res = A;res += B;return res;}template<class T2>Matrix<T> &operator-=(Matrix<T2> A) & {assert(n == A.n and m == A.m);for (int i = 0; i < n; i += 1) {for (int j = 0; j < m; j += 1) {g[i][j] -= T(A[i][j]);}}return *this;}template<class T2>friend Matrix<T> operator-(Matrix<T> A, Matrix<T2> B) {Matrix<T> res = A;res -= B;return res;}template<class T2>Matrix<T> &operator*=(Matrix<T2> A) & {assert(m == A.n);Matrix<T> res(n, A.m);for (int i = 0; i < n; i += 1) {for (int j = 0; j < A.m; j += 1) {for (int k = 0; k < m; k += 1) {res[i][j] += g[i][k] * T(A[k][j]);}}}return *this = res;}template<class T2>friend Matrix<T> operator*(Matrix<T> A, Matrix<T2> B) {Matrix<T> res = A;res *= B;return res;}friend std::istream &operator>>(std::istream &is, Matrix<T> &A) {for (int i = 0; i < A.n; i += 1) {for (int j = 0; j < A.m; j += 1) {is >> A[i][j];}}return is;}friend std::ostream &operator<<(std::ostream &os, Matrix<T> &A) {for (int i = 0; i < A.n; i += 1) {for (int j = 0; j < A.m; j += 1) {os << A[i][j] << " \n"[j + 1 == A.m];}}return os;}friend bool operator==(Matrix<T> A, Matrix<T> B) {if (A.n != B.n) {return false;} else if (A.m != B.m) {return false;}for (int i = 0; i < A.n; i += 1) {for (int j = 0; j < A.m; j += 1) {if (A[i][j] != B[i][j]) {return false;}}}return true;}friend bool operator!=(Matrix<T> A, Matrix<T> B) {if (A.n != B.n) {return true;} else if (A.m != B.m) {return true;}for (int i = 0; i < A.n; i += 1) {for (int j = 0; j < A.m; j += 1) {if (A[i][j] != B[i][j]) {return true;}}}return false;}friend bool operator<(Matrix<T> A, Matrix<T> B) {if (A.n != B.n) {return A.n < B.n;} else if (A.m != B.m) {return A.m < B.m;}for (int i = 0; i < A.n; i += 1) {for (int j = 0; j < A.m; j += 1) {if (A[i][j] != B[i][j]) {return A[i][j] < B[i][j];}}}return false;}friend bool operator>(Matrix<T> A, Matrix<T> B) {if (A.n != B.n) {return A.n > B.n;} else if (A.m != B.m) {return A.m > B.m;}for (int i = 0; i < A.n; i += 1) {for (int j = 0; j < A.m; j += 1) {if (A[i][j] != B[i][j]) {return A[i][j] > B[i][j];}}}return false;}
};void solve() {i64 n, m, p;std::cin >> n >> m >> p;if (p == 1) {std::cout << 0 << "\n";return;}Z::setMod(p);Matrix<Z> E(std::vector<std::vector<Z>>{{1, 0},{0, 1}});Matrix<Z> A(std::vector<std::vector<Z>>{{0, 1},{1, 1}});A = power(A, m);auto dfs = [&](auto &&self, i64 n) -> Matrix<Z> {if (n == 0) {return E;}return (n & 1) ? (E + power(A, n / 2 + 1)) * self(self, n / 2): (E + A * self(self, n - 1));};auto ans = dfs(dfs, n / m);std::cout << ans[1][0] << "\n";
}int main() {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout << std::fixed << std::setprecision(12);int T = 1;std::cin >> T;while (T--) {solve();}return 0;
}