HNOI2015 实验比较

终于开始来补题了，两年前我就是个沙茶。

题目大意

给定$n$个点和$m,mle n - 1$个小于关系或者等于关系，问有多少种合法的序列满足这$m$个关系。

简要题解

第一眼就知道要先拓扑排序判断是否存在合法序列，然后很重要的一点是$mle n - 1$，所以得到的是森林而不是一般意义上的DAG，添加一个根把森林并成一棵树，考虑在树上DP就好了。

设以$u$为根的子树并成长度为$j$的序列（有等于关系的看做序列中的一个点）的方案数为$f[u][j]$，则$f[u][j]$的计算可以由儿子的答案合并起来得到。其实要解决的问题就是，给两个长度分别为$p,k$的序列，将其并成长度为$j$的序列的方案数（$jle p+k$），可以这样想，先在$j$个位置中选$k$个用来放第二个序列中的元素，然后在这$k$个位置中选$p+k-j$个用来放第一个序列中的元素，这样两个序列中每个元素都有唯一确定的位置了，在DP的时候用一个新数组$g$来临时存合并的结果，$$f[u][j] = g[p] imes f[v][k] imes {jchoose k} imes {k choose p + k - j},vin son_u$$

手贱+脑残把$g$开成static，看到$g$的值还以为出了灵异事件QAQ

#include <bits/stdc++.h>
using namespace std;
namespace my_header {
#define pb push_back
#define mp make_pair
#define pir pair<int, int>
#define vec vector<int>
#define pc putchar
#define clr(t) memset(t, 0, sizeof t)
#define pse(t, v) memset(t, v, sizeof t)
#define bl puts("")
#define wn(x) wr(x), bl
#define ws(x) wr(x), pc(' ')
    const int INF = 0x3f3f3f3f;
    typedef long long LL;
    typedef double DB;
    inline char gchar() {
        char ret = getchar();
        for(; (ret == '
' || ret == '
' || ret == ' ') && ret != EOF; ret = getchar());
        return ret; }
    template<class T> inline void fr(T &ret, char c = ' ', int flg = 1) {
        for(c = getchar(); (c < '0' || '9' < c) && c != '-'; c = getchar());
        if (c == '-') { flg = -1; c = getchar(); }
        for(ret = 0; '0' <= c && c <= '9'; c = getchar())
            ret = ret * 10 + c - '0';
        ret = ret * flg; }
    inline int fr() { int t; fr(t); return t; }
    template<class T> inline void fr(T&a, T&b) { fr(a), fr(b); }
    template<class T> inline void fr(T&a, T&b, T&c) { fr(a), fr(b), fr(c); }
    template<class T> inline char wr(T a, int b = 10, bool p = 1) {
        return a < 0 ? pc('-'), wr(-a, b, 0) : (a == 0 ? (p ? pc('0') : p) : 
            (wr(a/b, b, 0), pc('0' + a % b)));
    }
    template<class T> inline void wt(T a) { wn(a); }
    template<class T> inline void wt(T a, T b) { ws(a), wn(b); }
    template<class T> inline void wt(T a, T b, T c) { ws(a), ws(b), wn(c); }
    template<class T> inline void wt(T a, T b, T c, T d) { ws(a), ws(b), ws(c), wn(d); }
    template<class T> inline T gcd(T a, T b) {
        return b == 0 ? a : gcd(b, a % b); }
    template<class T> inline T fpw(T b, T i, T _m, T r = 1) {
        for(; i; i >>= 1, b = b * b % _m)
            if(i & 1) r = r * b % _m;
        return r; }
};
using namespace my_header;

const int mod = 1e9 + 7;
const int maxN = 100 + 10;
int n, m;
int ind[maxN], fa[maxN], c[maxN][maxN];
vector<int> go[maxN];
int f[maxN][maxN];

int findFa(int u) {
    return fa[u] == u ? u : fa[u] = findFa(fa[u]);
}

void dp(int u) {
    int g[maxN];
    memset(g, 0, sizeof g);
    g[0] = 1;
    for (int i = 0; i < (int)go[u].size(); ++i) {
        int v = go[u][i];
        dp(v);
        for (int j = 0; j <= n; ++j)
            for (int k = 0; k <= n; ++k)
                if (g[k] != 0)
                    for (int p = n; j <= p + k; --p) {
                        (f[u][j] += 1LL * g[k] * f[v][p] % mod * c[j][k] % mod * c[k][k + p - j] % mod) %= mod;
                    }
        memcpy(g, f[u], sizeof f[u]);
        memset(f[u], 0, sizeof f[u]);
    }
    memcpy(f[u] + 1, g, sizeof (int) * (maxN - 1));
}

struct Data {
    int u, v, op;
    Data() {
        fr(u);
        op = gchar() == '=';
        fr(v);
        if (op == 1)
            fa[findFa(u)] = findFa(v);
    }
};

int main() {
#ifdef lol
    freopen("4013.in", "r", stdin);
    freopen("4013.out", "w", stdout);
#endif

    fr(n, m);

    c[0][0] = 1;
    c[1][1] = c[1][0] = 1;
    for (int i = 2; i <= n; ++i) {
        c[i][0] = 1;
        for (int j = 1; j <= i; ++j)
            c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
    }
    for (int i = 1; i <= n; ++i)
        fa[i] = i;
    Data *d = new Data[m];
    for (int i = 0; i < m; ++i) {
        int u = findFa(d[i].u);
        int v = findFa(d[i].v);
        if (u != v) {
            go[u].pb(v);
            ++ind[v];
        }
    }
    
    queue<int> q;
    for (int i = 1; i <= n; ++i) {
        if (findFa(i) != i)
            continue;
        if (ind[i] == 0) {
            q.push(i);
            go[0].pb(i);
        }
    }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < (int)go[u].size(); ++i) {
            int v = go[u][i];
            --ind[v];
            if (ind[v] == 0)
                q.push(v);
        }
    }
    for (int i = 1; i <= n; ++i)
        if (ind[i] != 0) {
            wt(0);
            return 0;
        }

    dp(0);

    int ans = 0;
    for (int i = 1; i <= n + 1; ++i)
        (ans += f[0][i]) %= mod;
    wt(ans);

    return 0;
}