力扣1911、最大子序列交替和

1、动态规划（128ms,89%;89MB,47%）

时间复杂度：O（n）：n为数组元素个数

空间复杂度：O（1）

 1 class Solution {
 2 public:
 3         long theMax(long a,long b,long c){
 4         return a>b? (a>c? a:c):(b>c? b:c);
 5     }
 6     //#define INT_MAX 2147483647
 7     //#define INT_MIN (-INT_MAX - 1) 
 8     long long maxAlternatingSum(vector<int>& nums) {
 9         //dp0保存以偶次项结尾的目标值的总和
10         //dp1保存以奇次项结尾的目标值的总和
11         //temp是中间载体
12         long dp0=nums[0];
13         long dp1=INT_MIN;
14         long temp=0;
15         for(int i=1;i<nums.size();i++){
16             temp=dp0;
17             dp0=theMax(dp0,nums[i],nums[i]+dp1);
18             dp1=max(dp1,temp-nums[i]);
19         }
20         return dp0;
21     }
22 };

2、模拟股票交易（136ms,69%;88.9MB,84%）

时间复杂度：O（n）：n为数组元素个数

空间复杂度：O（1）

 1 long long maxAlternatingSum(vector<int>& nums) {
 2         //将ans类比成赚的钱，pre类比成股票原价，nums[]类比成股票现价
 3         long ans = 0;
 4         int pre = 0;
 5         for (int i = 0; i<nums.size(); i++) {
 6             if (nums[i] > pre) {//现价比原价高，就卖出一股，并更新原价
 7                 ans += nums[i] - pre;
 8                 pre = nums[i];
 9             } else pre = nums[i];//如果遇到价格更低的，则更新原价
10         }
11         return ans;
12     }

3、循环（124ms,95%;88.9MB,66%）

时间复杂度：O（n）：n为数组元素个数

空间复杂度：O（1）

 1 long long maxAlternatingSum(vector<int>& nums) {
 2         int n = nums.size();
 3         long long ans = nums[0];
 4         for(int i=1;i<n;++i){
 5             if(nums[i-1] < nums[i]){
 6                 ans -= nums[i-1];
 7                 ans += nums[i];
 8             }
 9         }
10         return ans;
11     }

 

4、栈（152ms,33.7%;88.9MB，59%）

时间复杂度：O（n）：n为数组元素个数

空间复杂度：O（n）：我不确定

 1 long long maxAlternatingSum(vector<int>& nums) {
 2         long long ans = 0;
 3         stack<int> st;
 4         for(int i = 0; i < nums.size(); i++){
 5             //空的或者递减，入栈
 6             if(st.empty() || nums[i] < st.top()){
 7                 st.push(nums[i]);
 8                 continue;
 9             } 
10             //当前数字比栈顶的大，清空栈并计算差值和
11             if(nums[i] > st.top()){
12                 int pre = st.top();
13                 st.pop();
14                 while(!st.empty()){
15                     ans += st.top() - pre;
16                     pre = st.top();
17                     st.pop();
18                 }
19                 //把当前元素塞进去
20                 st.push(nums[i]);
21             }
22         }
23         //栈没空，说明最后有一个递减序列
24         //此时不需要计算差值，只要把栈底最大的元素取出来即可
25         int tmp = 0;
26         while(!st.empty()){
27             tmp = st.top();
28             st.pop();
29         }
30         ans += tmp;
31         return ans;
32     }

 

标签：pre,nums,复杂度,long,st,力扣,序列,ans,1911
来源： https://www.cnblogs.com/Wow-A/p/15700445.html