概率DP问题整理（一）

最新推荐文章于 2023-10-03 21:24:42 发布
最新推荐文章于 2023-10-03 21:24:42 发布
阅读量2.4k 收藏 2
点赞数 2
分类专栏： Algorithm_动规
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niuox/article/details/9960913
版权

第一题：Hdu 3853 

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3853

简单概率DP题。注意思维逆过来考虑。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;

#define Maxn 1005
struct Probab
{
   double same,right,down;
}probab[Maxn][Maxn];

double dp[Maxn][Maxn];
int main()
{
   #ifndef ONLINE_JUDGE
      freopen("in.txt","r",stdin);
   #endif
   int r,c;
   while(scanf(" %d %d",&r,&c)!=EOF)
   {
      for(int i=1;i<=r;i++)
      {
         for(int j=1;j<=c;j++)
         {
            scanf(" %lf %lf %lf",&probab[i][j].same,&probab[i][j].right,&probab[i][j].down);         
         }
      }
      memset(dp,0,sizeof(dp));
      for(int i=r;i>=1;i--)
      {
         for(int j=c;j>=1;j--)
         {
            if(j==c && i==r) continue;
            if(fabs(probab[i][j].same-1.0)<1e-8) dp[i][j] += 2;
            else dp[i][j] = (dp[i][j+1]*probab[i][j].right + dp[i+1][j]*probab[i][j].down + 2)/(1-probab[i][j].same);
         }
      }
      printf("%.3lf\n",dp[1][1]);
   }
   return 0;
}
第二题：Hdu 4336

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4336

状态压缩+概率DP。

状态转移方程：

dp[s] = ps*dp[s]+sigma(  p[i]*dp[ s ^ (1<<i) ] ) +1, (0<=i<n，假设下标从1到n)
ps = 1 - sigma( p[i] )

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;

#define Maxn 21

double probab[Maxn];

double dp[1<<Maxn];
int main()
{
   #ifndef ONLINE_JUDGE
      freopen("in.txt","r",stdin);
   #endif
   int n;
   while(scanf(" %d",&n)!=EOF)
   {
      for(int i=1;i<=n;i++)
      {
         scanf(" %lf",&probab[i]);
      }
      memset(dp,0,sizeof(dp));
      dp[0] = 0;
      for(int i=1;i<(1<<n);i++)
      {
         double temp = 0;
         double total = 0;
         for(int j=1;j<=n;j++)
         {
            if(i & 1<<(j-1))
            {
               temp += probab[j] * dp[i^(1<<(j-1))];
               total += probab[j];
            }
         }
         temp ++;
         dp[i] = temp/total;
      }
      printf("%lf\n",dp[(1<<n)-1]);
   }
   return 0;
}

第三题：Poj 3744 Scout YYF I

题目链接：http://poj.org/problem?id=3744

思路摘自其他人:


题意：在一条不满地雷的路上，你现在的起点在1处。在N个点处布有地雷，1<=N<=10。地雷点的坐标范围：[1,100000000].
每次前进p的概率前进一步，1-p的概率前进1-p步。问顺利通过这条路的概率。就是不要走到有地雷的地方。
 
设dp[i]表示到达i点的概率，则 初始值 dp[1]=1.
很容易想到转移方程： dp[i]=p*dp[i-1]+(1-p)*dp[i-2];
但是由于坐标的范围很大，直接这样求是不行的，而且当中的某些点还存在地雷。
 
N个有地雷的点的坐标为 x[1],x[2],x[3]```````x[N].
我们把道路分成N段：
1~x[1];
x[1]+1~x[2];
x[2]+1~x[3];
`
`
`
x[N-1]+1~x[N].
 
这样每一段只有一个地雷。我们只要求得通过每一段的概率。乘法原理相乘就是答案。
对于每一段，通过该段的概率等于1-踩到该段终点的地雷的概率。
 
就比如第一段 1~x[1].  通过该段其实就相当于是到达x[1]+1点。那么p[x[1]+1]=1-p[x[1]].
但是这个前提是p[1]=1,即起点的概率等于1.对于后面的段我们也是一样的假设，这样就乘起来就是答案了。
 
对于每一段的概率的求法可以通过矩阵乘法快速求出来。

另外注意：关于double，scanf要用%lf,printf只能用%f才对。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;

#define Maxn 12
#define MATRIX_SIZE 2
int place[Maxn];

