bzoj 1415 [Noi2005]聪聪和可可——其实无环的图上概率

题目:https://www.lydsy.com/JudgeOnline/problem.php?id=1415

乍一看和“游走”一样。于是高斯消元。n^2状态,复杂度n^6……

看看TJ,发现因为聪聪不是随便走的,所以聪聪一直逼近可可。故其实无环。可以记搜。

(1A还是不错的)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=1005;
int n,m,l0,l1,nxt[N][N],dfn[N],du[N];
double dp[N][N];
bool vis[N],vs[N][N];
priority_queue<int,vector<int>,greater<int> >ed[N];
void add(int x,int y)
{
    ed[x].push(y);ed[y].push(x);
    du[x]++;du[y]++;
}
void bfs(int cr)
{
    priority_queue<int,vector<int>,greater<int> >tp;
    memset(vis,0,sizeof vis);memset(dfn,0,sizeof dfn);
    queue<int> q;q.push(cr);vis[cr]=1;nxt[cr][cr]=cr;
    while(q.size())
    {
        int k=q.front();q.pop();
        tp=ed[k];
        while(tp.size())
        {
            int v=tp.top();tp.pop();
            if(vis[v])continue;
            dfn[v]=dfn[k]+1;vis[v]=1;q.push(v);
            if(dfn[v]>2)nxt[v][cr]=nxt[k][cr];
            else nxt[v][cr]=v;
        }
    }
}
double dfs(int x,int y)//coco->x ,cncn->y
{
//    printf("x=%d y=%d\n",x,y);
    if(vs[x][y])return dp[x][y];vs[x][y]=1;
    if(nxt[x][y]==x){/*printf("rt x=%d y=%d\n",x,y);*/return dp[x][y]=1;}
    double ret=(dfs(x,nxt[x][y])+(nxt[x][y]!=x))/(du[x]+1);
    priority_queue<int,vector<int>,greater<int> >tp=ed[x];//每层定义
//    printf("siz[%d]=%d\n",x,tp.size());
    while(tp.size())
    {
        int v=tp.top();tp.pop();
//        printf("v=%d nxt[%d][%d]=%d\n",v,x,y,nxt[x][y]);
        ret+=(dfs(v,nxt[x][y])+(nxt[x][y]!=v))/(du[x]+1);
    }
//    printf("ret=%.3lf\n",ret);
    return dp[x][y]=ret;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&l0,&l1);int x,y;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);add(x,y);
    }
    for(int i=1;i<=n;i++)bfs(i);
    printf("%.3lf",dfs(l1,l0));
    return 0;
}

版本1

看看TJ,发现判断得那么纠结是因为x==y时正常应返回0。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=1005;
int n,m,l0,l1,nxt[N][N],dfn[N],du[N];
double dp[N][N];
bool vis[N],vs[N][N];
priority_queue<int,vector<int>,greater<int> >ed[N];
void add(int x,int y)
{
    ed[x].push(y);ed[y].push(x);
    du[x]++;du[y]++;
}
void bfs(int cr)
{
    priority_queue<int,vector<int>,greater<int> >tp;
    memset(vis,0,sizeof vis);memset(dfn,0,sizeof dfn);
    queue<int> q;q.push(cr);vis[cr]=1;nxt[cr][cr]=cr;
    while(q.size())
    {
        int k=q.front();q.pop();
        tp=ed[k];
        while(tp.size())
        {
            int v=tp.top();tp.pop();
            if(vis[v])continue;
            dfn[v]=dfn[k]+1;vis[v]=1;q.push(v);
            if(dfn[v]>2)nxt[v][cr]=nxt[k][cr];
            else nxt[v][cr]=v;
        }
    }
}
double dfs(int x,int y)//coco->x ,cncn->y
{
    if(vs[x][y])return dp[x][y];vs[x][y]=1;
    if(x==y)return dp[x][y]=0;//
    if(nxt[x][y]==x)return dp[x][y]=1;
    double ret=dfs(x,nxt[x][y])/(du[x]+1)+1;
    priority_queue<int,vector<int>,greater<int> >tp=ed[x];//每层定义
    while(tp.size())
    {
        int v=tp.top();tp.pop();
        ret+=dfs(v,nxt[x][y])/(du[x]+1);
    }
    return dp[x][y]=ret;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&l0,&l1);int x,y;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);add(x,y);
    }
    for(int i=1;i<=n;i++)bfs(i);
    printf("%.3lf",dfs(l1,l0));
    return 0;
}

