数学专题训练3

这次是概率专练

选的题都比较基础。。因为我对概率的感觉很不到位啊啊啊啊

题目一：wikioi计算概率

地址：http://www.wikioi.com/problem/1533/

这个就是古典概型嘛。。。先枚举选的第一根。。。然后再求出第选二根后和小于等于l的方案个数。然后答案很自然就是 这些方案个数的和/n*(n-1)了。。

考虑到n稍大。。求方案数不能直接暴力。。。可以选择二分来求（要注意选的第二根不能与第一根一样。。所以二分后还要判断下这些可选的木棍是否包含了第一根，包含了的话减去）

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
int n,ll;
int len[100000+10];
double ans=0;
int main()
{
	scanf("%d%d",&n,&ll);
	for(int i=1;i<=n;i++)scanf("%d",&len[i]);
	sort(len+1,len+n+1);
	for(int i=1;i<=n;i++)
	{
		int l=1,r=n;
		while(l<r)
		{
			int mid=l+r+1>>1;
			if(len[mid]+len[i]>ll)r=mid-1;
			else l=mid;
		}
		if(l>=i)
		{
			l--;
		}
		if(l==1&&len[1]+len[i]>ll)l--;
		ans=ans+l*1.0/(n-1);
	}
	printf("%.2f\n",ans/n);
	return 0;
}

第二题：rqnoj矩阵粉刷

地址：http://www.rqnoj.cn/problem/717

rq的某次月赛题。。。当时我是第一次参加网赛。。结果一道都不会 T_T

其实这题的题意我觉得不是太清楚。。。说的随机选两个点。。。其实选的这两个点可以是一个。。然后对应的矩形就是一个小方格了

期望方块数自然就是 每个方块的被刷到的概率*权值1 的和。

但是要粉刷k次。。。不好直接求哪个小方格被刷的概率。。。于是可以求某次不被刷的概率 p，然后1-p^k就是被刷的概率啦

然后某次不被刷的概率又要用1-某次被刷的概率来求。。

考虑到这样一个问题：对于每个方块。。。包含了它的矩形一定有两个相对的顶点在它的坐上方和右下方。。。（包括它本身所在坐标）

然后这样的矩形数基本上就是 左上角点横坐标可选方案数*纵坐标可选方案数*右下角点横坐标可选方案数*纵坐标可选方案数。

对于不为一个或一行一列的矩形。。。有四种选点的方式会选到它，对于是一行或一列的矩形只有两种，对于只有一格的矩形（也就是正好是这一格本身）只统计了一次。。。

于是我们就枚举方块(i,j)

其一次被粉刷的方案数为 4*i*j*(w-i+1)*(h-j+1)-2*(i*(w-i+1)+j*(h-j+1))+1 (先全当成普通的矩形，然后减去为一行或一列时多计算的次数，再加上多扣了的当一个格子时的次数)，概率就是  上面那个式子/w*w*h*h

这题基本上就这样了。。。

#include<cstdlib>
#include<cmath>
#include<cstring>
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
long long k,w,h;
double ans=0;
double qpow(double d,int c)
{
	if(c==0)return 1;
	if(c==1)return d;
	double ret=qpow(d,c/2);
	ret=ret*ret;
	if(c&1)ret=ret*d;
	return ret;
}
int main()
{
	scanf("%lld%lld%lld",&k,&w,&h);
	long long s=w*w*h*h;
	for(int i=1;i<=w;i++)
	{
		for(int j=1;j<=h;j++)
		{
			double tem=i*(w-i+1)*j*(h-j+1)*4-2*(i*(w-i+1)+j*(h-j+1))+1;
			tem=tem/s;
			ans+=1-qpow(1-tem,k);
		}
	}
	printf("%.0f\n",ans);
	return 0;
}

题目三：rqnoj bomb

地址：http://www.rqnoj.cn/problem/691

我觉得稍微有点高端的题。。。纠结了很久（当然对大神们来说还是水到爆啦）

这道题是一道与期望有关的dp

状态这么设计：dp[i]表示剩i个精灵时的期望操作次数（我开始设计成减少i个的期望。。。结果纠结半天）

然后就可以得出这样一个方程：

dp[i]=(dp[i]*p[0]+dp[i-1]*p[1]+dp[i-2]*p[2]+....+dp[i-5]*p[5])+1;

直接用这个方程来递推的话。。。当然不行。。。因为左右都有dp[i];

所以移个项整理一下...变成dp[i]=p[1]/(1-p[0])*dp[i-1]+...+p[5]/(1-p[0])*dp[i-5]+1/(1-p[0]);

边界是这样的：对于i<m,dp[i]=0;

考虑到数据范围有点大。。。这个递推又是线性的。于是就可以想到用矩阵乘法来优化。。。

然后基本就没什么难点了

#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
int n,m;
double p[10];
double end=0;
struct Mat
{
	int x,y;
	double num[8][8];
	Mat(){memset(num,0,sizeof(num));}
	Mat operator *(const Mat &b)
	{
		Mat c;
		c.x=x;c.y=b.y;
		for(int i=1;i<=x;i++)
		{
			for(int j=1;j<=b.y;j++)
				for(int k=1;k<=y;k++)
				{
					c.num[i][j]+=num[i][k]*b.num[k][j];
				}
		}
		return c;
	}
}start,single,ele;
void readdata()
{
	scanf("%d%d",&n,&m);
	for(int i=0;i<=m;i++)scanf("%lf",&p[i]);
}
double dp[5+10];
void pre()
{
	start.x=6;start.y=1;
	dp[m]=1.0/(1-p[0]);
	for(int i=m+1;i<=4;i++)
	{
		for(int j=1;j<=5;j++)if(i-j>=0)dp[i]+=(dp[j]*p[i-j]/(1-p[0]));
		dp[i]+=1.0/(1-p[0]);
	}
	start.num[1][1]=dp[4];
	start.num[2][1]=dp[3];
	start.num[3][1]=dp[2];
	start.num[4][1]=dp[1];
	start.num[5][1]=dp[0];
	start.num[6][1]=1.0/(1-p[0]);
	single.x=single.y=6;
	for(int i=1;i<=6;i++)
	{
		single.num[i][i]=1;
	}
	for(int i=1;i<=5;i++)ele.num[1][i]=p[i]/(1-p[0]);
	ele.x=ele.y=6;
	ele.num[1][6]=1;ele.num[2][1]=ele.num[3][2]=ele.num[4][3]=ele.num[5][4]=1;
	ele.num[6][6]=1;
}
Mat qpow(const Mat &d,int c)
{
	if(c==0)return single;
	if(c==1)return d;
	Mat ret=qpow(d,c/2);
	ret=ret*ret;
	if(c&1)ret=ret*d;
	return ret;
}
int main()
{
	readdata();
	pre();//计算出dp[0]到dp[4]并存入start
	if(n<=4)printf("%.1f\n",dp[n]);
	else
	{
		Mat ans=qpow(ele,n-4);
		ans=ans*start;
		printf("%.1f\n",ans.num[1][1]);
	}
	return 0;
}