BZOJ 3143: [Hnoi2013]游走

3143: [Hnoi2013]游走

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 2429  Solved: 1049
[Submit][Status][Discuss]

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之间存在一条边。 输入保证30%的数据满足N≤10，100%的数据满足2≤N≤500且是一个无向简单连通图。

Output

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

Sample Input

3 3
2 3
1 2
1 3

Sample Output

3.333

HINT

边(1,2)编号为1，边(1,3)编号2，边(2,3)编号为3。

Source

非官方数据

[Submit][Status][Discuss]

先求出每个点的期望经过次数,则每条边的经过次数为x点出发，走这条边的期望+y点出发，走这条边的概率。

#include <bits/stdc++.h>

inline char nextChar(void)
{
    static const int siz = 1024;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
    
    return *hd++;
}

inline int nextInt(void)
{
    register int ret = 0;
    register int neg = false;
    register int bit = nextChar();
    
    for (; bit < 48; bit = nextChar())
        if (bit == '-')neg ^= true;
        
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - 48;
        
    return neg ? -ret : ret;
}

int n, m;

struct edge
{
    int x, y;
    double k;
}e[500005];

double f[505][505];

int g[505][505], c[505];

inline bool cmp(const edge &a, const edge &b)
{
    return a.k > b.k;
}

signed main(void)
{
    n = nextInt();
    m = nextInt();
    
    for (int i = 1; i <= m; ++i)
    {
        ++c[e[i].x = nextInt()];
        ++c[e[i].y = nextInt()];
        
        ++g[e[i].x][e[i].y];
        ++g[e[i].y][e[i].x];
    }
    
    for (int i = 1; i < n; ++i)
        for (int j = 1; j < n; ++j)
        {
            if (i == j)
                f[i][j] = -1.0;
            else
                f[i][j] = 1.0 * g[i][j] / c[j];
        }
    
    f[1][n] = -1.0;
    
    {
        for (int i = 1; i < n; ++i)
        {
            int r = i;
            
            for (int j = i + 1; j < n; ++j)
                if (fabs(f[j][i]) > fabs(f[r][i]))
                    r = j;
                    
            for (int j = 1; j <= n; ++j)
                std::swap(f[i][j], f[r][j]);
            
            for (int j = i + 1; j < n; ++j)
            {
                long double t = f[j][i] / f[i][i];
                
                for (int k = i; k <= n; ++k)
                    f[j][k] -= t * f[i][k];
            }
        }
        
        for (int i = n - 1; i >= 0; --i)
        {
            for (int j = i + 1; j < n; ++j)
                f[i][n] -= f[j][n] * f[i][j];
            
            f[i][n] /= f[i][i];
        }
    }
    
    for (int i = 1; i <= m; ++i)
        e[i].k = f[e[i].x][n] / c[e[i].x] + f[e[i].y][n] / c[e[i].y];
        
    std::sort(e + 1, e + m + 1, cmp);
    
    double ans = 0.0;
    
    for (int i = 1; i <= m; ++i)
        ans += e[i].k * i;
        
    printf("%.3lf
", ans);
}

@Author: YouSiki