CS Academy Round 52 An Unstable Graph

题意

给出一个n个点m条边的有向图，第i条边在每一时刻出现的概率均为p[i]。一开始玩家在节点1，每秒必须要沿一条出现的边走过去。若没有出边则退出。假设玩家绝顶聪明，问能够到达节点n的概率是多少。
n<=50，无重边自环。

分析

n<=8
设f[i]表示从节点i开始最优策略下到n的概率是多少。
先来考虑最优策略是什么。
假设已经得到了最后f[]的相对顺序。
那么对于一个节点x其最优策略就是，取出所有他可以到达的点a[]，将a[]按照f[a[i]]的大小从大到小排序，从前往后依次看这条边是否存在，如果存在就走到a[i]否则继续往后，如果所有边都不在，那么就挂掉了。
接下来证明这个结论的正确性，考虑两个相邻的a[i]和a[i+1]（其中f[a[i]]>f[a[i+1]]），考虑如果将a[i]和a[i+1]交换的贡献，由于前面的系数不变，已经对大于i+1的位置贡献不变，所以只用考虑a[i]和a[i+1]的贡献（接下来设x=a[i],y=a[i+1]）。
如果是按照原来的顺序，那么贡献是f[x]*p[x]+(1-p[x])*p[y]*f[y]
如果是交换之后的顺序，那么贡献是f[y]*p[y]+(1-p[y])*p[x]*f[x]
前式减后式得到：p[x]p[y](f[x]-f[y])
由于f[x]>f[y]，那么这个式子是大于0的，故对于任意的i，f[a[i]]>=f[a[i+1]]
那么n<=8就只需要枚举f[]的相对顺序，然后就可以列出若干个方程，高斯消元即可，当枚举的相对顺序满足计算出的f[]的相对顺序的时候就说明我们找到了解。
n<=20
我也不知道怎么做（Jason说过，“中国人这么多，总有一个会做的”）
(o゜▽゜)o☆[BINGO!]
n<=50
在n<=8的做法上进行拓展，前者的瓶颈在于要枚举f[]最终的相对顺序，那么可以初始假定一个相对顺序，然后根据这个计算得出的f[]会有一个新的相对顺序，用新的相对顺序继续迭代下去，直到找到符合的即可。
这个的时间复杂度可以这样理解，每个f[]的计算出来的值会向他真实 的值的排名靠近，所以总共有O(n^2)次变动，所以总的时间复杂度是O(n^5)

代码

#include <bits/stdc++.h>

#define f first
#define s second
#define mp std::make_pair

int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
    while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}

const int N = 55;
const double eps = 1e-8;

struct Edge
{
    int to,next;
    int p;
}e[N * N];

int cnt;
int next[N];

void add(int x,int y,int z)
{
    e[++cnt].to = y, e[cnt].next = next[x], next[x] = cnt, e[cnt].p = z;
}

double a[N][N];

std::pair<int, int> t[N];

int n,m;

void gauss()
{
    for (int i = 1; i <= n; i++)
    {
        int l = i;
        for (int j = i + 1; j <= n; j++)
        {
            if (fabs(a[j][i]) > fabs(a[l][i]))
                l = j;
        }
        if (l != i)
            for (int j = 1; j <= n + 1; j++)
                std::swap(a[i][j], a[l][j]);
        double w = a[i][i];
        for (int j = 1; j <= n + 1; j++)
        {
            a[i][j] /= w;
        }
        for (int j = 1; j <= n + 1; j++)
        {
            if (i != j && fabs(a[j][i]) > eps)
            {
                w = a[j][i];
                for (int k = 1; k <= n + 1; k++)
                    a[j][k] -= a[i][k] * w;
            }
        }
    }
}

double f[N];

bool cmp(std::pair<int , int> x, std::pair<int, int> y)
{
    return f[x.f] > f[y.f];
}

void check()
{
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n + 1; j++)
            a[i][j] = 0;
    a[n][n] = a[n][n + 1] = 1;
    for (int i = 1; i < n; i++)
    {
        int tot = 0;
        a[i][i] = -1;
        for (int j = next[i]; j; j = e[j].next)
        {
            t[++tot] = mp(e[j].to, e[j].p);
        }
        std::sort(t + 1, t + tot + 1, cmp);
        double p = 1;
        for (int j = 1; j <= tot; j++)
            a[i][t[j].f] = (double)p * t[j].s / 100, p *= (double)(100 - t[j].s) / 100;
    }
    gauss();
    for (int i = 1; i <= n; i++)
        f[i] = a[i][n + 1];
}

int main()
{
    n = read(), m = read();
    for (int i = 1; i <= m; i++)
    {
        int x = read(), y = read(), z = read();
        add(x,y,z);
    }
    for (int i = 1; i <= n; i++)
        f[i] = i;
    for (int i = 1; i <= n * n; i++)
        check();
    printf("%.10lf", f[1]);
}