leetCode 122. Meilleur moment pour acheter et vendre des actions II Algorithme gourmand

122. Le meilleur moment pour acheter et vendre des actions II - LeetCode

Vous recevez un tableau d’entiers  prices qui  prices[i] représente le prix d’une certaine action au  i premier jour.

Chaque jour, vous pouvez décider d' acheter et/ou de vendre des actions . Vous ne pouvez détenir  qu'une  seule  action à la fois  . Vous pouvez également acheter d'abord, puis  vendre le même jour . 

Renvoyez  le  profit maximum que vous pouvez réaliser   .

Exemple 1:

Entrée : prix = [7,1,5,3,6,4]
 Sortie : 7
 Explication : Acheter le jour 2 (cours de l'action = 1) et vendre le jour 3 (cours de l'action = 5) Out, le profit de cette transaction = 5 - 1 = 4. 
     Par la suite, si vous achetez le 4ème jour (cours de l'action = 3) et vendez le 5ème jour (cours de l'action = 6), le bénéfice de cette transaction = 6 - 3 = 3. 
     Le bénéfice total est de 4 + 3 = 7.

Exemple 2 :

Entrée : prix = [1,2,3,4,5]
 Sortie : 4
 Explication : Acheter le jour 1 (cours de l'action = 1), vendre le jour 5 (cours de l'action = 5), Le bénéfice de cette transaction = 5 - 1 = 4. 
     Le bénéfice total est de 4.

Exemple 3 :

Entrée : prix = [7,6,4,3,1]
 Sortie : 0
 Explication : Dans ce cas, la transaction ne peut pas obtenir de profit positif, donc le profit maximum peut être obtenu en ne participant pas à la transaction, et le profit maximum est 0.

>>Idées et analyses

  • ① Un seul stock
  • ② Actuellement, il n'y a que des opérations d' achat ou de vente d'actions
  • ③ Si vous souhaitez réaliser un bénéfice, au moins deux jours doivent constituer une unité de négociation.

1. Algorithme gourmand

Prenons d'abord un exemple : par exemple, si vous achetez le 1er jour (cours de l'action = 1) et vendez le 3ème jour (cours de l'action = 10), le bénéfice de cette transaction = 10 - 1 = 9. Le profit est : prix[3] - prix[1]

Équivalent à (prix[3] - prix[2]) + (prix[2] - prix[1]) 

A cette époque, le profit est décomposé en dimensions unitaires journalières , au lieu de le considérer dans son ensemble du jour 1 au jour 3 !

  • Optimale locale : collecter des bénéfices positifs quotidiens
  • Global Optimum : Trouver le profit maximum

L'optimalité locale peut conduire à l'optimalité globale. Si vous ne trouvez pas de contre-exemple, essayez d'être gourmand !

Remarque : Il n'y a pas de profit le premier jour , et il y aura un profit au moins le deuxième jour , donc la séquence de profit est d'un jour de moins que la séquence de stock !

D'après la figure ci-dessus, on peut voir que seuls les bénéfices quotidiens sont collectés.La fourchette de collecte des bénéfices positifs est la fourchette de négociation des actions , vous n'avez donc qu'à prêter attention au bénéfice final et n'avez pas besoin d'enregistrer la fourchette. Et c’est en collectant uniquement des bénéfices positifs que la cupidité entre en jeu !

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 1; i < prices.size(); i++) {
            result += max(prices[i] - prices[i - 1], 0);
        }
        return result;
    }
};
  • Complexité temporelle : O(n)
  • Complexité spatiale : O(1)

2. Programmation dynamique

class Solution {
public:
    // 动态规划 + 状态转移 时间复杂度:O(n) 空间复杂度:O(n)
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(len,vector<int>(2,0));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for(int i = 1;i < len; i++) {
            dp[i][0] = max(dp[i-1][0],dp[i-1][1] - prices[i]);
            dp[i][1] = max(dp[i-1][1],dp[i-1][0] + prices[i]);
        }
        return dp[len-1][1];
    }
    // 动态规划 + 状态转移 时间复杂度:O(n) 空间复杂度:O(1)
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2,vector<int>(2));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for(int i = 1;i < len; i++) {
            dp[i % 2][0] = max(dp[(i-1) % 2][0],dp[(i-1) % 2][1] - prices[i]);
            dp[i % 2][1] = max(dp[(i-1) % 2][1],dp[(i-1) % 2][0] + prices[i]);
        }
        return dp[(len-1) % 2][1];
    }
};

Mes articles précédents expliquent en détail la programmation dynamique de cette question :  leetCode 122. Le meilleur moment pour acheter et vendre des actions II programmation dynamique + transfert d'état + compression d'état_Heheda( ̄▽ ̄)"'s blog-CSDN blog https:// icon-default.png?t=N7T8blog .csdn.net/weixin_41987016/article/details/133432053?spm=1001.2014.3001.5501

Articles et vidéos de référence et recommandés :

Les algorithmes gourmands peuvent aussi résoudre le problème des stocks ! LeetCode : 122. Le meilleur moment pour acheter et vendre des actions II_bilibili_bilibili

Enregistrement aléatoire de code (programmercarl.com)

Captures d'écran de classe de Code Caprice :

Je suppose que tu aimes

Origine blog.csdn.net/weixin_41987016/article/details/133500827
conseillé
Classement