[HNOI2013]游走

大意：给定简单无向图，从1号点出发，等概率走路，到n号点停止。

求每条边经过的次数期望。

解：

边的期望可以由点的概率很容易推出来。

点的概率是互相关联的，比如1号一开始概率为1，但是可能出去之后就回来结果概率比1还大了，然后又会影响到别的点....

有一种高斯消元的感觉，再一看数据范围：刚好！那么就是你了！

每个点的概率应该是从所有边过来的概率之和。

注意：常数项全0是解不了的。但是我们的一号点有个常数项为1

为什么有个负号呢？

因为把a[1][1]*f[1]移过去之后刚好是f[1] - 1，这就没问题了。

其余的贡献加起来再加原来就有的1就是f[1]

n号点不能为其他任一点的概率做贡献。

然后我们就可以列方程，解方程，然后搞出答案了。

精度开到1e12，否则可能WA

#include <cstdio>
#include <algorithm>
#include <cmath>
const int N = 510;
const double eps = 1e-12;

struct Edge {
    int v, nex;
}edge[N * N * 2]; int top = 1;

int e[N], out[N], n, m, t;
double a[N][N], f[N], b[N * N];

inline void add(int x, int y) {
    top++;
    edge[top].v = y;
    edge[top].nex = e[x];
    e[x] = top;
    out[x]++;
    return;
}

inline void Gauss() {
    for(int i = 1; i < n; i++) {
        for(int j = i; j <= n; j++) {
            if(fabs(a[j][i]) > eps) {
                std::swap(a[j], a[i]);
                break;
            }
        }
        for(int j = i + 1; j <= n; j++) {
            if(fabs(a[j][i]) < eps) {
                continue;
            }
            double p = a[j][i] / a[i][i];
            for(int k = i; k <= n + 1; k++) {
                a[j][k] -= a[i][k] * p;
            }
        }
    }

    for(int i = n; i > 1; i--) {
        for(int j = i - 1; j >= 1; j--) {
            if(fabs(a[j][i]) < eps) {
                continue;
            }
            double p = a[j][i] / a[i][i];
            for(int k = i; k <= n + 1; k++) {
                a[j][k] -= a[i][k] * p;
            }
        }
    }

    for(int i = 1; i <= n; i++) {
        f[i] = a[i][n + 1] / a[i][i];
    }

    return;
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1, x, y; i <= m; i++) {
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }
    out[n] = 0;

    for(int x = 1; x < n; x++) {
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            a[y][x] = 1.0 / out[x];
        }
        a[x][x] = -1.0;
    }
    a[1][n + 1] = -1.0;
    a[n][n] = -1.0;

    Gauss();

    for(int i = 2; i <= top; i += 2) {
        ++t;
        if(edge[i].v < n) {
            b[t] = f[edge[i].v] / out[edge[i].v];
        }
        if(edge[i ^ 1].v < n) {
            b[t] += f[edge[i ^ 1].v] / out[edge[i ^ 1].v];
        }
    }

    std::sort(b + 1, b + t + 1);

    double ans = 0;
    for(int i = t; i >= 1; i--) {
        ans += b[i] * (t + 1 - i);
    }

    printf("%.3lf", ans);

    return 0;
}