HDU4624 Endless Spin(概率&&dp)

2013年多校的题目，那个时候不太懂怎么做，最近重新拾起来，看了一下出题人当初的解题报告，再结合一下各种情况的理解，终于知道整个大致的做法，这里具体写一下做法。

题意：给你一段长度为[1..n]的白色区间，每次随机的取一个子区间将这个区间涂黑，问整个区间被涂黑时需要的期望次数。

1. 首先要做的是一个题目的转化。如果我定义pi为恰好i次将区间涂黑的概率，那么显然期望 E= 0*p0+1*p1+2*p2+... 换一种角度看这个公式，其实这个公式可以这么写

　　　　　　　　E = p1 + p2 + p3 + p4 + p5 + ...

　　　　　　　　　　 p2 + p3 + p4 + p5 + ...

　　　　　　　　　　　　　　 p3 + p4 + p5 + ...

定义Li=p(i+1) + p(i+2) + ... 那么我们可以把Li理解成覆盖了i次都没有将整个区间涂黑的概率。

所以E=L0+L1+L2+...

2. 理解了上面这一点之后我们可以先考虑一种暴力的做法，那就是枚举2^n个最后留下来的点，譬如最后留下来的点是v1,v2,v3...vk，那么实际上可选的区间只有[1,v1-1],[v1+1,v2-1],[v2+1,v3-1]...那么这里区间的选法就有A种（A是可以求出来的），要使这些点都能被留下来，那么我们每次选的只能是这A个区间，因而概率 p = A/ ((n+1)*n/2). 那么对于Li来说 Li += p^i* (-1)^(k－1). 之所以要乘(-1)^k是因为这里需要有一个容斥。考虑到p^i的累加和即 p+p^1+p^2+... = 1/(1-p) 所以对于每个2^n，它对最后期望的影响实际上是 1/(1-p)*(-1)^(k-1).

3. 暴力的想法给到了，那么下面就是要优化一下这种做法了，因为我总不可能2^50枚举所有剩下的点。一个自然的想法是考虑dp，看上面的式子我们不难发现实际上最后起作用的是 A和k的奇偶性，而A的范围是有限的（总的区间个数），那么我们可以定义一个状态dp[i][j][k]表示，第i个点是白点（未被覆盖），且前i个白点的奇偶性为j，可选区间的个数为k有多少个子集。那么对于一个期望值E[n]来说(n>=i) 这个状态对E[n]的影响实际上是

可选的区间 A = 前i个点的可选区间数+ [i...n]这一段为黑的可选区间数＝ k+(n-i+1)(n-i)/2;

　　　　　　p = A/（(n+1)*n/2）;

　　　　　　E[n] += dp[i][j][k]*(1-p)*(-1)^(j-1)；

dp状态的转移具体可以参考一下下面的代码。

4. 题目的第二个坑点就在于它需要有15个小数点的精度，所以需要写一个高精度类，这里只需要涉及两个浮点数的加法和减法就可以了，所以写的时候还是挺容易的，注意答案是round到15个小数点，所以如果小数点后第16个数是>=5的，输出之前还要将结果加上一个1e-15.

下面贴两分代码，一份是不需要高精度的时候的dp的代码，另外一份是要高精度的代码。

#pragma warning(disable:4996)

#include<algorithm>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<math.h>

#include<iostream>

#include<queue>

#include<list>

#include<time.h>

#include<bitset>

using namespace std;

#define ll long long

#define maxn 55

ll dp[maxn][2][maxn*(maxn + 1) / 2];

double E[maxn];

int main()

{

	memset(dp, 0, sizeof(dp));

	memset(E, 0, sizeof(E));

	dp[0][0][0] = 1;

	for (int i = 0; i <= 50; ++i){

		for (int j = 0; j <= (i + 1)*i / 2; ++j){

			if (dp[i][0][j]) {

				for (int k = i + 1; k <= 50; ++k){

					dp[k][1][j + (k - i)*(k - i - 1) / 2] += dp[i][0][j];

				}

			}

			if (dp[i][1][j]){

				for (int k = i + 1; k <= 50; ++k){

					dp[k][0][j + (k - i)*(k - i-1) / 2] += dp[i][1][j];

				}

			}

		}

	}

	for (int i = 1; i <= 50; ++i){

		for (int k = 0; k <= i; ++k){

			for (int j = 0; j <= (k + 1)*k / 2; ++j){

				if (dp[k][0][j]){

					long double p = (j + (i - k + 1)*(i - k) / 2 + .0) / ((i + 1)*i / 2);

					if (p == 1.0) { continue; }

					E[i] -= dp[k][0][j] / (1 - p);

				}

				if (dp[k][1][j]){

					long double p = (j + (i - k + 1)*(i - k) / 2 + .0) / ((i + 1)*i / 2);

					if (p == 1.0) { continue; }

					E[i] += dp[k][1][j] / (1 - p);

				}

			}

		}

	}

	int xx;

	cin >> xx;

}

