2014多校第一场J题 || HDU 4870 Rating（DP || 高斯消元）

题目链接

题意 ：小女孩注册了两个比赛的帐号，初始分值都为0，每做一次比赛如果排名在前两百名，rating涨50，否则降100，告诉你她每次比赛在前两百名的概率p，如果她每次做题都用两个账号中分数低的那个去做，问她最终有一个账号达到1000分需要做的比赛的次数的期望值。

思路 ：可以直接用公式推出来用DP做，也可以列出210个方程组用高斯消元去做。

（1）DP1：离散化。因为50，100，1000都是50的倍数，所以就看作1，2，20。这样做起来比较方便。

定义dp[i]为从 i 分数到达i+1分的期望，状态转移方程：

dp[i] = p+(1-p)*(1+dp[i-2]+dp[i-1]+dp[i]); 在前两百名里增加一分，当不在前两百名里的时候，扣两分，要回到 i+1 分就是1+dp[i-2]+dp[i-1]+dp[i].

mp[i][i]表示两个账号都从0分涨到 i 分的期望，所以mp[i+1][i] = mp[i][i]+dp[i], mp[i+1][i+1] = mp[i+1][i]+dp[i];

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>

 using namespace std ;

 double dp[],mp[][] ;

 int main()
 {
     double p ;
     while(scanf("%lf",&p) != EOF)
     {
         dp[] =  / p ;
         dp[] =  / p / p ;
         for(int i =  ; i <  ; i++)
             dp[i] =  + (-p)*(dp[i-]+dp[i-]+)/p ;
         for(int i =  ; i <  ; i++)
         {
             mp[i+][i] = mp[i][i]+dp[i] ;
             mp[i+][i+] = mp[i+][i] + dp[i] ;
         }
         printf("%.6lf\n",mp[][]) ;
     }
     return  ;
 }

（2）DP2：在网上看了一个线性的复杂度的，here，推公式很厉害。

先考虑一场比赛的情况，定义dp[k]为当前为k分，要达到20分时的期望回合数。

那么显然有 dp[0]=1+p*dp[1]+q*dp[0] 化简得 dp[0]=1/p+dp[1]

dp[1]=1+p*dp[2]+q*dp[0] 化简得 dp[0]=1/p+1/p^2+dp[2]

我们令  dp[0]=t[k]+dp[k] 那么t[k]就表示由0状态到达k状态所需的期望回合数。如果是要到达20分就是t[20]。

得到dp[k]=1+p*dp[k+1]+(1-p)*dp[k-2]

将dp[k]=dp[0]-t[k]和dp[k-2]=dp[0]-t[k-2]代入得 ：

dp[0]=1/p+t[k]/p-(1-p)/p*t[k-2]+dp[k+1]

然后代入dp[k+1]=dp[0]-t[k+1]得：

t[k+1]＝1/p+1/p*t[k]-(1-p)/p*t[k-2]

边界条件是  t[0]=0,t[1]=1/p,t[2]=1/p+1/p^2

知道这些就可以递推出所有需要的t[k]了。

因为是两个账号，所以变化一定是（0，0）——>（1，0）——>（1，1）——>……（19，18）——>（19，19）——>（20，19）

(0,0)->(0,1)需要的期望回合数是t[1]-t[0].  (0,1)->(1,1)需要的期望回合数是 t[1]-t[0]

(1,1)->(1,2)需要的期望回合数是t[2]-t[1].  (1,2)->(2,2)需要的期望回合数是 t[2]-t[1].

....

(18,18)->(18,19)需要的期望回合数是t[19]-t[18]. (18,19)->(19,19)需要的期望回合数是t[19]-t[18].

(19,19)->(19,20)需要的期望回合数是t[20]-t[19]。

全部加起来的结果就是t[19]*2+t[20]-t[19].

所以最后的复杂度可以是线性的，而且理论上对于k个账号也是适用的，这样就可以避开了高斯消元的做法了。

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>

 using namespace std ;

 double d[] ;

 int main()
 {
     double p ;
     while(scanf("%lf",&p) != EOF)
     {
         d[] =  ;
         d[] =  / p ;
         d[] =  / p +  / (p * p) ;
         for(int i =  ; i <=  ; i++)
             d[i] =  / p + d[i-] / p +(p - )*d[i-] / p ;
         printf("%.6lf\n",d[] + d[]) ;
     }
     return  ;
 }

（3）高斯消元：

官方题解：

令(x, y)表示高分为x，低分为y的状态（x >= y），E(x, y)表示从(x, y)到达(1000, ?)的比赛场数期望。容易得到E(x, y) = P * E(x1, y1) + (1 - P) * E(x2, y2) + 1，其中，(x1, y1)表示rating上升后的状态，（x2, y2）表示rating下降后的状态。每50分一个状态，共有210个状态（21*20/2）。

移项后得E(x, y) -P * E(x1, y1) - (1 - P) * E(x2, y2) = 1，共有210个这样的方程组。高斯消元求解，x[0]代表E(0,0)这个状态到目标状态的期望。

注意精度。

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <math.h>

 using namespace std ;

 const double eps = 1e- ;

 double p,mp[][] ;
 int vis[][] ;

 double Gauss()
 {
     for(int i =  ; i <  ; i++)
     {
         int k ;
         for(k = i ; k <  ; k++)
             if(fabs(mp[k][i]) > eps) break ;
         for(int j =  ; j <=  ; j++)
             swap(mp[i][j],mp[k][j]) ;
         for(int j =  ; j <  ; j++)
         {
             if(i != j)
             {
                 if(fabs(mp[j][i]) > eps)
                 {
                     double s = mp[j][i] / mp[i][i] ;
                     for(int k = i ; k <=  ; k++)
                         mp[j][k] -= mp[i][k] * s ;
                 }
             }
         }
     }
     return mp[][]/mp[][]  ;
 }

 void pro()
 {
     for(int i =  ; i <  ; i++)
     {
         for(int j =  ; j < i ; j ++)
         {
             int u = vis[i][j] ;
             mp[u][u] =  ;
             mp[u][] =  ;
             int v = vis[i][max(,j-)] ;
             mp[u][v] -= (-p) ;
             v = vis[i][j+] ;
             mp[u][v] -= p ;
         }
         int u = vis[i][i] ;
         mp[u][u] =  ;
         mp[u][] =  ;
         int v = vis[i][max(,i-)] ;
         mp[u][v] -= (-p) ;
         v = vis[i+][i] ;
         mp[u][v] -= p ;
     }
 }

 int main()
 {

     while(scanf("%lf",&p) != EOF)
     {
         int cnt =  ;
         memset(vis,-,sizeof(vis)) ;
         for(int i =  ; i <   ; i++)
             for(int j =  ; j <= i ; j++)
                 vis[i][j] = cnt ++ ;
         memset(mp,,sizeof(mp)) ;
         pro() ;
         printf("%.6lf\n",Gauss()) ;
     }
     return  ;
 }