POJ 3028 Shoot-out（概率DP）

Description

This is back in the Wild West where everybody is fighting everybody. In particular, there are n cowboys, each with a revolver. These are rather civilized cowboys, so they have decided to take turns firing their guns until only one is left standing. Each of them has a given probability of hitting his target, and they all know each other’s probability. Furthermore, they are geniuses and always know which person to aim at in order to maximize their winning chance, so they are indeed peculiar cowboys. If there are several equally good targets, one of those will be chosen at random. Note that a cowboy’s code of ethics forces him to do his best at killing one of his opponents, even if intentionally missing would have increased his odds (yes, this can happen!)

Input

On the first line of the input is a single positive integer t, telling the number of test cases to follow. Each case consists of one line with an integer 2 ≤ n ≤ 13 giving the number of cowboys, followed by n positive integers giving hit percentages for the cowboys in the order of their turns.

Output

For each test case, output one line with the percent probabilities for each of them surviving, in the same order as the input. The numbers should be separated by a space and be correctly rounded to two decimal places.

 

题目大意：n个枪手，均有一个命中率，从第一位开始，每次下一位开枪射击一个人。问每个人的生存率是多少，枪手总会朝着对自己最有利的人开枪，但一定要开枪，不能向自己开枪，如果有多个最有利的人，随机向其中一个开枪。

思路：O(n^4*2^n)水过去的……所以思路就不怎么讲了……（next每次算会TLE，先预处理出来依然TLE……）现在实在想不到什么好方法先这样吧……

PS：贴一下做题时候的草稿

b[i]为i命中的胜率
a[i]为i不命中的胜率
p[i]为i的命中率
q[i]为1-p[i]
a[i] = p[i+1] * b[i+1] + q[i+1] * a[i+1]
= p[i+1] * b[i+1] + q[i+1] * (p[i+2] * b[i+2] + q[i+2] * a[i+2])
= p[i+1] * b[i+1] + q[i+1] * p[i+2] * b[i+2] + q[i+1] * q[i+2] * a[i+2]
= p[i+1] * b[i+1] + q[i+1] * p[i+2] * b[i+2] + ……
+ pro{q[i+1] .. q[i-1]} * p[i] * b[i] + pro{q[i+1] .. q[i]} * a[i]
a[i] = (p[i+1] * b[i+1] + q[i+1] * p[i+2] * b[i+2] + ……
+ pro{q[i+1] .. q[i-1]} * p[i] * b[i]) / (1 - pro{q[i+1] .. q[i]})

 

代码（2641MS）：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;

const int MAXN = 13;
const double EPS = 1e-8;

int T, n;
double dp[MAXN][(1 << MAXN) + 10][MAXN];
double p[MAXN];

inline int sgn(double x) {
    return (x > EPS) - (x < -EPS);
}

int Tnext[1 << MAXN][MAXN];

inline int next(int state, int x) {
    if(Tnext[state][x] != -1) return Tnext[state][x];
    int ret = x;
    while(true) {
        if(++ret == n) ret = 0;
        if(state & (1 << ret)) break;
    }
    return Tnext[state][x] = ret;
}

inline int count(int state) {
    int ret = 0;
    while(state) {
        ret += state & 1;
        state >>= 1;
    }
    return ret;
}

int c[MAXN][MAXN];
double b[MAXN][MAXN], maxb[MAXN];

void dfs(int state, int cur) {
    if(dp[cur][state][0] != -1) return ;
    if(count(state) == 1) {
        for(int i = 0; i < n; ++i) dp[cur][state][i] = (i == cur);
        return ;
    }

    for(int i = 0; i < n; ++i) {
        if((state & (1 << i)) == 0) continue;
        for(int tar = next(state, i); tar != i; tar = next(state, tar)) {
            int newState = state ^ (1 << tar), nx = next(newState, i);
            dfs(newState, nx);
        }
    }

    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j) b[i][j] = c[i][j] = 0;
    for(int i = 0; i < n; ++i) maxb[i] = 0;

    for(int i = 0; i < n; ++i) {
        if((state & (1 << i)) == 0) continue;
        for(int tar = next(state, i); tar != i; tar = next(state, tar)) {
            int newState = state ^ (1 << tar), nx = next(newState, i);
            maxb[i] = max(maxb[i], dp[nx][newState][i]);
        }
        for(int tar = next(state, i); tar != i; tar = next(state, tar)) {
            int newState = state ^ (1 << tar), nx = next(newState, i);
            if(sgn(maxb[i] - dp[nx][newState][i]) == 0) {
                for(int k = 0; k < n; ++k) {
                    ++c[i][k];
                    b[i][k] += dp[nx][newState][k];
                }
            }
        }
        for(int k = 0; k < n; ++k) b[i][k] /= c[i][k];
    }

    for(int k = 0; k < n; ++k) dp[cur][state][k] = p[cur] * b[cur][k];

    for(int k = 0; k < n; ++k) {
        if((state & (1 << k)) == 0) continue;
        int now = cur;
        double tmp = 1, sum = 0;
        do {
            now = next(state, now);
            sum += tmp * p[now] * b[now][k];
            tmp *= (1 - p[now]);
        } while(cur != now);
        dp[cur][state][k] += sum / (1 - tmp) * (1 - p[cur]);
    }
}

void solve() {
    dfs((1 << n) - 1, 0);
    for(int i = 0; i < n - 1; ++i) printf("%.2f ", 100 * dp[0][(1 << n) - 1][i]);
    printf("%.2f\n", 100 * dp[0][(1 << n) - 1][n - 1]);
}

int main() {
    memset(Tnext, -1, sizeof(Tnext));
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        for(int i = 0; i < n; ++i) scanf("%lf", &p[i]), p[i] /= 100;
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < (1 << n); ++j) dp[i][j][0] = -1;
        solve();
    }
}