#define FOLD__SCOPE                                                          
                                                                             
#ifdef  FOLD__SCOPE  /// includes                                            
                                                                             
#include <set>                                                               
#include <vector>                                                            
#include <cmath>                                                             
#include <fstream>                                                           
                                                                             
#endif                                                                       
#ifdef  FOLD__SCOPE  /// typedefs                                            
                                                                             
typedef  ::std::size_t  stsz;                                                
typedef  double         stfp;                                                
                                                                             
stsz  const max_n = 25;                                                      
stsz  const max_x = 1 + max_n;                                               
                                                                             
typedef  stfp  arfp[max_x];                                                  
typedef  stfp  smfp[max_x][max_x];                                           
                                                                             
typedef  ::std::ifstream  stis;                                              
typedef  ::std::ofstream  stos;                                              
                                                                             
#endif                                                                       
#ifdef  FOLD__SCOPE  /// dezastru                                            
                                                                             
stfp                                                                         
dezastru                                                                     
(                                                                            
  arfp  P                                                                    
, stsz  N                                                                    
, stsz  K                                                                    
)                                                                            
{                                                                            
  smfp  D;                                                                   
                                                                             
  stsz  n = 1;                                                               
  stsz  k = 0;                                                               
  stfp  s = 0;                                                               
                                                                             
                                                                             
  for (n = 1; N >= n; ++ n )                                                 
  {                                                                          
    s       = s + P[n];                                                      
    D[1][n] = s / n;                                                         
  }                                                                          
                                                                             
  for (k = 2; K >= k; ++ k )                                                 
  {                                                                          
    D[k][k] = P[k] * D[k-1][k-1];                                            
                                                                             
    for ( n = 1+k; N >= n; ++ n  )                                           
    {                                                                        
      D[k][n] = (k * P[n] * D[k-1][n-1] + (n - k) * D[k][n-1]) / n;          
    }                                                                        
                                                                             
  }                                                                          
                                                                             
  return D[K][N];                                                            
                                                                             
}                                                                            
                                                                             
#endif                                                                       
#ifdef  FOLD__SCOPE  /// demo                                                
                                                                             
bool                                                                         
demo                                                                         
()                                                                           
{                                                                            
  #ifdef  FOLD__SCOPE  /// state                                             
                                                                             
    /// Program state.                                                       
    stsz  N = 0;                                                             
    stsz  K = 0;                                                             
    arfp  P;                                                                 
    stfp  V = 0;                                                             
                                                                             
  #endif                                                                     
  if (true) {          /// read                                              
                                                                             
    bool  ok = false;                                                        
                                                                             
    stis  is ("dezastru.in");                                                
                                                                             
    arfp  p;                                                                 
    stsz  n = 0;                                                             
    stsz  k = 0;                                                             
                                                                             
    is >> n;                                                                 
    is >> k;                                                                 
                                                                             
    ok = ( (1 <= k) && (k <= n) && (n <= max_n)  );                          
                                                                             
    if ( ! ok  )                                                             
    {                                                                        
      /// Invalid input.                                                     
      return false;                                                          
    }                                                                        
                                                                             
    stsz  i = 0;                                                             
    stfp  v = 0;                                                             
                                                                             
    for ( i = 1; n >= i; ++ i  )                                             
    {                                                                        
      is >> v;                                                               
                                                                             
      ok = ((0 <= v) && (v <= 1));                                           
                                                                             
      if ( ! ok  )                                                           
      {                                                                      
        /// Invalid input.                                                   
        return false;                                                        
      }                                                                      
                                                                             
      p[i] = v;                                                              
                                                                             
    }                                                                        
                                                                             
    /// So far so good.                                                      
                                                                             
    N = n;                                                                   
    K = k;                                                                   
                                                                             
    for ( i = 1; n >= i; ++ i  )                                             
    {                                                                        
      P[i] = p[i];                                                           
    }                                                                        
                                                                             
  }                                                                          
  if (true) {          /// solve                                             
                                                                             
    stfp  const v = dezastru(P, N, K);                                       
                                                                             
    V = v;                                                                   
                                                                             
  }                                                                          
  if (true) {          /// write                                             
                                                                             
    /// Write solution.                                                      
    stos  os("dezastru.out");                                                
    os.precision(15);                                                        
    os << V << '\n';                                                         
                                                                             
  }                                                                          
                                                                             
  return true;                                                               
                                                                             
}                                                                            
                                                                             
#endif                                                                       
#ifdef  FOLD__SCOPE  /// main                                                
                                                                             
int                                                                          
main                                                                         
()                                                                           
{                                                                            
  int  status = 3;                                                           
                                                                             
  try                                                                        
  {                                                                          
    bool  const ok = demo();                                                 
    status = ( ok ? 0 : 1 );                                                 
  }                                                                          
  catch ( ... )                                                              
  {                                                                          
    status = 2;                                                              
  }                                                                          
                                                                             
  return status;                                                             
}                                                                            
                                                                             
#endif