【Contest】Problems about probablity

最新推荐文章于 2022-06-04 11:52:52 发布

willinglive

最新推荐文章于 2022-06-04 11:52:52 发布

阅读量617

点赞数

分类专栏： Contest

本文链接：https://blog.csdn.net/willinglive/article/details/45886859

版权

Contest 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

以后再推一遍

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
#define rep(i,l,r) for(int i=(l),_=(r);i<=_;i++)
#define per(i,r,l) for(int i=(r),_=(l);i>=_;i--)
#define MS(arr,x) memset(arr,x,sizeof(arr))
#define INE(i,u) for(int i=head[u];~i;i=e[i].next)
#define LL long long
inline const int read(){int r=0,k=1;char c=getchar();
for(;c<'0'||c>'9';c=getchar())if(c=='-')k=-1;
for(;c>='0'&&c<='9';c=getchar())r=r*10+c-'0';return r*k;}
/*
   dp[>n] = 0
   dp[i] = sigma (P[k] * dp[i + k]) + P[0] * dp[0] + 1
   Let
   dp[i] = a[i] * dp[0] + b[i]
   Then 
   dp[i] = (sigma (P[k] * a[i + k]) + P[0]) * dp[0] + sigma (P[k] * b[i + k]) + 1
   i.e.
   a[i] = sigma (P[k] * a[i + k]) + P[0]  (i<=n)
   b[i] = sigma (P[k] * b[i + k]) + 1     (i<=n)
   a[i>n] = b[i>n] = 0
   We can calculate the value of a[] and b[]
   Finally we get the answer
   dp[0] = b[0] / (1 - a[0])
*/
//
const int N=520;
int n,k1,k2,k3,a,b,c,K,s;
double dp[N];
double A[N],B[N];
double p[N];
//

//
void input()
{
	MS(A,0); MS(B,0); MS(p,0);
	cin>>n>>k1>>k2>>k3>>a>>b>>c;
	K=k1*k2*k3; s=k1+k2+k3;
}
void solve()
{
	p[0]=1.0/K;
	rep(i,1,k1) rep(j,1,k2) rep(k,1,k3) if(i!=a || j!=b || k!=c)
		p[i+j+k]+=p[0];
	per(i,n,0)
	{
		A[i]=p[0];
		B[i]=1;
		rep(k,3,s)
		{
			A[i]+=p[k]*A[i+k];
			B[i]+=p[k]*B[i+k];
		}
	}
	double ans=B[0]/(1-A[0]);
	printf("%.15f\n",ans);
}
//
int main()
{
	rep(i,1,read())
	input(),solve();
	return 0;
}

推导得不太熟练

if(i==1) dp[1][1] = ( p1 + p2 ) * dp[1][1] + p4
else if(j>1) dp[i][j] = p1 * dp[i][j] + p2 * dp[i][j-1] + p3 * dp[i-1][j-1] + p4 * [j <= k]
else dp[i][1] = p1 * dp[i][1] + p2 * dp[i][i] + p4

p21 = p2 / (1 - p1)
p31 = p3 / (1 - p1)
p41 = p4 / (1 - p1)

if(i==1) dp[1][1] * (1 - p1 - p2) = p4
else if(j>1) dp[i][j] = p21 * dp[i][j-1] + p31 * dp[i-1][j-1] + p41 * [j <= k]
else dp[i][1] = p21 * dp[i][i] + p41

dp[i][i] = p21 * dp[i][i-1] + p31 * dp[i-1][i-1] + p41 * [i <= k]
dp[i][i-1] = p21 * dp[i][i-2] + p31 * dp[i-1][i-2] + p41 * [i-1 <= k]
dp[i][i-2] = p21 * dp[i][i-3] + p31 * dp[i-1][i-3] + p41 * [i-2 <= k]
...
dp[i][1] = p21 * dp[i][i] + p41

c[i][j] = p31 * dp[i-1][j-1] + p41 * [j <= k]

dp[i][i] = p21 * ( p21 * ( p21 * ( ... ) + c[i][i-2] ) + c[i][i-1] ) + c[i][i]
         = c[i][i] + p21 * c[i][i-1] + p21 ^ 2 * c[i][i-2] + ... + p21 ^ (i - 1) * dp[i][1]
         = c[i][i] + p21 * c[i][i-1] + p21 ^ 2 * c[i][i-2] + ... + p21 ^ (i - 1) * (p21 * dp[i][i] + p41)
         = c[i][i] + p21 * c[i][i-1] + p21 ^ 2 * c[i][i-2] + ... + p21 ^ (i-1) * p41
(1 - p21 ^ i) * dp[i][i] = c[i][i] + p21 * c[i][i-1] + p21 ^ 2 * c[i][i-2] + ... + p21 ^ (i-1) * p41

vim为啥连注释都要缩进

E[u] = p1[u] * E[1] + p3[u] * ave (E[v] + 1)
     = p1[u] * E[1] + p3[u] * ave (E[v]) + p3

If u is a leaf
    E[u] = p1[u] * E[1] + p3[u] * E[fa] + p3[u]
Else
    Let m = deg[u]
    E[u] = p1[u] * E[1] + p3[u] * (sigma (E[son[u]] + 1) + E[fa[u]] + 1) / m
         = p1[u] * E[1] + p3[u] * sigma (E[son[u]]) / m + p3[u] * (E[fa[u]]) / m + p3[u]

