[hdu4870]高斯消元

题意：小明有2个账号，rating都是0分，每打一场赢的概率为P，假设当前分为x，赢了分数变为min(1000,x+50)，输了则分数变为max(0,x-100)，小明每次都选rating小的账号打，求打到有一个账号为1000所需的场数的期望值

思路：很明显需要把分数离散化，50分为1个单位。利用期望的可加性建立状态：dp(x,y)(x<=y))表示当前两个账号rating小的为x，大的为y，到达目标状态所需场数的期望值，则有dp(x,y)=P*dp(x+1,y)+（1-P)*dp(x-1,y){这里为了描述方便，没有考虑边界}，dp(19,20)=0。建好图后由于所有的dp值都是未知的，但转移时的每一项前面的系数为常数，所以可以考虑用高斯消元来确定每个状态的值。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

/* ******************************************************************************** */

#include <iostream>                                                                 //

#include <cstdio>                                                                   //

#include <cmath>                                                                    //

#include <cstdlib>                                                                  //

#include <cstring>                                                                  //

#include <vector>                                                                   //

#include <ctime>                                                                    //

#include <deque>                                                                    //

#include <queue>                                                                    //

#include <algorithm>                                                                //

#include <map>                                                                      //

#include <cmath>                                                                    //

using namespace std;                                                                //

                                                                                    //

#define pb push_back                                                                //

#define mp make_pair                                                                //

#define X first                                                                     //

#define Y second                                                                    //

#define all(a) (a).begin(), (a).end()                                               //

#define fillchar(a, x) memset(a, x, sizeof(a))                                      //

                                                                                    //

typedef pair<int, int> pii;                                                         //

typedef long long ll;                                                               //

typedef unsigned long long ull;                                                     //

                                                                                    //

#ifndef ONLINE_JUDGE                                                                //

void RI(vector<int>&a,int n){a.resize(n);for(int i=0;i<n;i++)scanf("%d",&a[i]);}    //

void RI(){}void RI(int&X){scanf("%d",&X);}template<typename...R>                    //

void RI(int&f,R&...r){RI(f);RI(r...);}void RI(int*p,int*q){int d=p<q?1:-1;          //

while(p!=q){scanf("%d",p);p+=d;}}void print(){cout<<endl;}template<typename T>      //

void print(const T t){cout<<t<<endl;}template<typename F,typename...R>              //

void print(const F f,const R...r){cout<<f<<", ";print(r...);}template<typename T>   //

void print(T*p, T*q){int d=p<q?1:-1;while(p!=q){cout<<*p<<", ";p+=d;}cout<<endl;}   //

#endif // ONLINE_JUDGE                                                              //

template<typename T>bool umax(T&a, const T&b){return b<=a?false:(a=b,true);}        //

template<typename T>bool umin(T&a, const T&b){return b>=a?false:(a=b,true);}        //

template<typename T>                                                                //

void V2A(T a[],const vector<T>&b){for(int i=0;i<b.size();i++)a[i]=b[i];}            //

template<typename T>                                                                //

void A2V(vector<T>&a,const T b[]){for(int i=0;i<a.size();i++)a[i]=b[i];}            //

                                                                                    //

const double PI = acos(-1.0);                                                       //

const int INF = 1e9 + 7;                                                            //

                                                                                    //

/* -------------------------------------------------------------------------------- */

struct Gauss {

    const static int maxn = 1e3 + 7;

    double A[maxn][maxn];

    int n;

    double* operator [] (int x) {

        return A[x];

    }

    /** 要求系数矩阵可逆

    A是增广矩阵，A[i][n]是第i个方程右边的常数bi

    运行结束后 A[i][n]是第i个未知数的值 **/

    void solve() {

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

            int r = i;

            for (int j = i + 1; j < n; j ++) {

                if (fabs(A[j][i]) > fabs(A[r][i])) r = j;

            }

            if (r != i) for (int j = 0; j <= n; j ++) swap(A[r][j], A[i][j]);

            for (int j = n; j >= i; j --) {

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

                    A[k][j] -= A[k][i] / A[i][i] * A[i][j];

                }

            }

        }

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

            for (int j = i + 1; j < n; j ++) {

                A[i][n] -= A[j][n] * A[i][j];

            }

            A[i][n] /= A[i][i];

        }

    }

};

Gauss solver;

int c, n;

double p;

int hsh[22][22];

void add(int x, int y, int z) {

    solver[c][x] += 1;

    solver[c][y] += -p;

    solver[c ++][z] += p - 1;

}

void init() {

    fillchar(solver.A, 0);

    c = 0;

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

        for (int j = i; j < 20; j ++) {

            int win = i + 1, unwin = max(i - 2, 0);

            add(hsh[i][j], hsh[min(win, j)][max(win, j)], hsh[unwin][j]);

        }

    }

    solver[c ++][hsh[19][20]] = 1;

    for (int i = 0; i < c - 1; i ++) {

        solver[i][n] = 1;

    }

}

