poj-2151

最新推荐文章于 2018-09-30 19:57:00 发布

fyfcauc

最新推荐文章于 2018-09-30 19:57:00 发布

阅读量511

点赞数

分类专栏： POJ 文章标签： poj

本文链接：https://blog.csdn.net/fyfcauc/article/details/32981361

版权

POJ 专栏收录该内容

233 篇文章 0 订阅

订阅专栏

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

double DP[50][50];

double P[1010];
double PSolveN[1010][50];
double PSolveNAcc[1010][50];

void getMENP(double * array, int N, int length, int M, double (* PSolveN)[50] ) // MENP: more/equal N questions probability
{
   // printf("N %d length %d M %d\n", N, length, M);
   // if (N > length) {
   //    return 0;
   // }
   memset(DP, 0, sizeof(DP));


   int i = 0;
   for (; i <= length; i++) {
       int j = 0;
       for (; j<=M; j++) {
           if (i < j) { // imposible
               DP[i][j] = 0;
           } else if (i == 0 && j == 0) { // must be
               DP[i][j] = 1;
           } else if (j == 0) {
               DP[i][j] = (1-array[i-1]) * DP[i-1][j];
           } else {
               double p1 = DP[i-1][j];
               double p2 = DP[i-1][j-1];
               double solveThisP = p2*array[i-1];
               double noSolveThisP = p1*(1- array[i-1]);

               DP[i][j] = solveThisP + noSolveThisP;
               // printf("%d %d %lf\n", i, j, DP[i][j]);
           }
       }
   }

   for (int j = 0; j <=length; j++) {
       (*PSolveN)[j] = DP[length][j];
   }
}

int main() {
   int M;
   int T;
   int N;
   while(1){
       memset(P, 0, sizeof(P));
       memset(PSolveN, 0, sizeof(PSolveN));
       memset(PSolveNAcc, 0, sizeof(PSolveNAcc));

       double res = 0;
       double AllME1P = 1;
       double AllLNME1 = 1;
       scanf("%d %d %d", &T, &M, &N);
       if (0 == M &&
           0 == T &&
           0 == N) {
           return 0;
       }

       if (T < N) {
           printf("%.3f\n", 0.0);
           continue;
       }

       int i = 0;
       for (; i < M; i++) {
           int j = 0;
           for (; j < T; j++) {
               scanf("%lf", P+j);
           }
           getMENP(P, N, T, M, PSolveN + i);
       }

       for (i = 0; i< M; i++) {
           int j = 0;
           for (; j <= T; j++) {
               if (0 == j) {
                   PSolveNAcc[i][j] = PSolveN[i][j];
               } else {
                   PSolveNAcc[i][j] = PSolveN[i][j] + PSolveNAcc[i][j-1];
               }
               // printf("%d %d %.3lf ", i ,j, PSolveNAcc[i][j]);
           }
           // printf("\n");
       }

       for (i = 0; i < M; i++) {
           AllME1P *= (1-PSolveN[i][0]);
       }

       for (i = 0; i < M; i++) {
           AllLNME1 *= (PSolveNAcc[i][N-1] - PSolveNAcc[i][0]);
       }

       res = AllME1P - AllLNME1;
       // printf("%f %f\n", AllME1P, AllLNME1);

       printf("%.3f\n", res);
   }

}

G++ 1188K 79MS.

悲催一题，　因为RE卡了半天，　后来才发现，自己把　Ｔ（队伍数量　1~1000）和Ｍ（题目数量 1~ 30）　搞混了，这样必然后面数组访问会出错，

当时发现了这个问题，输入时搞颠倒了，但是没有接着把用到的数组的尺寸调换，妈的，真是2B的超出了自己的想象，　后面为了排查RE,直接把poj当成调试器用了...

悲剧的是，最后还是靠直接看代码发现的这个问题.... 唉，　发现现在自己现在思维有问题，写完code，就懒得再仔细的检查，直接上数据，有错了再用数据debug,

诚然，　很多算法题第一遍就就写对的难度还是蛮高的，但是不能因为这个就完全指望测试，测试终究有自己的覆盖范围(poj　很多AC的最后其实还是有问题的)。

以后必须要强化审阅code，就像现在工作中一样，不能指望别人code rebview给你发现问题，一个合格的程序员，必须在自己脑子里对自己的code有最清晰和肯定的认识.

唉，其实我现在有时候就是code AC了，　还是没底，一定要消除这个问题了.

回到题本身, 这道题我在刷题指南里看到，被分到了hash，其实应该不是，　硬要归，就是概率论+DP.

DP在这里的作用就是求出了　某一队在整场比赛解出k道题的概率，　一开始还想着按照传统数学思路来，后来发现是作死，看了discuss以后一想，确实DP可以用在这里:

以前解DP题，大都是求最优解，及每个解之间是要比较的，但这只是DP的一个种类，有些DP,　不是要求最优解，而是子问题解之间的一种组合。

对某一队(解题概率数组P)来说，　定义D[i][j]为该队在前i道题中解出j道题的概率, 那么，就有: