【BZOJ1415】】聪聪和可可记忆化搜索的概率dp

最新推荐文章于 2021-09-18 17:33:27 发布

转载最新推荐文章于 2021-09-18 17:33:27 发布 · 229 阅读

概率dp 专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种使用记忆化搜索算法解决图中两点间路径概率问题的方法。通过记录已计算过的路径概率避免重复计算，提高效率。该算法首先进行广度优先搜索(BFS)预处理所有节点间的最短距离，然后利用递归方式计算从起点到终点经过特定节点的概率。

别的代码我是看不懂了，，渣渣只能看得只能看得懂这份用记忆化搜索的代码，，

感觉真的挺好看懂的。 但是想就有点难想了，但是应该比那种单纯的方程好记些，             但是毕竟我以后还是很难想到啊。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
using namespace std;
const int maxn = 1e3 + 5, oo = 0x3f3f3f3f;
struct Edge{
    int to, next;
}edge[maxn << 1];
int head[maxn];
int dist[maxn][maxn];
int n, e, s, t;
double dp[maxn][maxn];
bool vis[maxn][maxn];
int tot = 0;
void addedge(int u, int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void bfs(int s)
{
    queue<int>q;q.push(s);
    dist[s][s] = 0;
    while(!q.empty()){
        int t = q.front();q.pop();
        for(int i = head[t]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(dist[v][s] > dist[t][s] + 1){
                dist[v][s] = dist[t][s] + 1;
                q.push(v);
            }
        }
    }
}
double dfs(int a, int b)
{
    if(a == b) return dp[a][b] = 0;
    if(vis[a][b]) return dp[a][b];
    vis[a][b] = true;
    int mins = oo;
    int nxt = b;
    for(int i = head[b]; i != -1; i = edge[i].next){
        int v = edge[i].to;
        if(dist[v][a] == mins && v < nxt) nxt = v; 
        else if(dist[v][a] < mins){
            mins = dist[v][a];
            nxt = v;
        }
    }
    int nxtt = nxt;
    if(nxt == a) return dp[a][b] = 1.0; 
    for(int i = head[nxt]; i != -1; i = edge[i].next){
        int v = edge[i].to;
        if(dist[v][a] == mins && v < nxtt) nxtt = v; 
        else if(dist[v][a] < mins){
            mins = dist[v][a];
            nxtt = v;
        }
    }
    if(nxtt == a) return dp[a][b] = 1.0;
    dp[a][b] = dfs(a, nxtt);
    int cnt = 1;
    for(int i = head[a]; i != -1; i = edge[i].next){
        int v = edge[i].to;
        cnt++;
        dp[a][b] +=  dfs(v, nxtt);
    }
    dp[a][b] /= cnt * 1.0;
    dp[a][b]++;
    return dp[a][b];
}
int main (void)
{
    scanf("%d%d", &n, &e);
    scanf("%d%d", &s, &t);
    memset(dist, 0x3f, sizeof(dist));
    memset(head, -1, sizeof(head));
    int x, y;
    for(int i = 0; i < e; i++){
        scanf("%d%d", &x, &y);
        addedge(x, y);
        addedge(y, x);
    }
    for(int i = 1; i <= n; i++) bfs(i);//这个地方用  了n次bfs来求任意两点之间的最短路
    printf("%.3f\n", dfs(t, s));
    return 0;
}