高斯消元裸题（期望）——【HNOI2013】游走

Description

一个无向连通图，顶点从1 编号到N，边从1 编号到M。

小Z 在该图上进行随机游走，初始时小Z 在1 号顶点，每一步小Z 以相等的概率随机选择当前顶点的某条边，沿着这条边走到下一个顶点，获得等于这条边的编号的分数。当小Z到达N 号顶点时游走结束，总分为所有获得的分数之和。

现在，请你对这M 条边进行编号，使得小Z 获得的总分的期望值最小。

Input

输入第一行是正整数N和M，分别表示该图的顶点数和边数，接下来M行每行是整数u，v(1≤u,v≤N)，表示顶点u与顶点v之间存在一条边。

Output

输出仅包含一个实数，表示最小的期望值，保留3 位小数。

Sample Input3 3

2 3
1 2
1 3

Sample Output

3.333

Data Constraint

30%的数据满足N≤10；
100%的数据满足2≤N≤500且是一个无向简单连通图。

Hint

样例解释：边(1,2)编号为1，边(1,3)编号2，边(2,3)编号为3。

---

解析：

我们很容易想到先求出每条边期望的经过次数，然后排个序就行了。

边期望的经过次数如果直接列方程，由于边数比较大，会T的。

注意到点事很少的，可以先求出点的期望经过次数：

每个点由它相邻的不是终点的点过来，起点的期望要加1，因为一开始就经过了它， 然后高斯消元一波~

点的期望到边的期望的转换：
S_x-y = S_x / du_x +S_y / du_y
当然x,y若是终点就不算。

Code:

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

const int Maxn = 505;

int n, m, x, y, du[Maxn];
int tot, final[Maxn];
struct edge {
    int to, next;
}e[Maxn * Maxn * 2];
struct edge2 {
    int x, y; double c;
}b[Maxn * Maxn * 2];
double a[Maxn][Maxn], s[Maxn];

bool rank_b(edge2 a, edge2 b) {
    return a.c > b.c;
}

void link(int x, int y) {
    e[++ tot].next = final[x], e[tot].to = y, final[x] = tot;   
}

void Init() {
    scanf("%d %d", &n, &m);
    fo(i, 1, m)
        scanf("%d %d", &x, &y), link(x, y), link(y, x), du[x] ++, du[y] ++, b[i].x = x, b[i].y = y;
}

void Build() {
    fo(i, 1, n) {
        a[i][i] = -1;
        for(int k = final[i]; k; k = e[k].next)
            if(e[k].to != n)
                a[i][e[k].to] += (double) 1 / du[e[k].to];
    }
    a[1][0] = 1;
}

void Solve_equation(int n, int m) {
    fo(i, 1, n) {
        int mi = i;
        fo(j, i + 1, m) if(abs(a[j][i]) > abs(a[mi][i]))
            mi = j;
        fo(j, 0, n) swap(a[i][j], a[mi][j]);
        fo(j, 1, m) if(i != j){
            double c = a[j][i] / a[i][i];
            fo(k, 0, n) a[j][k] -= a[i][k] * c;
        }
    }
    fo(i, 1, n) 
        if(a[i][i] != 0)
            s[i] = -a[i][0] / a[i][i];
}

void End() {
    fo(i, 1, m) {
        if(b[i].x != n) b[i].c += s[b[i].x] / du[b[i].x];
        if(b[i].y != n) b[i].c += s[b[i].y] / du[b[i].y];
    }
    sort(b + 1, b + m + 1, rank_b);
    double ans = 0;
    fo(i, 1, m) ans += b[i].c * i;
    printf("%.3lf", ans);
}

int main() {
    Init();
    Build();
    Solve_equation(n, n);
    End();
}