#pragma warning(disable:4996)

#include<algorithm>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<math.h>

#include<iostream>

#include<queue>

#include<list>

#include<time.h>

#include<bitset>

using namespace std;

#define ll long long

#define maxn 55

#define maxdp 50

struct BigDecimal

{

	ll ip;

	int dp[maxdp];

	BigDecimal(){

		ip = 0;

		memset(dp, 0, sizeof(dp));

	}

	BigDecimal(int x){

		ip = x;

		memset(dp, 0, sizeof(dp));

	}

	BigDecimal(ll x, ll y)

	{

		ip = x / y;

		x = abs(x); y = abs(y);

		x = x%y;

		for (int i = 0; i < maxdp; ++i){

			x *= 10;

			dp[i] = x / y;

			x %= y;

		}

	}

};

BigDecimal operator + (const BigDecimal &a, const BigDecimal &b)

{

	BigDecimal ret;

	int carry = 0;

	for (int i = maxdp - 1; i >= 0; --i){

		ret.dp[i] = (a.dp[i] + b.dp[i] + carry) % 10;

		carry = (a.dp[i] + b.dp[i] + carry) / 10;

	}

	ret.ip = a.ip + b.ip + carry;

	return ret;

}

BigDecimal operator - (const BigDecimal &a, const BigDecimal &b)

{

	BigDecimal ret;

	int marry = 0;

	for (int i = maxdp - 1; i >= 0; --i){

		ret.dp[i] = (a.dp[i] - b.dp[i] - marry + 10) % 10;

		marry = a.dp[i] - b.dp[i] - marry < 0 ? 1 : 0;

	}

	ret.ip = a.ip - b.ip - marry;

	return ret;

}

void print(const BigDecimal& x, int digits)

{

	printf("%I64d.", x.ip);

	BigDecimal y;

	if (x.dp[digits] >= 5){

		y.dp[digits - 1] = 1;

	}

	y = x + y;

	for (int i = 0; i < digits; ++i){

		printf("%d", y.dp[i]);

	}

	puts("");

}

ll dp[maxn][2][maxn*(maxn + 1) / 2];

BigDecimal Ep[maxn];

BigDecimal En[maxn];

BigDecimal E[maxn];

int main()

{

	memset(dp, 0, sizeof(dp));

	memset(E, 0, sizeof(E));

	dp[0][0][0] = 1;

	for (int i = 0; i <= 50; ++i){

		for (int j = 0; j <= (i + 1)*i / 2; ++j){

			if (dp[i][0][j]) {

				for (int k = i + 1; k <= 50; ++k){

					dp[k][1][j + (k - i)*(k - i - 1) / 2] += dp[i][0][j];

				}

			}

			if (dp[i][1][j]){

				for (int k = i + 1; k <= 50; ++k){

					dp[k][0][j + (k - i)*(k - i - 1) / 2] += dp[i][1][j];

				}

			}

		}

	}

	for (int i = 1; i <= 50; ++i){

		ll all = ((i + 1)*i / 2);

		for (int k = 0; k <= i; ++k){

			for (int j = 0; j <= (k + 1)*k / 2; ++j){

				if (dp[k][0][j]){

					ll select = j + (i - k + 1)*(i - k) / 2;

					if (select == all) continue;

					En[i] = En[i] + BigDecimal(all*dp[k][0][j], all - select);

				}

				if (dp[k][1][j]){

					ll select = j + (i - k + 1)*(i - k) / 2;

					if (select == all) continue;

					Ep[i] = Ep[i] + BigDecimal(all*dp[k][1][j], all - select);

				}

			}

		}

		E[i] = Ep[i] - En[i];

	}

	int T; cin >> T; int n;

	while (T--)

	{

		cin >> n;

		print(E[n], 15);

	}

	return 0;

}

巴特西

HDU4624 Endless Spin(概率&&dp)

最新文章

热门文章