struct Matrix
{
   double elem[MATRIX_SIZE][MATRIX_SIZE];
   int size;
   Matrix(){memset(elem,0,sizeof(elem));}
   void setSize(int _size)
   {
      size = _size;
   }
   Matrix operator = (const Matrix & other)
   {
      setSize(other.size);
      for(int i=0;i<size;i++)
      {
         for(int j= 0;j<size;j++)
         {
            elem[i][j] = other.elem[i][j];
         }
      }
      return *this;
   }
   Matrix operator * (const Matrix & other)
   {
      Matrix temp;
      temp.setSize(size);
      for(int i=0;i<size;i++)
      {
         for(int j=0;j<size;j++)
         {
            for(int k=0;k<size;k++)
            {
               temp.elem[i][j] += elem[i][k] * other.elem[k][j];
            }
         }
      }
      return temp;
   }
   void Power(int exp)
   {
      Matrix E;
      E.setSize(size);
      for(int i=0;i<size;i++) E.elem[i][i] = 1;
      while(exp)
      {
         if(exp & 1) E = E * (*this);
         *this = (*this) * (*this);
         exp >>= 1;
      }
      *this = E;
   }
};
Matrix m;
void init(double p)
{
   m.setSize(2);
   m.elem[0][0] = 0.0;
   m.elem[0][1] = 1.0;
   m.elem[1][0] = 1-p;
   m.elem[1][1] = p;
}

int main()
{
   #ifndef ONLINE_JUDGE
      freopen("in.txt","r",stdin);
   #endif
   int n;
   double p;
   while(scanf(" %d %lf",&n,&p)!=EOF)
   {
      place[0] = 0;
      for(int i=1;i<=n;i++)
      {
         scanf(" %d",&place[i]);
      }
      sort(place+1,place+1+n);
      double ans = 1;
      for(int i=1;i<=n;i++)
      {
         init(p);
         if(place[i] == place[i-1]) continue;
         int t = place[i] - place[i-1];
         m.Power(t-1);
         ans *= (1 - m.elem[1][1]);
      }
      printf("%.7f\n",ans );
   }
   return 0;
}

第四题：Uva 11722 Joining with Friend

题目连接：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2769

连续概率DP：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;

const double eps = 1e-8;  
  
struct Point  
{  
    int x;  
    int y;  
    Point() {}  
    Point(int _x,int _y):x(_x),y(_y) {}  
    friend Point operator + (Point a,Point b)  
    {  
        return Point(a.x+b.x , a.y+b.y);  
    }  
    friend Point operator - (Point a,Point b)  
    {  
        return Point(a.x-b.x , a.y-b.y);  
    }  
}; 

int dcmp(double x)  //三态函数  
{  
    if(fabs(x)<eps)//在一定的精度范围内可认为是0  
        return 0;  
    return x>0?1:-1;  
}  
double det(Point a,Point b)  // 叉积，重载叉积函数  
{  
    return a.x*b.y-a.y*b.x;  
}  
double det(Point a,Point b,Point o)  // 叉积  
{  
    return det(a-o,b-o);
}  
double det(Point a,Point b,Point c,Point d)  // 叉积  
{  
    return det(b-a,d-c);  
}
//A,B,C,D是矩形的四个点
Point A,B,C,D;

//p1,p2是y=x-w线段上的任意两个点
//p3,p4是y=x+w线段上的任意两个点
Point p1,p2,p3,p4;

int t1, t2, s1, s2, w;