版本2

但是自己代码巨慢……想来是用了优先队列的缘故(为了标号字典序)。尝试改一改。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=1005;
int n,m,l0,l1,nxt[N][N],dfn[N],du[N],head[N],xnt;
double dp[N][N];
bool vis[N],vs[N][N];
priority_queue<int,vector<int>,greater<int> >ed[N];
struct Edge{
    int next,to;
    Edge(int n=0,int t=0):next(n),to(t) {}
}edge[N<<1];
void add(int x,int y)
{
    edge[++xnt]=Edge(head[x],y);head[x]=xnt;
    edge[++xnt]=Edge(head[y],x);head[y]=xnt;
    ed[x].push(y);ed[y].push(x);
    du[x]++;du[y]++;
}
void bfs(int cr)
{
    priority_queue<int,vector<int>,greater<int> >tp;
    memset(vis,0,sizeof vis);memset(dfn,0,sizeof dfn);
    queue<int> q;q.push(cr);vis[cr]=1;nxt[cr][cr]=cr;
    while(q.size())
    {
        int k=q.front();q.pop();
        tp=ed[k];
        while(tp.size())
        {
            int v=tp.top();tp.pop();
            if(vis[v])continue;
            dfn[v]=dfn[k]+1;vis[v]=1;q.push(v);
            if(dfn[v]>2)nxt[v][cr]=nxt[k][cr];
            else nxt[v][cr]=v;
        }
    }
}
double dfs(int x,int y)//coco->x ,cncn->y
{
    if(vs[x][y])return dp[x][y];vs[x][y]=1;
    if(x==y)return dp[x][y]=0;//
    if(nxt[x][y]==x)return dp[x][y]=1;
    double ret=dfs(x,nxt[x][y])/(du[x]+1)+1;
    for(int i=head[x];i;i=edge[i].next)
        ret+=dfs(edge[i].to,nxt[x][y])/(du[x]+1);
    return dp[x][y]=ret;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&l0,&l1);int x,y;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);add(x,y);
    }
    for(int i=1;i<=n;i++)bfs(i);
    printf("%.3lf",dfs(l1,l0));
    return 0;
}

结果只是快了28ms。

别人用一些方法保证字典序。

这个人bfs+两步保证dis最小的前提下调整标号至最小。https://blog.csdn.net/clove_unique/article/details/62237321

这个人spfa的同时判断标号。(但只能记录一步的pre)https://blog.csdn.net/PoPoQQQ/article/details/40896403(bfs因为是bfs所以不能边求dis边调整标号)

可是我都没记录dis。用的dfn。所以懒得改了……比较欣赏第一个人的写法。

原文地址:https://www.cnblogs.com/Narh/p/9206642.html

时间: 2024-10-10 08:19:54

bzoj 1415 [Noi2005]聪聪和可可——其实无环的图上概率的相关文章

BZOJ 1415 NOI2005 聪聪和可可 期望DP+记忆化搜索 BZOJ200题达成&amp;&amp;NOI2005全AC达成

题目大意:给定一个无向图,聪聪在起点,可可在终点,每个时刻聪聪会沿最短路走向可可两步(如果有多条最短路走编号最小的点),然后可可会等概率向周围走或不动,求平均多少个时刻后聪聪和可可相遇 今天早上起床发现194了然后就各种刷--当我发现199的时候我决定把第200题交给05年NOI仅剩的一道题--结果尼玛调了能有一个小时--我居然没看到编号最小这个限制0.0 首先我们知道,由于聪聪走两步而可可走一步,所以聪聪一定能在有限的时刻追上可可,而且两人的距离随着时间进行单调递减 于是我们记忆化搜索 首先用

BZOJ 1415: [Noi2005]聪聪和可可 [DP 概率]

