Le meilleur moment pour acheter et vendre des actions I
Description du problème
Étant donné les prix d'un tableau, les prix de son i-ème élément [i] représentent le prix d'un stock donné le i-ème jour.
Vous ne pouvez choisir d'acheter cette action qu'un certain jour et choisir de vendre l'action un autre jour dans le futur. Concevez un algorithme pour calculer le profit maximum que vous pouvez obtenir.
Renvoyez le profit maximum que vous pouvez tirer de cette transaction. Si vous ne pouvez pas faire de profit, renvoyez 0.
Exemple 1:
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
Exemple 2:
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
Idées de résolution de problèmes:
Méthode de la force brute:
Nous devons trouver la différence maximale (c'est-à-dire le profit maximum) entre deux nombres dans un tableau donné. De plus, le deuxième nombre (prix de vente) doit être supérieur au premier nombre (prix d'achat).
Formellement, pour chaque groupe de ii et jj (où j> ij> i) nous devons trouver \ max (prix [j] -prices [i]) max (prix [j] −prices [i]).
class Solution {
public int maxProfit(int[] prices) {
int tempProfit []=new int[prices.length];
if(prices.length==0){
return 0;
}
tempProfit[0]=0;
int maxPro=0;
for(int i=1;i<prices.length;i++){
int temp;
for(int j=i-1;j>=0;j--){
if(prices[i]>prices[j]){
temp=prices[i]-prices[j]+tempProfit[j];
if(temp>tempProfit[i]){
tempProfit[i]=temp;
}
}
}
if(tempProfit[i]>maxPro){
maxPro=tempProfit[i];
}
}
return maxPro;
}
}
Comment allez-vous:
Supposons que le tableau donné soit: [7, 1, 5, 3, 6, 4]
Si nous dessinons les nombres dans le tableau donné sur le graphique, nous obtiendrons:
Supposons que nous achetons des actions par nous-mêmes. Au fil du temps, chaque jour, nous pouvons choisir de vendre ou non l'action. Alors, supposons que le i jour, si nous voulons vendre des actions aujourd'hui, combien d'argent pouvons-nous gagner?
Évidemment, si nous achetions et vendions vraiment des actions, nous penserions certainement: ce serait formidable si j'achetais les actions au plus bas de l'histoire! Dans le titre, il suffit d'enregistrer un prix minimum historique avec une variable et nous pouvons supposer que notre action a été achetée ce jour-là. Ensuite, le profit que nous pouvons tirer de la vente d'actions le i jour est le prix [i] -minprice.
Par conséquent, nous n'avons besoin de parcourir le tableau des prix qu'une seule fois, d'enregistrer le point le plus bas de l'histoire, puis de considérer cette question tous les jours: si j'ai acheté au point le plus bas avant cela, combien d'argent puis-je gagner en vendant aujourd'hui? Lorsque tous les jours sont considérés, nous obtenons la meilleure réponse.
Si vous prévoyez de vendre des actions le i-ième jour, la différence de profit maximum doit être le point le plus bas entre [0, i-1] pour acheter; parcourez donc le tableau et trouvez la différence maximale pour chaque opportunité de vente à tour de rôle, Et puis prenez-en la valeur maximale .
class Solution {
public int maxProfit(int[] prices) {
int minPrice=prices[0];
int n=prices.length;
int res=0;
for(int i=0;i<n;i++){
//记录这之前的最低价格
if(minPrice>prices[i]){
minPrice=prices[i];
}else{
//如果大于最低价格，就尝试着卖出，并假设最低点买入
res=Math.max(res,prices[i]-minPrice);
}
}
return res;
}
}
Le meilleur moment pour acheter et vendre des actions II
Description du problème
Étant donné un tableau, son i-ème élément est le prix d'une action donnée le i-ème jour.
Concevez un algorithme pour calculer le profit maximum que vous pouvez obtenir. Vous pouvez effectuer autant de transactions que possible (acheter et vendre une action plusieurs fois).
Remarque: vous ne pouvez pas participer à plusieurs transactions en même temps (vous devez vendre les actions précédentes avant d'acheter à nouveau).
Exemple 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
Exemple 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
Exemple 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
Idées de résolution de problèmes: cupides
Il convient de noter que l'algorithme glouton ne peut être utilisé que pour calculer le profit maximum et que le processus de calcul n'est pas le processus de trading réel .
Puisqu'il n'y a pas de restrictions sur l'achat d'actions, tout le problème équivaut à trouver x intervalles disjoints (li, ri),
où li signifie acheter le jour li, ri signifie acheter le jour ri,
et nous remarquons que (li, ri ] La valeur de contribution a [ri] -a [li] dans cet intervalle est en fait équivalente à (li, li + 1), (li + 1, li + 2), ..., (ri-1, ri)
Par conséquent , le problème peut être simplifié pour trouver x intervalles (li, li + 1) de longueur 1 pour maximiser la valeur totale. Du
point de vue gourmand, nous pouvons maximiser la réponse chaque fois que nous choisissons un intervalle dont la contribution est supérieure à 0, donc la réponse finale est
Où n est la longueur du tableau.
Prenons l'exemple du titre [1,2,3,4,5], la longueur du tableau est n = 5, car il y a un [i]> a [i pour tous 1 <i <n −1], donc la réponse est.
Mais le processus de transaction réel n'est pas d'acheter 4 fois et de vendre 4 fois, mais d'acheter le 11ème jour et de vendre le 55ème jour.
class Solution {
public int maxProfit(int[] prices) {
int profit=0;
int n=prices.length;
for(int i=1;i<n;i++){
if(prices[i]>prices[i-1]){
profit+=prices[i]-prices[i-1];
}
}
return profit;
}
}