double init()
{
   A.x = t1;
   A.y = s1;
   B.x = t2;
   B.y = s1;
   C.x = t2;
   C.y = s2;
   D.x = t1;
   D.y = s2;
   p1.x = 1;
   p1.y = 1-w;
   p2.x = 2;
   p2.y = 2-w;
   p3.x = 1;
   p3.y = 1+w;
   p4.x = 2;
   p4.y = 2+w;
   //>0点在线上方,<0点在线下方
   //处理下方的线段
   int bP = dcmp(det(p1,p2,B));
   int aP = dcmp(det(p1,p2,A));
   int cP = dcmp(det(p1,p2,C));
   int dP = dcmp(det(p1,p2,D));
   double area1 = 0;
   if(bP>=0) area1 = 0;
   else if(bP<0 && aP>=0 && cP>=0)
   {
      area1 = fabs((s1+w-t2)*(t2-w-s1)) * 0.5;
   }
   else if(bP<0 && aP<=0 && cP<=0 && dP>=0)
   {
      area1 = fabs((t2-t1)*(s2-s1)) - fabs((t1-w-s2)*(s2+w-t1)) * 0.5;
   }
   else if(bP<0 && cP<0 && aP>0 && dP>0)
   {
      area1 = (fabs(s1+w-t2) + fabs(s2+w-t2)) *fabs(s2-s1) * 0.5;
   }
   else if(bP<0 && aP<0 && cP>0 && dP>0)
   {
      area1 = (fabs(t1-w-s1) + fabs(t2-w-s1))*fabs(t2-t1)*0.5;
   }
   else
   {
      area1 = fabs((t2-t1)*(s2-s1));
   }
   //处理上方的线段
   bP = dcmp(det(p3,p4,B));
   aP = dcmp(det(p3,p4,A));
   cP = dcmp(det(p3,p4,C));
   dP = dcmp(det(p3,p4,D));
   double area2 = 0;
   if(bP>=0) area2 = 0;
   else if(bP<0 && aP>=0 && cP>=0)
   {
      area2 = fabs((s1-w-t2)*(t2+w-s1)) * 0.5;
   }
   else if(bP<0 && aP<=0 && cP<=0 && dP>=0)
   {
      area2 = fabs((t2-t1)*(s2-s1)) - fabs((t1+w-s2)*(s2-w-t1)) * 0.5;
   }
   else if(bP<0 && cP<0 && aP>0 && dP>0)
   {
      area2 = (fabs(s1-w-t2) + fabs(s2-w-t2)) *fabs(s2-s1) * 0.5;
   }
   else if(bP<0 && aP<0 && cP>0 && dP>0)
   {
      area2 = (fabs(t1+w-s1) + fabs(t2+w-s1))*fabs(t2-t1)*0.5;
   }
   else
   {
      area2 = fabs((t2-t1)*(s2-s1));
   }
   return (area2 - area1)/(t2-t1)/(s2-s1);
}
int main()
{
   #ifndef ONLINE_JUDGE
      freopen("in.txt","r",stdin);
   #endif
   int t;
   int cas = 0;
   scanf(" %d",&t);
   while(t--)
   {
      cas++;
      scanf(" %d %d %d %d %d",&t1,&t2,&s1,&s2,&w);
      double ans = init();
      printf("Case #%d: %.7f\n",cas,ans);
   }
   return 0;
}


第五题：Uva 11762 - Race to 1

题目连接：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2862

质数分解转换。

设：sum[x]表示1到x中有多少个素数，p[x]表示x的素数因子个数，不难发现递推关系如下：
dp(x) = 1 + dp(x) * (sum[x] - p[x])/sum[x] + sigma(dp(x/yi)) /sum[x];其中yi是x的素因子。

两边同时乘sum[x].我们得到：

p[x] * dp(x) = sum[x] + sigma(dp(x/yi))

dp(x)即可求出。

注意用筛法求质数同时预处理出sum[x] 和p[x].

求筛法的时候要注意范围和系数。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;

#define Maxn 1000002
int n;
int notPrime[Maxn+5];
vector <int> primeFactor[Maxn+5];
int primeSum[Maxn+5];
double dp[Maxn+5];

void init()
{
   memset(notPrime,0,sizeof(notPrime));
   notPrime[1] = 1;
   for(int i=2;i<=Maxn;i++)
   {
      if(!notPrime[i])
      {
         for(int j=i*2;j<=Maxn;j+=i)
         {
            notPrime[j] = 1;
            primeFactor[j].push_back(i);
         }
         primeFactor[i].push_back(i);
      }
   }
   memset(primeSum,0,sizeof(primeSum));
   for(int i=2;i<=Maxn;i++)
   {
      primeSum[i] += primeSum[i-1] + (notPrime[i] == 0);
   }
   memset(dp,0,sizeof(dp));
}

double solve(int n)
{
   if(n == 1) return 0;
   if(dp[n]!=0) return dp[n];
   double ans = 0;
   for(int i=2;i<=n;i++)
   {
      ans = 0;
      for(int j=0;j<primeFactor[i].size();j++)
      {
         ans += dp[i/primeFactor[i][j]];
      }
      ans = ans + primeSum[i];
      ans = ans / primeFactor[i].size();
      dp[i] = ans;
   }
   return dp[n];
}
int main()
{
   #ifndef ONLINE_JUDGE
      freopen("in.txt","r",stdin);
   #endif
   int t;
   int cas = 0;
   init();
   scanf(" %d",&t);
   while(t--)
   {
      cas++;
      scanf(" %d",&n);
      double ans = solve(n);
      printf("Case %d: %.7f\n",cas,ans);
   }
   return 0;
}


