Update optimized approach code

Author: SartHak-0-Sach

184-2nd_July-Intersection_of_arrays-II/approach-explanation.txt

@@ -1,9 +1,12 @@
 Intuition
-Using hash map to opimize the algorithm o(N). Instead of using sorting. It takes O(NlogN). But my solution takes require more space then sorting approach.
+We have to check whether the current element in the current array is also present in the other array that has been given to us, What data structure can we use here?
+
 Approach
-My first thought is using a "Hash_map" to store the elements of 1 array and corresponding frequency into hash map.
-Add the elements of "nums1" into map with corresponding frequency.
-Iterate throught each element of "nums2". If frequency of the element stored in hash map greater than 0. We add this element into "res" and decrease the frequency of this element.
+We simply store one array in a map with all its frequencies, and while iterating the other given array if we encounter the current element of the current array in the map with suitable frequency we will add that element to our answer vector. Also remember that we have to delete any element that has 0 frequncy to avoid adding extra elements to our answer vector.
+
 Complexity
-Time complexity: O(N).
-Space complexity: O(N).
+Time complexity:
+O(n+m) Iterating over the vectors and finding the element in tree map.
+
+Space complexity:
+O(n) An answer vector to return and a map to store elements.

184-2nd_July-Intersection_of_arrays-II/code.cpp

@@ -1,24 +1,43 @@
 #include <iostream>
 #include <vector>
 #include <unordered_map>
-#include <algorithm>
 using namespace std;
-
-class Solution {
+#define nline '\n'
+#define sp ' '
+#define all(x) x.begin(), x.end()
+#define rall(x) x.rbegin(), x.rend()
+static int fastIO = []
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(0);
+    cout.tie(0);
+    return 0;
+}();
+// Paste the Class here-
+class Solution
+{
 public:
-    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
-        vector<int> res;
-        unordered_map<int, int> box;
-        for (int num : nums1)
-            box[num]++;
-        for (int i = 0; i < nums2.size(); ++i) {
-            if (box[nums2[i]] > 0) {
-                res.push_back(nums2[i]);
-                box[nums2[i]]--;
-            } else {
-                continue;
+    vector<int> intersect(vector<int> &nums1, vector<int> &nums2)
+    {
+        unordered_map<int, int> hashmap;
+        vector<int> Res;
+        for (int i = 0; i < nums1.size(); i++)
+        {
+            hashmap[nums1[i]]++;
+        }
+        for (int i = 0; i < nums2.size(); i++)
+        {
+            int element = nums2[i];
+            if (hashmap.find(element) != hashmap.end())
+            {
+                Res.push_back(element);
+                hashmap[element]--;
+                if (hashmap[element] == 0)
+                {
+                    hashmap.erase(element);
+                }
             }
         }
-        return res;
+        return Res;
     }
 };