[HNOI 2013]游走

Description

题库链接

一个无向连通图，顶点从 \(1\) 编号到 \(N\) ，边从 \(1\) 编号到 \(M\) 。 小Z在该图上进行随机游走，初始时小Z在 \(1\) 号顶点，每一步小Z以相等的概率随机选择当前顶点的某条边，沿着这条边走到下一个顶点，获得等于这条边的编号的分数。当小Z到达 \(N\) 号顶点时游走结束，总分为所有获得的分数之和。 现在，请你对这 \(M\) 条边进行编号，使得小Z获得的总分的期望值最小。

\(1\leq N\leq 500\)

Solution

首先一个显然的贪心就是，假设我们知道了每一条边走过的期望，显然我们把边按期望从大到小排序再从小到大编号即可。

如何求边的期望。对于这种无向图求期望的问题。容易想到用高消来解点被经过的期望。容易发现对于一条边 \(e(u,v)\) ，它经过的期望容易以 \(u,v\) 的期望求得 \[E(e)=\frac{E(u)}{degree(u)}+\frac{E(v)}{degree(v)}\]

比较直观的解释就是由于是无向图，这条边被经过只有可能 \(u\rightarrow v\) 和 \(v\rightarrow u\) 。对于点 \(u\) ，它有 \(\frac{1}{degree(u)}\) 的概率来选这条边走，对于 \(v\) 同理。

现在考虑如何求点期望，类似地我们令 \(f_u\) 为 \(u\) 被经过的期望 \[f_u=\sum_{(u,v)\in \mathbb{G}} \frac{f_v}{degree(v)}\]

特别地 \(f_n=0\) 因为 \(n\) 号点不会被经过，因为到了 \(n\) 号点就不会继续走了。另外对于 \(1\) 号点 \[f_1-1=\sum_{(1,v)\in \mathbb{G}} \frac{f_v}{degree(v)}\]

因为一开始就在 \(1\) 号点，所以期望 \(+1\) 。

Code

//It is made by Awson on 2018.3.2
#include <bits/stdc++.h>
#define LL long long
#define dob complex<double>
#define Abs(a) ((a) < 0 ? (-(a)) : (a))
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
#define Swap(a, b) ((a) ^= (b), (b) ^= (a), (a) ^= (b))
#define writeln(x) (write(x), putchar('\n'))
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int N = 500;
void read(int &x) {
    char ch; bool flag = 0;
    for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1); ch = getchar());
    for (x = 0; isdigit(ch); x = (x<<1)+(x<<3)+ch-48, ch = getchar());
    x *= 1-2*flag;
}
void print(int x) {if (x > 9) print(x/10); putchar(x%10+48); }
void write(int x) {if (x < 0) putchar('-'); print(Abs(x)); }

int n, m, path[N+5], top, degree[N+5];
struct ss {
    int u, v; double e;
    bool operator < (const ss &b) const {return e > b.e; }
}e[N*N+5];
struct tt {int to, next; }edge[N*N+5];
double A[N+5][N+5];

void add(int u, int v) {edge[++top].to = v, edge[top].next = path[u], path[u] = top, ++degree[v]; }
void Gauss() {
    for (int line = 1; line <= n; line++) {
        int maxline = line;
        for (int j = line+1; j <= n; j++) if (fabs(A[j][line]) > fabs(A[maxline][line])) maxline = j;
        if (line != maxline) swap(A[line], A[maxline]);
        for (int j = line+1; j <= n; j++) {
            double div = A[j][line]/A[line][line];
            for (int k = line; k <= n+1; k++) A[j][k] -= A[line][k]*div;
        }
    }
    for (int i = n; i >= 1; i--) {
        for (int j = i+1; j <= n; j++) A[i][n+1] -= A[i][j]*A[j][n+1];
        A[i][n+1] /= A[i][i];
    }
}
void work() {
    read(n), read(m);
    for (int i = 1; i <= m; i++) read(e[i].u), read(e[i].v), add(e[i].u, e[i].v), add(e[i].v, e[i].u);
    for (int i = 1; i < n; i++) {
        A[i][i] = 1.; for (int j = path[i]; j; j = edge[j].next) A[i][edge[j].to] = -1./degree[edge[j].to];
    }
    A[1][n+1] = 1., A[n][n] = 1; Gauss();
    for (int i = 1; i <= m; i++) e[i].e = A[e[i].u][n+1]/degree[e[i].u]+A[e[i].v][n+1]/degree[e[i].v];
    double ans = 0; sort(e+1, e+m+1);
    for (int i = 1; i <= m; i++) ans += e[i].e*i;
    printf("%.3lf\n", ans);
}
int main() {
    work(); return 0;
}