1. El mejor momento para comprar y vender acciones
121. El mejor momento para comprar y vender acciones
ideas que se me ocurren
Inexplicablemente, el código lo escribí yo mismo: De hecho, está atravesando para encontrar el valor mínimo.Esta matriz dp indica el precio de venta máximo, que en realidad no tiene sentido. Eso es encontrar los valores máximos y mínimos si la diferencia
class Solution {
public:
int maxProfit(vector<int>& prices) {
vector<int> dp(prices.size(), 0);
for (int i = 1; i < prices.size(); i++)
{
if (prices[i] > prices[i - 1])
dp[i] = dp[i - 1] + (prices[i] - prices[i - 1]);
else
dp[i] = dp[i - 1];
}
return dp[prices.size() - 1];
}
};programación dinámica
1. Primero aclare el significado de la matriz dp: dp[i][0] es la cantidad máxima de acciones que se tienen actualmente, y dp[i][1] es la cantidad máxima de acciones que no se tienen actualmente. La tenencia aquí no significa comprar las acciones en la posición i, sino el estado de tenencia de las acciones. La fuente de tenencia de las acciones puede ser comprar i ahora o heredar las acciones que se tienen de i-1, por lo tanto, no tenga acciones A en realidad. significa que no hay stock, puede ser uno que no se haya comprado antes, o uno que se haya comprado antes de venderlo ahora.
2. Inicialización: dp[0][0]=-prices[0] se refiere a la compra de acciones en la posición 0, que cuesta price[0], y toma un valor negativo para representar el costo, dp[0][1] =0 se refiere a Si no hay compra en la posición 0, entonces solo hay un resultado, es decir, no se compra nada, y es directamente igual a 0
3. La condición de la matriz dp: dp[i][0] es la cantidad máxima de acciones que se tienen actualmente. Dado que solo se puede comprar una vez, en realidad solo hay dos opciones, que pueden ser las dp[i] heredadas previamente -1][0] ; También puede ser -prices[i] comprado en el momento. dp[i][1] actualmente no tiene la cantidad máxima de existencias, y debido a que solo se puede vender una vez, solo hay dos estados, uno se hereda del estado dp[i-1][1] que no mantener acciones la última vez; también puede ser la acción dp[i-1][0]+prices[i] que se compró la última vez. Tome el valor máximo de ambos para obtener lo que necesita y finalmente devuelva dp[prices.size()-1][1], porque el efectivo que no tiene acciones debe ser mayor que el efectivo que tiene acciones.
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.size()==1)
return 0;
vector<vector<int>> dp(prices.size(),{0,0});
dp[0][0]=-prices[0];
dp[0][1]=0;
for(int i=1;i<prices.size();i++)
{
dp[i][0]=max(dp[i-1][0],-prices[i]);
dp[i][1]=max(dp[i-1][0]+prices[i],dp[i-1][1]);
}
return dp[prices.size()-1][1];
}
};2. El mejor momento para comprar y vender acciones II
122. Mejor momento para comprar y vender acciones II
ideas que se me ocurren
De hecho, está diseñado así para encontrar la tendencia alcista actual para el frente, por lo que puede usarse como una oportunidad para vender, por lo que el enfoque está en encontrar la forma de la diferencia de altura.
class Solution {
public:
int maxProfit(vector<int>& prices) {
vector<int> dp(prices.size(),0);
for(int i=1;i<prices.size();i++)
{
if(prices[i]>prices[i-1])
dp[i]=dp[i-1]+(prices[i]-prices[i-1]);
else
dp[i]=dp[i-1];
}
return dp[prices.size()-1];
}
};programación dinámica
La diferencia con la pregunta anterior es que esta transacción no es única, por lo que en realidad necesitamos cambiar las condiciones de la matriz dp. Hay dos fuentes de la cantidad máxima de existencias actualmente en poder de dp[i][0], una es la cantidad máxima de no existencias en poder la última vez más las acciones compradas actualmente dp[i-1][1]-; la otra es la cantidad máxima dp[i-1][0] de las acciones mantenidas la última vez, que es dp[i][0]=max(dp[i-1][1]-prices[i],dp[ i -1][0]). Entonces, la fuente de la cantidad máxima para dp[i][1] actualmente no tiene existencias permanece sin cambios, porque la venta está determinada por la compra, y la compra solo se puede hacer una vez, pero la cantidad de veces que se compra es grande, correspondiente También hay más ventas, por lo que no hay necesidad de cambiar la operación de venta.
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.size()==1)
return 0;
vector<vector<int>> dp(prices.size(),{0,0});
dp[0][0]=-prices[0];
dp[0][1]=0;
for(int i=1;i<prices.size();i++)
{
dp[i][0]=max(dp[i-1][1]-prices[i],dp[i-1][0]);
dp[i][1]=max(dp[i-1][0]+prices[i],dp[i-1][1]);
}
return dp[prices.size()-1][1];
}
};