POJ 3744 Scout YYF I 概率DP + 矩阵快速幂

题目大意：

YYF潜入了敌军基地，现在需要从中逃离，逃离时需要经过一片地雷区， 这片地雷区可以视为一条数轴，从位置1开始向前走， 每次有p的概率前进一格，有( 1 - p )的概率前进2格，现在一片雷区有N个地雷，告诉你每个地雷所在的位置，要求求出YYF有多大的概率安全地走出雷区

地雷所在的位置可能达到10^8

大致思路：

首先，我们暂时不考虑地雷的因素，那么对于位置 n , 安全到达位置 n 的概率 F( n ) 满足：

F( n ) = p*F( n - 1) + ( 1 - p )*F(n - 2); n >= 2

其中F(0) = 0; F(1) = 1;

这样的话不难发现转换矩阵的方法：

利用矩阵解决了 地雷的位置编号可能高达10^8的问题

接下来看地雷的原因：

假设位置 i 有地雷，那么当矩阵快速幂计算到这个位置时，将安全到达这个位置的概率清零，即在地推到F( i ) 之后将F( i )归零，这样后面的位置的上一状态来自于这一状态的概率是0

这样子知道计算至最后一个地雷，最后一个地雷的位置+1 对应的概率即为最终结果，因为不可能在不经过最后一个地雷位置 + 1 那个位置的情况下到达之后的位置

也就是说，到达那个位置的便是到达了安全区域

代码如下：

Result  :  Accepted     Memory  :  148 KB     Time  :  0 ms

/*
 * Author: Gatevin
 * Created Time:  2014/7/28 20:14:05
 * File Name: test.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

int N;
double p;
int mine[20];

struct Matrix
{
    double a[3][3];
    Matrix()
    {
        for(int i = 1; i <= 2; i++)
        {
            for(int j = 1; j <= 2; j++)
            {
                a[i][j] = i == j ? 1.0 : 0;
            }
        }
    }
};

Matrix operator * (const Matrix & m1, const Matrix & m2)
{
    Matrix m;
    for(int i = 1; i <= 2; i++)
    {
        for(int j = 1; j <= 2; j++)
        {
            m.a[i][j] = 0;
            for(int k = 1; k <= 2; k++)
            {
                m.a[i][j] += m1.a[i][k]*m2.a[k][j];
            }
        }
    }
    return m;
}

Matrix quick_pow(Matrix base, int pow)
{
    Matrix I;
    while(pow)
    {
        if(pow & 1)
        {
            I = I * base;
        }
        base = base*base;
        pow >>= 1;
    }
    return I;
}

int main()
{
    while(scanf("%d %lf",&N, &p) == 2)
    {
        for(int i = 1; i <= N; i++)
        {
            scanf("%d", &mine[i]);
        }
        sort(mine + 1, mine + N + 1);
        double f0 = 0 , f1 = 1;
        mine[0] = 1;
        Matrix tran;
        tran.a[1][1] = p;
        tran.a[1][2] = 1;
        tran.a[2][1] = 1 - p;
        tran.a[2][2] = 0;
        for(int i = 1; i <= N; i++)
        {
            Matrix hehe = quick_pow(tran, mine[i] - mine[i - 1]);
     //       double tmp1 = f1*hehe.a[1][1] + f0*hehe.a[2][1];
            double tmp2 = f1*hehe.a[1][2] + f0*hehe.a[2][2];
     //       f1 = tmp1;
            f0 = tmp2;
            f1 = 0;
        }
        printf("%.7lf\n",f0*(1 - p));
    }
    return 0;
}