HH去散步

题目link：https://www.luogu.com.cn/problem/P2151

---

Part0：

注意题目有重边。

---

Part1：

首先这道题的题目限制为走过一条边不能按原边返回，这就导致了这个图的有向性，从而得出需要拆边的结论。

---

Part2：

拆完边后，容易看出如果要想满足题目限制，那么相当于走过第 $i$ 条边后，除了 $i$ 的反向边都可以走。

---

Part3：

得到上述特性后，再来观察题目，发现数据范围里的 $m$ 的值比较小，且比较的特殊，但是注意，因为通过 Part1 和 Part2 已经拆完边了，那么边的数量需要 $*$ $2$ 。

众所周知，这道题要求的路径方案数和邻接矩阵的幂次方有很大的关系，再加上 $2$ $*$ $m$ $=$ $120$ 这个值，发现 $120^3$ $*$ $log$ $t$ （矩阵快速幂的复杂度为 $O($$n^3$ $log$ $k$$)$）约为 $5e7$ ，不会超时，因此考虑用 $2$ $*$ $m$ 为行列的大小建一个矩阵。

---

Part4：

建完矩阵后，容易发现矩阵中的元素的一种恰当且显然的意义为如果第 $i$ 条边的终点是第 $j$ 条边的起点 $&&$ 第 $i$ 条边和第 $j$ 条边不是反向边，那么矩阵中的第 $i$ 行第 $j$ 列的元素就是 $1$ ，否则为 $0$ 。

---

Part5：

考虑矩形的 $k$ 次方是什么含义，设 $k$ 次方之后的矩形为 $A$ ，那么容易得出 $A_{i, j}$ 是在图上第 $i$ 条边经过 $k$ $+$ $1$ 条边到达第 $j$ 条边（包括第 $i$ 条边和第 $j$ 条边）的方案数。

---

Part6：

这样，便容易得出求答案的方法为：在建完矩阵后用矩阵快速幂求出它的 $t$ $-$ $1$ 次方（注意不是 $t$ 次方），枚举起点 $a$ 的所有出边和终点 $b$ 的所有入边，累加计算一下就好了。

---

Code：

#include <cstdio>

typedef long long LL;

const int MAXM = 60;
const LL MOD = 45989;

int n, m, t, a, b;
int outA[MAXM + 5], inB[MAXM + 5], cntA, cntB, cntEdge;

struct Node {
    int st, to;
};

struct Mat {

    int N;
    LL arr[2 * MAXM + 5][2 * MAXM + 5];

    Mat() {}
    Mat(int _N, LL val = 0ll) {
        N = _N;
        for(int i = 1; i <= N; ++i) {
            for(int j = 1; j <= N; ++j) {
                arr[i][j] = (i == j) ? val : 0ll;
            }
        }
    }

    // void print() {
    //     for(int i = 1; i <= N; ++i) {
    //         for(int j = 1; j <= N; ++j) {
    //             printf("%d%c", arr[i][j], (j == N - 1) ? '
' : ' ');
    //         }
    //     }
    //     puts("");
    // }

};

Mat operator* (const Mat &A, const Mat &B) {

    Mat res(A.N);

    for(int i = 1; i <= res.N; ++i) {
        for(int j = 1; j <= res.N; ++j) {
            for(int k = 1; k <= res.N; ++k) {
                res.arr[i][j] += A.arr[i][k] * B.arr[k][j];
                res.arr[i][j] %= MOD;
            }
        }
    }

    return res;
}

Mat qpow(Mat A, int k) {

    Mat res(A.N, 1ll);

    for(; k; k >>= 1) {
        if(k & 1) res = res * A;
        A = A * A;
    }

    return res;
}

int main() {

    scanf("%d %d %d %d %d", &n, &m, &t, &a, &b);

    Node edge[2 * MAXM + 5]; // 存边
    for(int i = 1, x, y; i <= m; ++i) {
        scanf("%d %d", &x, &y);
        edge[++cntEdge].st = x, edge[cntEdge].to = y;
        edge[++cntEdge].st = y, edge[cntEdge].to = x;
        if(x == a || y == a) { // 记录起点和终点的出边和入边
            outA[++cntA] = (x == a) ? cntEdge - 1 : cntEdge;
        }
        if(x == b || y == b) {
            inB[++cntB] = (x == b) ? cntEdge : cntEdge - 1;
        }
    }

    Mat fac(2 * m); // 建矩阵
    for(int i = 1; i <= cntEdge; ++i) {
        for(int j = 1; j <= cntEdge; ++j) {
            if(i == j || ((i & 1) && (j == i + 1)) || ((!(i & 1)) && (j == i - 1))) continue;
            if(edge[i].to == edge[j].st) {
                fac.arr[i][j] = 1ll;
            }
        }
    }
    
    fac = qpow(fac, t - 1); // 矩阵快速幂

    LL ans = 0; // 枚举出入边求解
    for(int i = 1; i <= cntA; ++i) {
        for(int j = 1; j <= cntB; ++j) {
            ans += fac.arr[outA[i]][inB[j]];
            ans %= MOD;
        }
    }

    printf("%lld
", ans);

    return 0;
}