[HNOI2015]落忆枫音

· 题意

　　对于一个DAG，在图中任意添加一条边，求可形成的树形图个数。

· 题解

　　首先对于一个DAG，它们可形成的树形图的个数显然是各点入度相乘。

　　那么现在加入了一条边，可能会构成环，于是可以用总方案数减去不合法方案数（即构成环的方案数）。

　　本题解题的关键在于如何构造不合法方案，那么y -> x的所有路径都是不合法的，因为这样一定会构成一个环，那么此时其它的点无论怎么选都是不合法的，应当删去。

　　于是有

　　　　　　　　　　　　　　　　　　　　

 

　　这个时候还要想到DP，不然可能会仅局限于环内那几个点，这样子就不好处理了，此时

　　　　　　　　　　　　　　　　　　　　

　　那么可以得到转移方程

　　　　　　　　　　　　　　　　　　　　

　　表示从可到达$i$的$j$转移过来，此时i已经不再是不属于集合$S$的点，所以应当除以其$degree$。

　　初值

　　　　　　　　　　　　　　　　　　　　

　　于是拓扑一下就好了。

　　（以上方程图片均摘自PoPoQQQ）

· 代码

　　

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

#define MOD 1000000007

using namespace std;

typedef long long LL;

const int MAXN = 1e05 + 10;
const int MAXM = 2e05 + 10;

struct LinkedForwardStar {
    int to;
    
    int next;
} ;

LinkedForwardStar Link[MAXM];
int Head[MAXN]= {0};
int size = 0;

void Insert (int u, int v) {
    Link[++ size].to = v;
    Link[size].next = Head[u];
    
    Head[u] = size;
}

LL f[MAXN];

int N, M;

int start, end;

int temp[MAXN]= {0}, Indeg[MAXN]= {0};

LL ans = 1;

LL inv[MAXM];

void Preparation () {
    inv[1] = 1;
    for (int i = 2; i <= M + 1; i ++)
        inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
}

queue<int> Que;

void Toposort () {
    for (int i = 1; i <= N; i ++)
        if(! temp[i])
            Que.push(i);
    
    while (! Que.empty()) {
        int u = Que.front();
        Que.pop();
        
        f[u] = f[u] * inv[Indeg[u]] % MOD;
        for (int i = Head[u]; i; i = Link[i].next) {
            int v = Link[i].to;
            
            f[v] = (f[v] + f[u]) % MOD;
            if (temp[v] > 0) {
                temp[v] --;
                if (! temp[v])
                    Que.push(v);
            }
        }
    }
}

int main () {
    scanf ("%d%d%d%d", & N, & M, & start, & end);
    
    for (int i = 1; i <= M; i ++) {
        int u, v;
        scanf ("%d%d", & u, & v);
        
        Insert (u, v);
        temp[v] ++, Indeg[v] ++;
    }
    Indeg[end] ++;
    
    for (int i = 2; i <= N; i ++)
        ans = ans * Indeg[i] % MOD;
    
    if (end == 1) {
        printf ("%lld\n", ans);
        
        return 0;
    }
    
    Preparation ();
    
    f[end] = ans;
    Toposort ();
    
    ans = (ans - f[start] + MOD) % MOD;
    
    printf ("%lld\n", ans);
    
    return 0;
}

/*
4 4 4 3
1 2
1 3
2 4
3 2
*/