【BZOJ】1415: [Noi2005]聪聪和可可【期望】【最短路】【记忆化搜索】

1415: [Noi2005]聪聪和可可

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 2335  Solved: 1373
[Submit][Status][Discuss]

Description

Input

数据的第1行为两个整数N和E，以空格分隔，分别表示森林中的景点数和连接相邻景点的路的条数。 第2行包含两个整数C和M，以空格分隔，分别表示初始时聪聪和可可所在的景点的编号。 接下来E行，每行两个整数，第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路。 所有的路都是无向的，即：如果能从A走到B，就可以从B走到A。 输入保证任何两个景点之间不会有多于一条路直接相连，且聪聪和可可之间必有路直接或间接的相连。

Output

输出1个实数，四舍五入保留三位小数，表示平均多少个时间单位后聪聪会把可可吃掉。

Sample Input

【输入样例1】
4 3
1 4
1 2
2 3
3 4
【输入样例2】
9 9
9 3
1 2
2 3
3 4
4 5
3 6
4 6
4 7
7 8
8 9

Sample Output

【输出样例1】
1.500
【输出样例2】
2.167

HINT

【样例说明1】
开始时，聪聪和可可分别在景点1和景点4。
第一个时刻，聪聪先走，她向更靠近可可(景点4)的景点走动，走到景点2，然后走到景点3；假定忽略走路所花时间。
可可后走，有两种可能：
第一种是走到景点3，这样聪聪和可可到达同一个景点，可可被吃掉，步数为1，概率为 。
第二种是停在景点4，不被吃掉。概率为 。
到第二个时刻，聪聪向更靠近可可(景点4)的景点走动，只需要走一步即和可可在同一景点。因此这种情况下聪聪会在两步吃掉可可。
所以平均的步数是1* +2* =1.5步。

对于所有的数据，1≤N,E≤1000。
对于50%的数据，1≤N≤50。

---

Solution

又把题看错叻....原来$N$范围是1000！而且可以跳两步！

但是思维总是没错的，首先预处理最短路，处理出聪聪可可位置固定时聪聪下一步会走哪（只走一步），用$Spfa$，固定可可的位置跑单源最短路，每次更新即可。

然后用记忆化搜索计算期望，除了最后一步判断一下是否走一步就可以到达，其他尽量走两步。

感觉对期望有了更深层的理解吧（？）

Code

#include<bits/stdc++.h>
using namespace std;

struct Node {
    int u, v, nex;
    Node(int u = , int v = , int nex = ) :
        u(u), v(v), nex(nex) { }
} Edge[];

int h[], stot;
void add(int u, int v) {
    Edge[++stot] = Node(u, v, h[u]);
    h[u] = stot;
}

int n, m, vis[], dis[], nex[][];
void spfa(int t) {
    queue < int > q;
    memset(vis, , sizeof(vis));
    memset(dis, 0x3f3f3f3f, sizeof(dis));
    q.push(t); dis[t] = ; vis[t] = ;
    while(!q.empty()) {
        int u = q.front(); q.pop(); vis[u] = ;
        for(int i = h[u]; i; i = Edge[i].nex) {
            int v = Edge[i].v;
            if(dis[v] > dis[u] + ) {
                dis[v] = dis[u] + ;
                if(!vis[v]) {
                    vis[v] = ;
                    q.push(v);
                }
            }
        }
    }
    for(int u = ; u <= n; u ++) {
        if(u != t) {
            int res = 0x3f3f3f3f;
            for(int i = h[u]; i; i = Edge[i].nex) {
                int v = Edge[i].v;
                if(dis[v] < res)    res = dis[v], nex[u][t] = v;
                else if(dis[v] == res && v < nex[u][t])    nex[u][t] = v;
            }
        }
    }
}

int d[], s, t;
double dp[][];
double dfs(int s1, int s2) {
    if(dp[s1][s2] != -)        return dp[s1][s2];
    if(s1 == s2)        return dp[s1][s2] = ;
    if(nex[s1][s2] == s2 || nex[nex[s1][s2]][s2] == s2)    return dp[s1][s2] = ;
    double res = ;
    for(int i = h[s2]; i; i = Edge[i].nex) {
        int v = Edge[i].v;
        res += ( + dfs(nex[nex[s1][s2]][s2], v)) / (d[s2] + 1.0) * 1.0;
    }
    res += ( + dfs(nex[nex[s1][s2]][s2], s2)) / (d[s2] + 1.0) * 1.0;
    return dp[s1][s2] = res;
}

int main() {
    ios :: sync_with_stdio();
    cin >> n >> m;
    cin >> s >> t;
    for(int i = ; i <= n; i ++)    for(int j = ; j <= n; j ++)    dp[i][j] = -;
    for(int i = ; i <= m; i ++) {
        int u, v;
        cin >> u >> v;
        add(u, v); add(v, u);
        d[u] ++; d[v] ++;
    }
    for(int i = ; i <= n; i ++)
        spfa(i);
    double ans = dfs(s, t);
    printf("%.3lf", ans);
    return ;
}