962. Maximum Width Ramp

时间:2020-05-29
本文章向大家介绍962. Maximum Width Ramp,主要包括962. Maximum Width Ramp使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

问题:

给定数组,求一对 index为 ( i , j ) 的 A[i] <= A[j] && i < j,两个index距离最远。(即max(j-i))

Example 1:
Input: [6,0,8,2,1,5]
Output: 4
Explanation: 
The maximum width ramp is achieved at (i, j) = (1, 5): A[1] = 0 and A[5] = 5.

Example 2:
Input: [9,8,1,0,1,9,4,0,4,1]
Output: 7
Explanation: 
The maximum width ramp is achieved at (i, j) = (2, 9): A[2] = 1 and A[9] = 1. 

Note:
2 <= A.length <= 50000
0 <= A[i] <= 50000

  

解法1:

使用排序的map去存储,元素数值 与 index数组信息 {A[i], array[...]}。

(同一个数值可能有多个,在不同位置)

array[0]为该数值A[i]的最小index,array[end]为该数值A[i]的最大index

(令end=array.size()-1)

遍历构建好的map

由于已经根据元素值排序过,

依次记录最小的index值。lowestindex = min(lowestindex, array[0]);

和当前值的最大index值的差:res = max(res, array[end]-lowestindex);

这样对每个数值,都进行了res求解。从中选出最大差值,即为要求结果。

代码参考:

 1 class Solution {
 2 public:
 3     int maxWidthRamp(vector<int>& A) {
 4         map<int, vector<int>> pos;
 5         int res=0;
 6         int lowestindex=A.size();
 7         for(int i=0; i<A.size(); i++){
 8             pos[A[i]].push_back(i);
 9         }
10         for(auto p:pos){
11             int end=p.second.size()-1;
12             lowestindex = min(lowestindex, p.second[0]);
13             res=max(res, p.second[end]-lowestindex);
14         }
15         return res;
16     }
17 };

解法2:

1.构建decreasing stack

记录 ( i , j ) 中的 i:尽量左边,尽量最小

比如对一个数组[3,28,15,1,4,0]

我们选取 i 的话,从第一个元素 3 开始选取,

[3]

接着选取下一个 28 时,发现,如果以28为 i,任何满足条件的 j (>=28) 都是满足前一个元素 3 的,

要尽量选择左边的 i 的话,相对于(28, j)我们宁愿选择(3, j),因为其距离差值选择3更大。因此我们不选择28

接着选取下一个 15 同上,

接着选取下一个 1 时,满足条件的 j 如果=2的时候,即不能向上面那样,选择3去替代1的情况。因此我们需要选入1

[3,1]

...

同理,我们最终得到的即是一个递减栈[3,1,0]

2.从最右边开始遍历j:尽量右边,尽量最大

一直遍历到 j>res即可

理由是:如果j已经小于等于res了,那么j-i就更小于等于res了,res要求最大,就不必去尝试了。

对于每一个j,我们去比较栈顶元素。

如果满足条件,A[s.top] <= A[j],那么构建栈已经保证i=s.top为i的最左边。j也是最右边,那么当前的j-i可作为备选答案,选入res中。

res=max(res, s.top-j);

接着,pop栈顶,我们再判断下一个栈顶元素,如果满足条件,同上。

如果不满足条件:我们需要判断下一个j-1,按理说,应该重新用最初的栈,开始重新判断。

但是,由以下理由,我们不需要再重新恢复栈,重新判断:

  首先,到上一个满足条件的res为止,res已经取得最大,即为j-s.top的距离,

  那么小于这个距离的,我们不必再去判断。j-1后,使得 i 从s.top-1开始向左判断(与A[j-1]的关系)。

  我们直接pop,直接选择新的s.top(省略了 新s.top+1 ~ 原s.top-1)来判断的理由:

    如果存在某个值A[k]<A[j-1]满足题意的话,(k在【原来的top-1的位置】->【现在的top】之间)

    由于A[k]一定 >= 现在的A[top] (stack是递减的),

    那么现在的A[top]<=A[k]<A[j-1]也满足题意。

    那还不如去选择 现在的A[top],因为top更靠左。

    因此直接去尝试现在的A[top],

    如果不满足,那么(从原来的top-1的位置->现在的top)都不会满足<A[j-1]

代码参考:

 1 class Solution {
 2 public:
 3     int maxWidthRamp(vector<int>& A) {
 4         int res=0;
 5         // 构建decreasing stack记录(i,j)中的 i:尽量左边,尽量最小
 6         stack<int> s;
 7         for(int i=0; i<A.size(); i++){
 8             if(s.empty() || A[i] < A[s.top()]){
 9                 s.push(i);
10             }
11         }
12         //从最右边开始遍历j:尽量右边,尽量最大
13         for(int j=A.size()-1; j>res; j--){
14             //如果j已经小于等于res了,那么j-i就更小于等于res了,res要求最大,就不必去尝试了。
15             while(!s.empty() && A[s.top()]<=A[j]){//满足题意:A[i]<=A[j]
16                 res=max(res, j-s.top());
17                 s.pop();
18                 //pop的理由:pop后的top不满足题意:top>A[j]
19                 //那么尝试A[j-1]这个元素:
20                 //对于原来的top:这时的(j-1)-i一定<刚才的j,因此不考虑原来的top
21                 //(从原来的top-1的位置->现在的top),逐次考虑:与A[j-1]的关系
22                 //如果存在某个值A[k]<A[j-1]满足题意的话,
23                 //(k在【原来的top-1的位置】->【现在的top】之间)
24                 //由于A[k]一定 >= 现在的A[top] (stack是递减的),
25                 //那么现在的A[top]<=A[k]<A[j-1]也满足题意。
26                 //那还不如去选择 现在的A[top],因为top更靠左。
27                 //因此直接去尝试现在的A[top],
28                 //如果不满足,那么(从原来的top-1的位置->现在的top)都不会满足<A[j-1]
29             }
30         }
31         return res;
32     }
33 };

原文地址:https://www.cnblogs.com/habibah-chang/p/12987489.html