niuox
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DP--划分问题（掷骰子）
qq1169091731的博客
07-01 636
一次掷n个骰子，每个骰子有p个面，问有多少种情况？ 要考虑重复情况，例：2个骰子，3个面，1,1,2和2,1,1是一种情况 对于这种情形 我们一般进行排序处理 把所有情况所对应的数从小到大排序a1&lt;=a2&lt;=a3&lt;=...&lt;=an。比如1,1,2和2,1,1就相当于1,1,2了再比如 3,1,2 2,3,1 都相当于1,2,3这样每种情况都与一个序列一一对应不是吗？ ...
【动态规划】数学期望/概率DP/期望DP详解
繁凡さん的博客
02-12 9228
期望DP概述规律全概率公式例题1.UVA11021 Tribles麻球繁衍2.算概率（简单，数论） 概述 一般来说，概率DP找到正确的状态定义后，转移是比较容易想到的。但状态一定是“可数”的，把有范围的整数作为数组下标。事实上，将问题直接作为状态是最好的。如问“n人做X事的期望次数”，则设计状态为f[i]表示i个人做完事的期望。转移一般是递推，即从上一个状态转移得（填表）或转移向下一个状态（刷表）...
【DP】【分队问题】
Star_Weeper的博客
11-09 473
题目描述 给定n 个选手，将他们分成若干只队伍。其中第i 个选手要求自己所属的队伍的人数大等于a[i]人。 在满足所有选手的要求的前提下，最大化队伍的总数。 注：每个选手属于且仅属于一支队伍。 输入格式 第一行一个整数n，表示人数。 以下n 行，每行一个整数表示a[i]。 输出格式 输出队伍总数的最大值。数据保证有解。 样例输入 5 2 1 2 2 3
算法题目4——DP
weixin_45901806的博客
03-08 391
题目一： 问题描述 　　共有n种图案的印章，每种图案的出现概率相同。小A买了m张印章，求小A集齐n种印章的概率。 输入格式 　　一行两个正整数n和m 输出格式 　　一个实数P表示答案，保留4位小数。 样例输入 2 3 样例输出 0.7500 拿到这题第一个思路是排列组合求概率， 由题目可知当n=1时概率p为1.n>m p=0.当n>m时，概率p为0 动态规划p[i][j]代表买i枚里面有j种的概率 拿到每一种的概率p=1/n 1、if i<j dp[i][j.
区间dp 经典问题 石子归并
b03188460的博客
08-13 164
石子归并有三个经典问题：https://blog.csdn.net/acdreamers/article/details/18039073//刚找到的大佬blog1.洛谷 P1880[NOI1995]石子合并 (环形版)题目描述在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。试设计出1...
dp方法论——由矩阵相乘问题学习dp解题思路
an38703413的博客
09-12 675
前篇戳：dp入门——由分杆问题认识动态规划 导语 刷过一些算法题，就会十分珍惜“方法论”这种东西。Leetcode上只有题目、讨论和答案，没有方法论。往往答案看起来十分切中要害，但是从看题目到得到思路的那一段，就是绕不过去。楼主有段时间曾把这个过程归结于智商和灵感的结合，直到有天为了搞懂Leetcode上一位老兄的题型总结，花两天时间学习了回溯法，突然有种惊为天人的感觉——原来真正掌...
概率DP
09-04
2014清华梦之队NOIP考前提高班概率DP课件
DP日常维护常见问题
07-31
DP日常维护常见问题
状压dp经典问题及代码
04-28
状态压缩经典问题及代码，TSP问题，状压dp..........................................
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
北航OJ_DP问题整理
12-15
针对刚学习动态规划算法 贪心算法的题目 北航编程啦的若干经典例题
基础dp学习
ComingLiu的博客
01-25 324
基础动态规划引入硬币找零问题01背包问题 引入 有这样一个问题：楼梯有N阶，可以一步上1阶，也可以上2阶，问N阶楼梯有多少种走法 题目链接 洛谷P1225 如果用搜索的方法，每次有两种方法，那么增长速度是指数级的，时间复杂度很大 那么可以这样考虑，如何才能走到第N阶楼梯呢？，只能从第N-1阶上1阶或者从第N-2阶上2阶得到，也就是说dp[N]=dp[N-1]+dp[N-2]，这其实是一种动态规划（Dynamic Programming，DP）的思想，把一个大问题分解成许多小问题，通过求解小问题得到大问题的
DP的一些杂题(思维型)
Guess_Ha的博客
11-03 1663
本帖收集收集一些考思维的DP问题啦。 1.P2876 [USACO07JAN]解决问题Problem Solving 题目链接：https://www.luogu.org/problemnew/show/2876 题目大意：有一些任务需要用几个月按顺序完成，每个任务有两个代价ai，bi，其中ai会在完成当月付出，bi会在完成后一个月付出。每个月的可用费用是固定的M(当月的不能在下个月用)
DP问题简介
weixin_42178241的博客
11-08 1351
DP问题简介 DP问题主要是解决全局最优解，与贪心不同，贪心只针对于局部最优解（后面解释dp性质时会知道原因）。 DP问题性质 重叠子问题(分治)：把一个大问题分成若干个处理方式相同的子问题继续解答 无后效性：每一个子问题对他的来源父问题没有影响(不用贪心的原因) 最优子结构：保证求得答案为最优解 DP问题解答步骤 在DP解答过程中，每次在求得一种状态所对应答案时，都需要调用之前已求解的状态所对应的答案 状态定义:状态格式及其所代表的意思 状态初始化:一些特殊状态的赋值(不用算就知道) 状态转移方程:
几个常见的DP问题及解法
热门推荐
yi_Afly的专栏
08-01 1万+
前言记录一些最近遇到的DP问题，并给出解法。只会记录我知道的最优解法（一般是时间最优），并贴出源码。有OJ的还会贴上地址。1. 求字符串的最长不重复子串的长度举例： abcabcbb，返回abc； bbbbb，返回b； pwwkew，返回wke。注意pwke是子序列，不是子串。 问题分析： 记字符串存放在字符数组cs中，遍历cs的下标为i。分析可知，想求截止到i的最长不重复子串的长度，只要从i向左
python问题描述_动态规划(DP)的整理-Python描述
weixin_39666496的博客
11-28 230
今天整理了一下关于动态规划的内容，道理都知道，但是python来描述的方面参考较少，整理如下，希望对你有所帮助，实验代码均经过测试。请先好好阅读如下内容--什么是动态规划？摘录于《算法图解》这里写图片描述以上的都建议自己手推一下，然后知道怎么回事，核心的部分是142页核心公式，待会代码会重现这个过程，推荐没有算法基础的小伙伴看这本书《算法图解》很有意思的书，讲的很清晰，入门足够更深入的请阅读pyt...
关于概率dp的个人理解与总结
Enmity_Dark
08-07 4156
首先，概率dp主要解决的是关于概率问题和期望问题的求解。
概率DP算法总结
TheSunspot的博客
06-22 2181
概率DP 顾名思义，概率DP就是动态规划求概率的问题。一般来说，我们将dp数组存放的数据定义为到达此状态的概率，那么我们初值设置就是所有初始状态概率为1，最终答案就是终末状态dp值了。 我们在进行状态转移时，是从初始状态向终末状态顺推，转移方程中大致思路是按照当前状态去往不同状态的位置概率转移更新DP，且大部分是加法。 期望DP 用于求解期望的DP。这类问题一般将dp数组存放的数据定义为到达终态还需要的期望值。那么初值设置就是终末状态期望为0，答案就是初始状态的dp值了。 我们在进行状态转移时，一般是从终末
ACM学习笔记 - 概率DP
最新发布
qq_74825516的博客
10-03 877
说来搞笑，重学一遍才发现概率DP有够简单，自己以前居然连反推都不会写，唉。概率 = 结果 * 概率概率DP其实无非三点：一是线性拆开，这个在状压不行的情况下优先考虑二是正反推，有多简单？只需要把枚举顺序反一下就行了三是后效性 + 高斯消元，偶尔会用约旦高斯，注意观察就行了，推起来不难，就是要记得背板子上题（直接在洛谷搜索题目就行）：1.「SCOI2008」奖励关 2.正推：CodeForces 148 D Bag of mice3.反推： POJ2096 Collecting Bugs4.CodeForce
期望dp和概率dp的区别
07-29
概率dp通常用于求解概率问题，例如求解抛硬币出现正面的概率、求解从一副牌中抽到红心的概率等。 总结来说，期望dp和概率dp的区别在于它们所计算的是不同的值，期望dp计算的是期望值，而概率dp计算的是概率值。 ###...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值