void pre_init() {

    int c = 0;

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

        for (int j = i; j < 20; j ++) {

            hsh[i][j] = c ++;

        }

    }

    hsh[19][20] = c ++;

    solver.n = n = c;

}

int main() {

#ifndef ONLINE_JUDGE

    freopen("in.txt", "r", stdin);

    //freopen("out.txt", "w", stdout);

#endif // ONLINE_JUDGE

    pre_init();

    while (cin >> p) {

        init();

        solver.solve();

        printf("%.10f\n", solver[0][n]);

    }

    return 0;

}

/* ******************************************************************************** */
时间： 2024-10-13 17:33:34

[hdu4870]高斯消元的相关文章

hdu4870 Rating （高斯消元或者dp）

Rating Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 213 Accepted Submission(s): 126 Special Judge Problem Description A little girl loves programming competition very much. Recently, she has f

poj_1222_高斯消元

第一次学习使用高斯消元,将灯板化为线性方程组,进行求解. /*######################################################################### # File Name: poj_1222.cpp # Author: CaoLei # Created Time: 2015/7/20 15:48:04 ###################################################################

HDU 4870 Rating（高斯消元)

HDU 4870 Rating 题目链接 题意:一个人注册两个账号,初始rating都是0,他每次拿低分的那个号去打比赛,赢了加50分,输了扣100分,胜率为p,他会打到直到一个号有1000分为止,问比赛场次的期望 思路:f(i, j)表示i >= j,第一个号i分,第二个号j分时候,达到目标的期望,那么可以列出转移为f(i, j) = p f(i', j') + (1 - p) f(i'' + j'') + 1 f(i', j')对应的是赢了加分的状态,f(i'', j'')对应输的扣分的状态

【BZOJ 4171】 4171: Rhl的游戏 （高斯消元）

4171: Rhl的游戏 Time Limit: 20 Sec  Memory Limit: 128 MBSubmit: 74  Solved: 33[Submit][Status][Discuss] Description RHL最近迷上一个小游戏:Flip it.游戏的规则很简单,在一个N*M的格子上,有一些格子是黑色,有一些是白色 .每选择一个格子按一次,格子以及周围边相邻的格子都会翻转颜色(边相邻指至少与该格子有一条公共边的格子 ),黑变白,白变黑.RHL希望把所有格子都变成白色的.不幸

POJ 1830 开关问题 高斯消元，自由变量个数

http://poj.org/problem?id=1830 如果开关s1操作一次,则会有s1(记住自己也会变).和s1连接的开关都会做一次操作. 那么设矩阵a[i][j]表示按下了开关j,开关i会被操作一次,记得a[i][i] = 1是必须的,因为开关i操作一次,本身肯定会变化一次. 所以有n个开关,就有n条方程, 每个开关的操作次数总和是:a[i][1] + a[i][2] + ... + a[i][n] 那么sum % 2就代表它的状态,需要和(en[i] - be[i] + 2) % 2

BZOJ 3105: [cqoi2013]新Nim游戏 [高斯消元XOR 线性基]

以后我也要用传送门! 题意:一些数,选择一个权值最大的异或和不为0的集合 终于有点明白线性基是什么了...等会再整理 求一个权值最大的线性无关子集 线性无关子集满足拟阵的性质,贪心选择权值最大的,用高斯消元判断是否和已选择的线性相关 每一位记录pivot[i]为i用到的行 枚举要加入的数字的每一个二进制为1的位,如果有pivot[i]那么就异或一下(消元),否则pivot[i]=这个数并退出 如果最后异或成0了就说明线性相关... #include <iostream> #include &l

[bzoj1013][JSOI2008]球形空间产生器sphere-题解[高斯消元]

Description 有一个球形空间产生器能够在n维空间中产生一个坚硬的球体.现在,你被困在了这个n维球体中,你只知道球面上n+1个点的坐标,你需要以最快的速度确定这个n维球体的球心坐标,以便于摧毁这个球形空间产生器. Input 第一行是一个整数n(1<=N=10).接下来的n+1行,每行有n个实数,表示球面上一点的n维坐标.每一个实数精确到小数点后6位,且其绝对值都不超过20000. Output 有且只有一行,依次给出球心的n维坐标(n个实数),两个实数之间用一个空格隔开.每个实数精确到

[spoj104][Highways] (生成树计数+矩阵树定理+高斯消元)

In some countries building highways takes a lot of time... Maybe that's because there are many possiblities to construct a network of highways and engineers can't make up their minds which one to choose. Suppose we have a list of cities that can be c

UVA 10828 Back to Kernighan-Ritchie(高斯消元)

高斯消元求概率 对于非起点,期望x[i] = ∑x[j] / deg[j] #include<cstdio> #include<iostream> #include<cstdlib> #include<cstring> #include<string> #include<algorithm> #include<map> #include<queue> #include<vector> #includ