2018清华集训（YL联考）9.9 T1 Dream

最新推荐文章于 2023-09-21 07:30:00 发布

原创最新推荐文章于 2023-09-21 07:30:00 发布 · 336 阅读

0 ·

CC 4.0 BY-SA版权

高斯消元专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种高效算法，用于解决在一个带权有向图中，从每个顶点出发到特定终点的期望边遍历次数问题。该算法通过引入额外的未知数并结合高斯消元法，在较优的时间复杂度内求解。适用于图论和概率计算相关问题。

题目大意：

核心问题是个一个n个点、m条边的有向图。

要求求以每一个点 $x|x∈V$ 作为起点，每个边有一个往它这边游走的权重，游走到终点n停下，求每个边期望经过的次数。

1<=n<=400

题解：

假设起点是确定的，一个经典的做法是设每个点经过的次数为一个未知数。

那么对每一个点可以列出一条方程，就是由相邻的点转移过来，终点没有出边，然后起点的那条方程的常数项是1，高斯消元一下，那么每条边x->y的次数=x的次数*走这条边的概率。

但是我们需要枚举起点，加上高斯消元，这个做法的复杂度是 $O(n^4)$ 的，难以接受。

注意到起点与其它点不同之处只是它的那条方程的常数项是1。

于是可以想到设每个点是不是起点也为未知数，这样就有2n个元，n条方程，我们消元只去消一开始那n个元。

然后最后每个点经过的次数就可以表示为每个点是不是起点的未知数乘上系数，这样系数就是答案。

复杂度 $O(2*n^3+n*m+q~log~q)$

有点卡常

Code:

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
#define fo(i, x, y) for(int i = x; i <= y; i ++)
#define abs(a) ((a) > 0 ? (a) : -(a))
#define gc getchar
#define pc putchar
using namespace std;

const int N = 405;

const int mo = 1e9 + 7;

int n, m, q, x, y;
int w[N][N], s[N][N], c[N][N], p[N][N], bz[N][N];
ll sw[N], d[N][N], a[N][N * 2];

struct node {
    int x, y;
} e[100005];

ll ksm(ll x, ll y) {
    ll s = 1;
    for(; y; y /= 2, x = x * x % mo)
        if(y & 1) s = s * x % mo;
    return s;
}

void read(int &x) {
    char c = ' '; x = 0;
    for(; c < '0' || c > '9'; c = gc());
    for(; c >= '0' && c <= '9'; c = gc()) x = x * 10 + c - '0';
}

void write(int x) { 
    if(x == 0) {pc('0'); return;}
    int d[10]; d[0] = 0;
    for(; x; x /= 10) d[++ d[0]] = x % 10;
    while(d[0]) pc(d[d[0] --] + '0');
}

int cmp1(node a, node b) { return p[a.x][a.y] < p[b.x][b.y];}

struct Ask {
    int y, x, i;
} b[2000005];

int cmp2(Ask a, Ask b) {return a.y < b.y;}

int ans[2000005];

ll k1[N], b1[N];

void ins(int i) {
    int x = e[i].x, y = e[i].y;
    if(x == n) return;
    fo(st, 1, n) {
        ll z = d[st][x] * w[x][y] % mo;
        b1[st] += ((ll) s[x][y] * p[x][y] % mo + c[x][y]) * z % mo;
        k1[st] -= z * s[x][y] % mo;
    }
}

void del(int i) {
    int x = e[i].x, y = e[i].y;
    if(x == n) return;
    fo(st, 1, n) {
        ll z = d[st][x] * w[x][y] % mo;
        b1[st] -= (ll) s[x][y] * p[x][y] % mo * z * 2 % mo;
        k1[st] += z * s[x][y] * 2 % mo;
    }
}

int main() {
    freopen("a.in", "r", stdin);
    freopen("a.out", "w", stdout);
    scanf("%d %d %d", &n, &m, &q);
    fo(i, 1, m) {
        read(x); read(y);
        bz[x][y] = 1;
        e[i].x = x; e[i].y = y;
        read(w[x][y]); read(s[x][y]); read(c[x][y]); read(p[x][y]);
        sw[x] = (sw[x] + w[x][y]) % mo;
    }
    fo(i, 1, n) sw[i] = ksm(sw[i], mo - 2);
    fo(i, 1, n) {
        a[i][i] = mo - 1;
        fo(j, 1, n - 1) if(bz[j][i])
            a[i][j] = sw[j] * w[j][i] % mo;
    }
    fo(i, 1, n) a[i][i + n] = 1;
    fo(i, 1, n) {
        int c; fo(j, i, n) if(a[j][i]) c = j;
        fo(j, 1, 2 * n) swap(a[i][j], a[c][j]);
        fo(j, 1, n) if(i != j && a[j][i]) {
            ll z = ksm(a[j][i], mo - 2) * a[i][i] % mo;
            fo(k, 1, 2 * n) a[j][k] = (a[j][k] * z - a[i][k]) % mo;
        }
    }
    fo(st, 1, n) fo(i, 1, n) d[st][i] = (mo - a[i][st + n]) * ksm(mo + a[i][i], mo - 2) % mo * sw[i] % mo;
    sort(e + 1, e + m + 1, cmp1);
    fo(i, 1, q) read(b[i].y), read(b[i].x), b[i].i = i;
    sort(b + 1, b + q + 1, cmp2);
    fo(i, 1, m) ins(i); int l = 0;
    fo(i, 1, q) {
        while(l < m && p[e[l + 1].x][e[l + 1].y] <= b[i].y) del(++ l);
        k1[b[i].x] = (k1[b[i].x] % mo + mo) % mo;
        b1[b[i].x] = (b1[b[i].x] % mo + mo) % mo;
        ans[b[i].i] = (k1[b[i].x] * b[i].y + b1[b[i].x]) % mo;
    }
    fo(i, 1, q) write(ans[i]), pc('\n');
}