买卖股票的最佳时机（暴力/动态规划）

 该题最容易想到的方法应该是暴力了（不过对于该题的数据而言会超时）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = (int)prices.size(), ans = 0;
        for (int i = 0; i < n; ++i){
            for (int j = i + 1; j < n; ++j) {
                ans = max(ans, prices[j] - prices[i]);//直接枚举所有情况同时找最大利润即可
            }
        }
        return ans;
    }
};

 该题明显也属于可以使用动态规划的题目，请读者先阅读下面这个代码

class Solution {
public://混乱DP+暴力
    int maxProfit(vector<int>& prices) {
        int n=prices.size(),MAXN=-1,sign=0;
        for(int j=0;j<n-1;j++)
        {
            if(prices[j]<prices[j+1])//这里循环的作用是判断是否该数组为 降序 
            {
                sign=1;
                break;
            }
        }        
        if(!sign)//如果该数组是降序就直接return 0
        {
            return 0;
        }
        vector<vector<int> >ev(n+1,vector<int>(n+1));//定义ev[i][j]为第i买入到第j天卖出收入
        int i=0;
        while(i!=n)
        {
            ev[i][i]=-1;//初始化，不存在当天买入当天卖出
            i++;
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(j>i&&prices[j]-prices[i]>=0)//有收入
                {
                    ev[i][j]=prices[j]-prices[i];//记录收入
                    if(ev[i][j]>MAXN)//找收入最大值
                    {
                        MAXN=ev[i][j];
                    }
                }
            }
        }
        return MAXN;
    }
};

这里我的第一思路就是想使用动态规划解决，然鹅我在定义数组涵义之后没有想好数组元素直接的关系式就直接动手写了，结果越写越偏，最后竟然变成一种暴力（对该题数据而言会超时）        震惊我了属于是....

所以写动态规划还是老老实实三步走吧入门动态规划之三步走

下面介绍真正的动态规划做法（其实只是利用了动态规划的思想）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)//prices数组元素个数<=1的情况单独讨论
        {
            return 0;
        }
        int maxn=0,minprice=prices[0];
        for(int i=1;i<prices.size();i++)
        {                            //往右
            maxn=max(maxn,prices[i]-minprice);//比较是之前找到的最大利润大 还是 “今天”直接卖掉股票的最大利润大（这里便是动态规划思想的体现，这里也可以换成dp数组来记录之前找到的最大利润）
            minprice=min(minprice,prices[i]);//注意时刻更新股票成本最小值
        }
        return maxn;
    }
};

如下是三步走的动态规划

• 第一步定义dp[ i ]为到prices数组下标为 i 的最大利润
• 第二步寻找数组元素之间的关系式
• 像这种最大利润的一般结合我们定义的数组涵义必然是下标为 i - 1 与下标为 i 的元素有关系
• 我们不难推知  dp[i]=max(dp[i-1],prices[i]-minprice)  比较是之前找到的最大利润大 还是 “今天”直接卖掉股票的最大利润大
• 第三步dp初始化，即dp[ 1 ]必定为prices[ 1 ] - prices[ 0 ]（不过这里直接融入循环了，所以代码里面没有体现） 

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)//prices数组元素个数<=1的情况单独讨论
        {
            return 0;
        }
        vector<int>dp(prices.size()+1);//定义dp数组
        int minprice=prices[0],MAXN=0;
        for(int i=1;i<prices.size();i++)
        {
            dp[i]=max(dp[i-1],prices[i]-minprice);//比较是之前找到的最大利润大 还是 “今天”直接卖掉股票的最大利润大
            minprice=min(minprice,prices[i]);//注意时刻更新股票成本最小值
            if(dp[i]>MAXN)//寻找最大值
            {
                MAXN=dp[i];
            }
        }
        return MAXN;
    }
};