poj 3744 Scout (Another) YYF I - 概率与期望 - 动态规划 - 矩阵快速幂

 

(Another) YYF is a couragous scout. Now he is on a dangerous mission which is to penetrate into the enemy's base. After overcoming a series difficulties, (Another) YYF is now at the start of enemy's famous "mine road". This is a very long road, on which there are numbers of mines. At first, (Another) YYF is at step one. For each step after that, (Another) YYF will walk one step with a probability of p, or jump two step with a probality of 1- p. Here is the task, given the place of each mine, please calculate the probality that (Another) YYF can go through the "mine road" safely.

Input

The input contains many test cases ended with EOF. 
Each test case contains two lines. 
The First line of each test case is N (1 ≤ N ≤ 10) and p (0.25 ≤ p ≤ 0.75) seperated by a single blank, standing for the number of mines and the probability to walk one step. 
The Second line of each test case is N integer standing for the place of N mines. Each integer is in the range of [1, 100000000].

Output

For each test case, output the probabilty in a single line with the precision to 7 digits after the decimal point.

Sample Input

1 0.5
2
2 0.5
2 4

Sample Output

0.5000000
0.2500000

---

　　题目大意 另一个叫做yyf的人在一个数轴上，他在位置1，每次他有p的概率向右跳1格，有(1 - p)的概率向右跳2格，如果踩到地雷就死了，问生还的概率。

　　显然动态规划。当位置i没有地雷的时候，显然有

　　如果位置i有地雷，那么有

　　由于值域很大，所以按照递推式动态规划的通用套路:构建转移矩阵加快动态规划。

　　由于n很小，所以可以分段，段内用矩阵快速幂处理，然后特殊处理一下f[i]，继续往前。

　　现在来构建转移矩阵:

 Code

/**
 * poj
 * Problem#3744
 * Accepted
 * Time: 0ms
 * Memory: 232k 
 */
#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cctype>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <bitset>
#include <cassert>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
#define clra(a) memset(a, false, sizeof(a))
const signed int inf = ((~0u) >> 1);
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)

template <typename T>
class Matrix {
    public:
        T a[2][2];
        int row; 
        int col;
        
        Matrix() {        }
        Matrix(int row, int col):row(row), col(col) {        }
        
        Matrix<T> operator * (Matrix<T> b) {
            Matrix<T> rt(row, b.col);
            assert(col == b.row);
            for(int i = 0; i < row; i++)
                for(int j = 0; j < b.col; j++) {
                    rt[i][j] = 0;
                    for(int k = 0; k < col; k++)
                        rt[i][j] += a[i][k] * b[k][j];
                }
            return rt;
        } 
        
        T* operator [] (int pos) {
            return &a[pos][0];
        }
};

int n;
double p;
Matrix<double> unit(2, 2);
Matrix<double> trans(2, 2);
int boom[15];

template <typename T>
Matrix<T> matpow(Matrix<T>& a, int pos) {
    if(pos == 0)    return unit;
    if(pos == 1)    return a;
    Matrix<T> temp = matpow(a, pos >> 1);
    temp = temp * temp;
    if(pos & 1)    temp = temp * a;
    return temp;
}

inline void prepare() {
    unit[0][0] = unit[1][1] = 1;
    unit[0][1] = unit[1][0] = 0;
}

inline void init() {
    for(int i = 0; i < n; i++)
        scanf("%d", boom + i);
    sort(boom, boom + n);
    trans[0][0] = p, trans[0][1] = 1 - p;
    trans[1][0] = 1, trans[1][1] = 0;
}

inline void solve() {
    int last = boom[n - 1];
    Matrix<double> f(2, 1);
    f[0][0] = 0, f[1][0] = 1;
    for(int i = n - 2; ~i; f[0][0] = 0, last = boom[i], i--)
        f = matpow(trans, last - boom[i]) * f;
    f = matpow(trans, last - 1) * f;
    printf("%.7lf\n", f[0][0]);
}

int main() {
    prepare();
    while(~scanf("%d%lf", &n, &p)) {    //坑啊，scanf交G++ WA了，交C++过了 
        init();
        solve();
    }
    return 0;
}