传送门 题意:小兔子乖乖~~~ 题意·真:无向图吗,聪抓可,每个时间聪先走可后走,聪一次可以走两步,朝着里可最近且点编号最小的方向:可一次只一步,等概率走向相邻的点或不走 求聪抓住可的期望时间 和游走很像,只不过这道题限制了一个人走的方向,两人间的距离具有了阶段性!可以直接$DP$ 求期望一般倒推 $f[i][j]$表示聪在$i$可在$j$抓住的期望时间 $bfs$预处理$g[i][j]$表示聪在$i$可在$j$下一步聪走到哪里 这样聪的行动就知道了,转移枚举可的行动就行啦 边界:$f[i][i

bzoj 1415: [Noi2005]聪聪和可可

直接上记忆化搜索 #include<queue> #include<cstdio> #include<algorithm> using namespace std; int read_p,read_ca; inline int read(){ read_p=0;read_ca=getchar(); while(read_ca<'0'||read_ca>'9') read_ca=getchar(); while(read_ca>='0'&&

bzoj 1415: [Noi2005]聪聪和可可【期望dp+bfs】

因为边权为1所以a直接bfs瞎搞就行--我一开始竟然写了个spfa #include<iostream> #include<cstdio> #include<queue> #include<cstring> using namespace std; const int N=1005,inf=1e9; int n,m,st,ed,h[N],cnt,a[N][N],b[N][N],dis[N][N],d[N]; double f[N][N]; bool v[N]

【BZOJ】【1415】【NOI2005】聪聪和可可

数学期望+记忆化搜索 论文:<浅析竞赛中一类数学期望问题的解决方法>——汤可因  中的第一题…… Orz 黄学长 我实在是太弱,这么简单都yy不出来…… 宽搜预处理有点spfa的感觉= =凡是更新了的,都要重新入队更新一遍…… dp的记忆化搜索过程好厉害…… 期望这里一直很虚啊,赶紧再多做点题熟悉熟悉…… 1 /************************************************************** 2 Problem: 1415 3 User: Tunix

【BZOJ 1415】 1415: [Noi2005]聪聪和可可 (bfs+记忆化搜索+期望)

1415: [Noi2005]聪聪和可可 Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 1640  Solved: 962 Description Input 数据的第1行为两个整数N和E,以空格分隔,分别表示森林中的景点数和连接相邻景点的路的条数. 第2行包含两个整数C和M,以空格分隔,分别表示初始时聪聪和可可所在的景点的编号. 接下来E行,每行两个整数,第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路. 所有的路都是无向的,即

BZOJ 1415 【NOI2005】 聪聪和可可

题目链接:聪聪和可可 一道水题--开始还看错题了,以为边带权--强行\( O(n^3)\)预处理-- 首先,我们显然可以预处理出一个数组\( p[u][v] \)表示可可在点\(u\),聪聪在点\(v\)的时候聪聪下一步会往哪里走.然后--一个记忆化搜索就轻易地解决掉了-- 至于转移方程吗,我觉得也没有必要写了--你要是实在不知道就看一看代码吧-- 下面贴代码: #include<iostream> #include<cstdio> #include<cstring>

【BZOJ】1415 [Noi2005]聪聪和可可

[算法]期望DP,记忆化搜索 题目 [题解]浅析竞赛中一类数学期望问题的解决方法 例题 首先因为聪聪走的步数等于大于可可走的步数,所以不可能出现循环(高斯消元),使DP成为可能. 因为是图显然采用记忆化搜索. p[x][y]表示x走向y第一步编号,f[x][y]表示答案(把答案数组设置出来考虑倒序递推就顺理成章了). e[x][y]表示x的相邻点(代码实现用邻接表),t[x]表示x的度(邻点个数). if(x==y)f[x][y]=0; if(p[p[x][y]][y]==y||p[x][y]=

bzoj1415【NOI2005】聪聪和可可

1415: [Noi2005]聪聪和可可 Time Limit: 10 Sec  Memory Limit: 162 MB Submit: 1271  Solved: 748 [Submit][Status][Discuss] Description Input 数据的第1行为两个整数N和E,以空格分隔,分别表示森林中的景点数和连接相邻景点的路的条数. 第2行包含两个整数C和M,以空格分隔,分别表示初始时聪聪和可可所在的景点的编号. 接下来E行,每行两个整数,第i+2行的两个整数Ai和Bi表示景