[HNOI2015]落忆枫音

嘟嘟嘟


这题大意就是有一个DAG，然后添加了一条边，求上有多少种生成树。


这题想了半天，最后还是写了暴力。暴力就是(O(2 ^ mn))的那种，还出锅了几次：刚开始我不想dfs判断选出的边是否构成树，于是yy了一下，以为只要边数为(n - 1)，除了根节点每个点的入度为1且都被访问过就行了。却忘了有环的情况：只要是一堆不连通的环就全符合我上述的判断条件了……最后还是写了每次建图跑dfs……


正解好像不是很难……但我就是没往那个方向想。
首先考虑一个DAG的情况，那答案就是(prod _ {i = 2} ^ {n} du[i])。因为每一个点只可能有一条入度，那么每一个点有(du[i])种选法，答案就是那个了。
这一步我也想过，但就是没想出来。这东西看上去感觉挺好理解的，但是自己去想不知为啥就是想不出来……


接下来有环了，那么我们想办法把有环的那些方案数减掉即可。
一种比较暴力的想法是这样的：找出(t)到(s)的所有路径（不就相当于找环了嘛），记为(path)，则要减去的就是(sum _ {i otin path} prod du[i])。
暴力显然不行，于是dp。
令(dp[i])表示从(t)到(i)的所有路径的(prod du[j])之和。则答案减去(dp[s])就好了。
怎么转移呢，因为是DAG，自然能想到拓扑排序，初始化(dp[t] = frac{prod du[i]}{du[t]})转移就是(dp[i] = sum_{j -> i} frac{dp[j]}{du[i]})。因为(i)和(j)相比路径上多了一个节点(i)，所以要把(i)的贡献除掉。
我刚开始担心这样开始从(t)转移拓扑排序进行不下去（样例就过不去），但后来发现从节点1转移就好了，因为(dp[1])是0，所以转移到(t)前相当于把DAG上环外的边给去掉了。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int n, m, s, t, du[maxn];
struct Edge
{
  int nxt, to;
}e[maxm];
int head[maxn], ecnt = -1;
In void addEdge(int x, int y)
{
  e[++ecnt] = (Edge){head[x], y};
  head[x] = ecnt;
}

In ll inc(ll a, ll b) {return a + b >= mod ? a + b - mod : a + b;}

In ll quickpow(ll a, ll b)
{
  ll ret = 1;
  for(; b; b >>= 1, a = a * a % mod)
    if(b & 1) ret = ret * a % mod;
  return ret;
}

ll ind[maxn], dp[maxn];
In void topo_sort()
{
  queue<int> q; q.push(1);
  while(!q.empty())
    {
      int now = q.front(); q.pop();
      for(int i = head[now], v; ~i; i = e[i].nxt)
	{
	  v = e[i].to;
	  dp[v] = inc(dp[v], dp[now] * ind[v] % mod);
	  if(!--du[v]) q.push(v);
	}
    }
}

int main()
{
  Mem(head, -1);
  n = read(), m = read(), s = read(), t = read();
  for(int i = 1; i <= m; ++i)
    {
      int x = read(), y = read();
      addEdge(x, y); ++du[y];
    }
  ll ans = du[t] + 1;
  for(int i = 2; i <= n; ++i) if(i ^ t) ans = ans * du[i] % mod;
  if(s == 1 || t == 1) {write(ans), enter; return 0;}
  ind[t] = quickpow(du[t] + 1, mod - 2);
  for(int i = 2; i <= n; ++i) if(i ^ t) ind[i] = quickpow(du[i], mod - 2);
  dp[t] = ans * ind[t] % mod;
  topo_sort();
  write((ans - dp[s] + mod) % mod), enter;
  return 0;
}