复杂度瓶颈应当是 $bfs$ 的 $O(nm)$ , 但完全跑不满啊

代码

#include <bits/stdc++.h>
using namespace std;
 
namespace IO {
    template <typename T>
    inline void read(T &x) {
        x = 0; T r = 1;
        char ch = getchar();
        while (!isdigit(ch)) r = ch == '-' ? -1 : 1, ch = getchar();
        while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
        x *= r;
    }
 
    template <typename T, typename ...Args>
    void read(T &x, Args &...args) {
        read(x), read(args...);
    }
 
    template <typename T>
    inline void write(T x) {
        if (x < 0) putchar('-'), x = -x;
        if (x > 9) write(x / 10);
        putchar(x % 10 + '0');
    }
}
 
using namespace IO;
 
using db = double;
using ll = long long;
using pii = pair<int, int>;
using ull = unsigned long long;
 
#define pc putchar
#define fi first
#define se second
#define eb emplace_back
 
const int N = 605;
 
struct Edge {
    int nxt, to;
} e[N * N];
int head[N * N], cnte;
 
void link(int x, int y) {
    e[++ cnte] = {head[x], y};
    head[x] = cnte;
}
 
int n, m, mod, tots, tott;
int in[N], out[N];
int w[N][N];
 
int s[N], t[N];
 
int add(int a, int b) {return (a + b >= mod) ? (a + b - mod) : (a + b);}
int sub(int a, int b) {return add(a, mod - b);}
int mul(int a, int b) {return 1ll * a * b % mod;}
 
int fpw(int a, int b) {
    int c = 1;
    while (b) {
        if (b & 1) c = mul(c, a);
        a = mul(a, a);
        b >>= 1; 
    }
    return c;
}
 
 
int det(int n) {
    int res = 1;
    for (int i = 1; i <= n; ++ i) {
        if (!w[i][i]) {
            for (int j = i + 1; j <= n; ++ j) {
                if (w[j][i]) {
                    swap(w[i], w[j]);
                    res = mod - res;
                    break;
                }
            }
        }
        int inv = fpw(w[i][i], mod - 2);
        for (int j = i + 1; j <= n; ++ j) {
            int t = mul(w[j][i], inv);
            for (int k = i; k <= n; ++ k) {
                w[j][k] = sub(w[j][k], mul(w[i][k], t));
            }
        }
        res = mul(res, w[i][i]);
    }
    return res;
}
 
queue<int> q;
int f[N][N], id[N], tot;
 
void bfs() {
    for (int i = 1; i <= tots; ++ i) {
        int u = id[i]; f[u][u] = 1;
        for (int j = i; j <= n; ++ j) {
            int v = id[j]; 
            for (int k = head[v]; k; k = e[k].nxt) f[u][e[k].to] = add(f[u][e[k].to], f[u][v]);
        }
    }   
}
 
signed main() {
    #ifndef ONLINE_JUDGE
        freopen("test.in", "r", stdin);
    #endif  
    read(n, m, mod);
    for (int i = 1; i <= m; ++ i) {
        int u, v; read(u, v);   
        in[v] ++; out[u] ++;
        link(u, v);
    }
    for (int i = 1; i <= n; ++ i) {
        if (!in[i]) s[++ tots] = i;
        if (!out[i]) t[++ tott] = i;
    }
 
    for (int i = 1; i <= tots; ++ i) q.push(s[i]);
    while (q.size()) {
        int u = q.front(); q.pop();
        id[++ tot] = u;
        for (int i = head[u]; i; i = e[i].nxt) {
            int v = e[i].to;
            if (! -- in[v]) q.push(v);
        }
    }
    bfs();
    for (int i = 1; i <= tots; ++ i) {
        for (int j = 1; j <= tots; ++ j) {
            w[i][j] = f[s[i]][t[j]];
        }
    }
    write(det(tots)), pc('\n');
}