El beneficio máximo (leetcode 122) p64 realizar un número ilimitado de operaciones con acciones

A: las ideas de resolución de problemas

Método uno: constantemente en busca de la acción mínima y máxima, y ​​la más pequeña es la pena el tiempo para comprar y vender en el máximo de la pena el tiempo. Tiempo: O (n), el espacio: O (1)

Segundo método: codicioso, sólo un día después de que el valor es mayor que el valor del día anterior, a continuación, ser objeto de comercio. Tiempo: O (n), el espacio: O (n)

Dos: ejemplos de código completo (C ++ versión y la versión Java)

Método uno C ++:

clase de soluciones {
 público :
     int maxProfit (vector < int > & precios) 
    { 
        si (prices.size () == 0 ) de retorno  0 ;
        int n = prices.size ();
        int i = 0 , comprar = 0 , venta = 0 , maxProfit = 0 ; 

        mientras que (i <n - 1 ) 
        { 
            mientras que (i <n - 1 && precios [i + 1 ] <= precios [i]) i ++ ; 
            comprar =precios [i];
            mientras que (i <n - 1 && precios [i + 1 ]> = precios [i]) i ++ ; 
            venta = precios [i]; 

            maxProfit + = (vender- compra); 
        } 

        Devolver maxProfit; 
    } 
};

Un método de Java:

clase de soluciones {
     pública  int maxProfit ( int [] precios) 
    { 
           si (los precios == nula || prices.length == 0 ) volver  0 ;
           int maxProfit = 0 , i = 0 , compra = 0 , venta = 0 ;
           int n = prices.length; 
           
           mientras que (i <n- 1 ) 
           { 
               mientras que (i <n- 1 && precios [i + 1 ] <= precios [i]) i ++ ; 
               comprar =precios [i];
               mientras que (i <n- 1 && precios [i + 1 ]> = precios [i]) i ++ ; 
               venta = precios [i]; 
               
               maxProfit + = (vender- compra); 
           } 
           
           Devolver maxProfit; 
    } 
}

Segundo método C ++:

clase de soluciones {
 público :
     int maxProfit (vector < int > & precios) 
    { 
        si (prices.size () == 0 ) de retorno  0 ;
        int maxProfit = 0 ; 

        para ( int i = 1 ; i <prices.size (); i ++ ) 
        { 
            si (precios [i]> precios [i - 1 ]) 
                maxProfit + = (precios [i] -precios [i- 1 ]); 
        } 

        Devolver maxProfit; 
    } 
};

Segundo método de Java:

clase de soluciones {
     pública  int maxProfit ( int [] precios) 
    { 
           si (los precios == nula || prices.length == 0 ) volver  0 ;
           int maxProfit = 0 ; 
           
           para ( int i = 1 ; i <prices.length; i ++ ) 
           { 
               si (precios [i]> precios [i- 1 ]) 
                   maxProfit + = (precios [i] -precios [i- 1 ]); 
           } 

           Devolver maxProfit; 
    } 
}