Let E[u] = A[u] * E[1] + B[u] * E[fa[u]] + C[u]
If u is not a leaf
    E[u] = p1[u] * E[1] + p3[u] * sigma (E[son[u]]) / m + p3[u] * (E[fa[u]]) / m + p3[u]
         = (p1[u] + p3[u] * A[son[u]] / m) * E[1] + p3[u] * sigma (E[son[u]]) * E[u] / m + p3[u] * C[son[u]] / m + p3[u] * E[fa[u]] / m + p3[u]

    (1 - p3[u] * sigma (B[son[u]]) / m) * E[u] = (p1[u] + p3[u] * A[son[u]] / m) * E[1] + p3[u] / m * E[fa[u]] + p3[u] * C[son[u]] / m + p3[u]
    Let T = 1 - p3[u] * sigma (B[son[u]]) / m
    A[u] = (p1[u] + p3[u] * A[son[u]] / m) / T
    B[u] = (p3[u] / m) / T
    C[u] = (p3[u] * C[son[u]] / m + p3[u]) / T
Else if u is a leaf
    A[u] = p1[u]
    B[u] = p3[u]
    C[u] = p3[u]

E[1] = A[1] * E[1] + C[1]
E[1] = C[1] / (1 - A[1])

Output "impossible" only when A[1] -> 1

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
#define rep(i,l,r) for(int i=(l),_=(r);i<=_;i++)
#define per(i,r,l) for(int i=(r),_=(l);i>=_;i--)
#define MS(arr,x) memset(arr,x,sizeof(arr))
#define INE(i,u) for(int i=head[u];~i;i=e[i].next)
#define LL long long
inline const int read(){int r=0,k=1;char c=getchar();
for(;c<'0'||c>'9';c=getchar())if(c=='-')k=-1;
for(;c>='0'&&c<='9';c=getchar())r=r*10+c-'0';return r*k;}
/*
   E[u] = p1[u] * E[1] + p3[u] * ave (E[v] + 1)
        = p1[u] * E[1] + p3[u] * ave (E[v]) + p3

		If u is a leaf
		    E[u] = p1[u] * E[1] + p3[u] * E[fa] + p3[u]
			Else
			    Let m = deg[u]
				    E[u] = p1[u] * E[1] + p3[u] * (sigma (E[son[u]] + 1) + E[fa[u]] + 1) / m
					         = p1[u] * E[1] + p3[u] * sigma (E[son[u]]) / m + p3[u] * (E[fa[u]]) / m + p3[u]

							 Let E[u] = A[u] * E[1] + B[u] * E[fa[u]] + C[u]
							 If u is not a leaf
							     E[u] = p1[u] * E[1] + p3[u] * sigma (E[son[u]]) / m + p3[u] * (E[fa[u]]) / m + p3[u]
								          = (p1[u] + p3[u] * A[son[u]] / m) * E[1] + p3[u] * sigma (E[son[u]]) * E[u] / m + p3[u] * C[son[u]] / m + p3[u] * E[fa[u]] / m + p3[u]

										      (1 - p3[u] * sigma (B[son[u]]) / m) * E[u] = (p1[u] + p3[u] * A[son[u]] / m) * E[1] + p3[u] / m * E[fa[u]] + p3[u] * C[son[u]] / m + p3[u]
											      Let T = 1 - p3[u] * sigma (B[son[u]]) / m
												      A[u] = (p1[u] + p3[u] * A[son[u]] / m) / T
													      B[u] = (p3[u] / m) / T
														      C[u] = (p3[u] * C[son[u]] / m + p3[u]) / T
															  Else if u is a leaf
															      A[u] = p1[u]
																      B[u] = p3[u]
																	      C[u] = p3[u]

																		  E[1] = A[1] * E[1] + C[1]
																		  E[1] = C[1] / (1 - A[1])

																		  Output "impossible" only when A[1] -> 1
*/
//
const int N=10010;
const double eps=1e-10;
int n;
struct edge{int v,next;}e[N*2];
int head[N],k;
double p1[N],p2[N],p3[N];
double A[N],B[N],C[N];
//
void adde(int u,int v)
{
	e[k].v=v;
	e[k].next=head[u];
	head[u]=k++;
}
bool dfs(int u,int fa)
{
	double T=0;
	int m=0;
	if(u!=1) m=1;
	INE(i,u)
	{
		int v=e[i].v; if(v==fa) continue;
		m++;
		dfs(v,u);
		A[u]+=A[v];
		T+=B[v];
		C[u]+=C[v];
	}
	if(u==1 || m>1)
	{
		T=1-p3[u]*T/m;
		if(T<eps) return 0;
		A[u]=(p1[u]+p3[u]*A[u]/m)/T;
		B[u]=p3[u]/m/T;
		C[u]=(p3[u]*C[u]/m+p3[u])/T;
	}
	else
	{
		A[u]=p1[u];
		B[u]=p3[u];
		C[u]=p3[u];
	}
//	printf("u=%d A=%lf B=%lf C=%lf\n",u,A[u],B[u],C[u]);
	return 1;
}
//
void input()
{
	MS(head,-1); k=0;
	MS(A,0); MS(B,0); MS(C,0);
	n=read();
	rep(i,2,n)
	{
		int u=read(),v=read();
		adde(u,v); adde(v,u);
	}
	rep(i,1,n) scanf("%lf%lf",&p1[i],&p2[i]),p3[i]=100-p1[i]-p2[i];
	rep(i,1,n) p1[i]/=100,p2[i]/=100,p3[i]/=100;
}
void solve()
{
	if(!dfs(1,0) || fabs(A[1]-1)<eps) puts("impossible");
	else printf("%.10f\n",C[1]/(1-A[1]));
}
//
int main()
{
	int t=read();
	rep(i,1,t) printf("Case %d: ",i),
	input(),solve();
	return 0;
}