DAY 106 - Next Greater Element I
Tags: learning, cpp, beginners, algorithms
Published: 2023-09-17 16:26:54

## Question: [Next Greater Element I](https://leetcode.com/problems/next-greater-element-i/description/)

The next greater element of some element `x` in an array is the first greater element that is to the right of `x` in the same array.

You are given two distinct 0-indexed integer arrays `nums1` and `nums2`, where `nums1`is a subset of `nums2`.

For each `0 <= i < nums1.length`, find the index `j`such that `nums1[i] == nums2[j]` and determine the next greater element of `nums2[j]`in `nums2`. If there is no next greater element, then the answer for this query is `-1.`

Return an array `ans` of length `nums1.length` such that `ans[i]` is the next greater element as described above.


---

### Example 1:

> **Input:** nums1 = [4,1,2], nums2 = [1,3,4,2]
> **Output:** [-1,3,-1]
> **Explanation**: The next greater element for each value of nums1 is as follows:
> - 4 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1.
> - 1 is underlined in nums2 = [1,3,4,2]. The next greater element is 3.
> - 2 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1.

---

## Problem Breakdown:

Before we dive into the code, let's break down the problem and understand what's expected:

- We have two arrays, `nums1` and `nums2`, of non-negative integers.

- Each element in `nums1` is present in `nums2`.

- For each element in `nums1`, we need to find the next greater element in `nums2`.

- If there is no greater element in `nums2`, we should return `-1` for that element in the result array.

---

## Approach:

To solve this problem efficiently, we can use a stack and a hash map. Here's the step-by-step approach:

1. We initialize an empty stack `s` and an empty unorderd_map `mp`.

2. We traverse through `nums2`, which serves as our parent array to find the next greater elements.

3. In each iteration, we compare the current element, `it`, with the top element of the stack (`s.top()`). If `it` is greater, we update the hash map `mp` with the mapping of the top element of the stack to `it`. We also pop the top element from the stack because we have found the next greater element for it.

4. After processing `nums2`, we have a complete mapping of each element to its next greater element in `mp`.

5. We initialize the result vector `res` with the same size as `nums1`, filled with -1.

6. We iterate through `nums1` and check if the element exists in `mp`. If it does, we update the corresponding position in `res` with the next greater element found in `mp`.

7. Finally, we return the `res` vector, which contains the next greater elements for each element in `nums1`.

---
## Code:

```cpp

vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> mp;
        stack<int> s;
        for(auto it : nums2){
            while(!s.empty() && s.top() < it){
                mp[s.top()] = it;
                s.pop();
            }
            s.push(it);
        }
        vector<int> res(nums1.size(),-1);

        for(int i = 0; i < nums1.size(); ++i){
            if(mp[nums1[i]]){
                res[i] = mp[nums1[i]];
            }
        }
        return res;
    }
```


---

## Time and Space Complexity:

Let's analyze the time and space complexity of our solution:

- **Time Complexity**: The solution processes both `nums1` and `nums2` exactly once, so the time complexity is O(N1 + N2), where N1 is the length of `nums1`, and N2 is the length of `nums2`.

- **Space Complexity**: We use a stack and a hash map to store intermediate results. The space complexity is O(N2) in the worst case, where N2 is the length of `nums2`.