DP(概率专题二)

题意:

• 在一条不满地雷的路上，你现在的起点在1处。在N个点处布有地雷，1<=N<=10。地雷点的坐标范围：[1,100000000].
• 每次前进p的概率前进一步，1-p的概率前进1-p步。问顺利通过这条路的概率。

>> Scout YYF I <<

Strategy:矩阵加速概率dp? 话说这题是dp嘛

状态: $dp[i]$ 从1点到i点的概率?

边界: dp[n] = 0

合法判断: 本题无

转移方程:

$$dp[i]=dp[i-1]\times p+dp[i-2]\times (1-p)$$

attention: 其实并这样做是做不出来的, 因为中间有地雷的地方会影响转移,而且也不知道最终要走到哪里去, 然后经过深思熟虑(参考题解), 发现可以把路分成若干段, 每段的末尾都是地雷, 每段的起始点概率都是1, 这样搞了以后就不难发现, 答案就是每段都不踩地雷的概率, 可以根据乘法原理搞一搞, 然后又因为地雷的范围有点大, 可以考虑用加速矩阵优化(才学)

$$由\{\begin{array}{l}dp[i]=x\ast dp[i-1]+y\ast dp[i-2]\\ dp[i-1]=dp[i-1]+0\ast dp[i-2]\end{array}$$
构造矩阵:
$$\left[\begin{array}{cc}x& y\\ 1& 0\end{array}\right]\times \left[\begin{array}{cc}dp[2]& 0\\ dp[1]& 0\end{array}\right]=\left[\begin{array}{cc}x\ast dp[2]+y\ast dp[1]& y\\ dp[2]& 0\end{array}\right]=\left[\begin{array}{cc}dp[3]& y\\ dp[2]& 0\end{array}\right]$$

即 :
$${\left[\begin{array}{cc}x& y\\ 1& 0\end{array}\right]}^{n-2}\times \left[\begin{array}{cc}dp[2]& 0\\ dp[1]& 0\end{array}\right]=\left[\begin{array}{cc}dp[n]& 0\\ dp[n-1]& 0\end{array}\right]$$

然后求快速幂

双倍经验: 加速矩阵优化适用的条件:

• 可以抽象出一个长度为n的一维向量，该向量在每个单位时间发生一次变化
• 变化的形式是一个线性递推（只有若干“加法”或者“乘一个系数”的运算）
• 该递推式在每个时间可能作用于不同的数据上，但本身保持不变
• 向量变化时间（即递推的轮数）很长，但向量长度n不大。

#include <vector>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <iostream>
#include<iomanip>
#include<map>
#include <algorithm>
using namespace std;
#define _rep(i, a, b) for (ll i = (a); i <= (b); ++i)
#define _rev(i, a, b) for (ll i = (a); i >= (b); --i)
#define _for(i, a, b) for (ll i = (a); i < (b); ++i)
#define _rof(i, a, b) for (ll i = (a); i > (b); --i)
#define maxm 109
#define oo 0x3f3f3f3f
#define ll long long
#define db double
#define eps 1e-8
#define what_is(x) cerr << #x << " is " << x << "s" << endl;
#define met(a, b) memset(a, b, sizeof(a))
#define pi acos(-1.0)
const int maxn = 12;
int n, a[maxn];

struct matrix
{
	db m[3][3];
	matrix() { met(m, 0); }
	matrix operator*(matrix& b)
	{
		matrix r;
		_rep(i, 1, 2)
		{
			_rep(j, 1, 2)
			{
				_rep(k, 1, 2)
				{
					r.m[i][j] += m[i][k] * b.m[k][j];
				}
			}
		}
		return r;
	}
	matrix traval(int a, matrix c)
	{
		matrix ret;
		_rep(i, 1, 2) ret.m[i][i] = 1;
		for (; a; a >>= 1, c = c * c)
		{
			if (a & 1)
				ret = ret * c;
		}
		return ret;
	}
} trans, dp;
db p;
int main()
{
	ios::sync_with_stdio(0);
	while (cin >> n)
	{
		met(a, 0);
		cin >> p;
		_rep(i, 1, n)
			cin >> a[i];
		sort(a + 1, a + 1 + n);
		trans.m[1][2] = 1 - p;
		trans.m[2][1] = 1;
		trans.m[2][2] = p;
		dp.m[1][2] = 1;
		db ans = 1;
		_rep(i, 1, n)
		{
			if (a[i] == a[i - 1])continue;
			matrix tmp;
			tmp = trans.traval(a[i] - a[i - 1], trans);
			tmp = dp * tmp;
			ans *= (1 - tmp.m[1][1]);
		}
		cout << fixed << setprecision(7) << ans << endl;
	}
}

---

upd 2020.12.10

class Solution {
public:
    /**
     * 返回c[n]%1000000007的值
     * @param n long长整型 即题目中的n
     * @return int整型
     */


    struct matrix {
        long long mat[2][2], mod = 1e9 + 7;

        matrix() { memset(mat, 0, sizeof(mat)); }

        matrix operator*(matrix &b) {
            matrix ret;
            for (int i = 0; i < 2; ++i) {
                for (int j = 0; j < 2; ++j) {
                    for (int k = 0; k < 2; ++k) {
                        ret.mat[i][j] = (ret.mat[i][j] + mat[i][k] * b.mat[k][j]) % mod;
                    }
                }
            }
            return ret;
        }

        matrix qpow(matrix a, long long b  ) {
            matrix r;
            for (int i = 0; i < 2; ++i) {
                r.mat[i][i] = 1;
            }
            for (;b;a = a*a,b >>=1){
                if (b & 1)r = r* a;
            }
            return r;
        }
    }transA, transB, a, b;

    int Answerforcn(long long n) {
        // write code here
        if (n == 1){
            return 14;

        }
        transA.mat[0][0] = 2;
        transA.mat[0][1] = 3;
        transA.mat[1][0] = 1;
        transA.mat[1][1] = 0;
        transA = transA.qpow(transA, n-2);
        a.mat[0][0] = 6;
        a.mat[1][0] = 2;
        transB.mat[0][0] = 3;
        transB.mat[0][1] = 10;
        transB.mat[1][0] = 1;
        transB.mat[1][1] = 0;
        transB = transB.qpow(transB, n-2);
        b.mat[0][0] = 35;
        b.mat[1][0] = 7;
        matrix aa = transA*a, bb = transB*b;
        return aa.mat[0][0] * bb.mat[0][0] % b.mod;
    }
}t;