Mar-13

Author: geemaple

README.md

@@ -0,0 +1,53 @@
+//  Tag: Array, Counting, Prefix Sum, Line Sweep
+//  Time: O(NlogN)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  You are given a 2D integer array logs where each logs[i] = [birthi, deathi] indicates the birth and death years of the ith person.
+//  The population of some year x is the number of people alive during that year. The ith person is counted in year x's population if x is in the inclusive range [birthi, deathi - 1]. Note that the person is not counted in the year that they die.
+//  Return the earliest year with the maximum population.
+//   
+//  Example 1:
+//  
+//  Input: logs = [[1993,1999],[2000,2010]]
+//  Output: 1993
+//  Explanation: The maximum population is 1, and 1993 is the earliest year with this population.
+//  
+//  Example 2:
+//  
+//  Input: logs = [[1950,1961],[1960,1971],[1970,1981]]
+//  Output: 1960
+//  Explanation: 
+//  The maximum population is 2, and it had happened in years 1960 and 1970.
+//  The earlier year between them is 1960.
+//   
+//  Constraints:
+//  
+//  1 <= logs.length <= 100
+//  1950 <= birthi < deathi <= 2050
+//  
+//  
+
+class Solution {
+public:
+    int maximumPopulation(vector<vector<int>>& logs) {
+        map<int, int> lines;
+        for (auto &log: logs) {
+            lines[log[0]] += 1;
+            lines[log[1]] -= 1;
+        }
+
+        int count = 0;
+        int max_count = 0;
+        int res = 0;
+        for (auto& i: lines) {
+            count += i.second;
+            if (count > max_count) {
+                max_count = count;
+                res = i.first;
+            }
+        }
+        return res;
+    }
+};

leetcode/1854.maximum-population-year.cpp

@@ -0,0 +1,51 @@
+#  Tag: Array, Counting, Prefix Sum, Line Sweep
+#  Time: O(NlogN)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  You are given a 2D integer array logs where each logs[i] = [birthi, deathi] indicates the birth and death years of the ith person.
+#  The population of some year x is the number of people alive during that year. The ith person is counted in year x's population if x is in the inclusive range [birthi, deathi - 1]. Note that the person is not counted in the year that they die.
+#  Return the earliest year with the maximum population.
+#   
+#  Example 1:
+#  
+#  Input: logs = [[1993,1999],[2000,2010]]
+#  Output: 1993
+#  Explanation: The maximum population is 1, and 1993 is the earliest year with this population.
+#  
+#  Example 2:
+#  
+#  Input: logs = [[1950,1961],[1960,1971],[1970,1981]]
+#  Output: 1960
+#  Explanation: 
+#  The maximum population is 2, and it had happened in years 1960 and 1970.
+#  The earlier year between them is 1960.
+#   
+#  Constraints:
+#  
+#  1 <= logs.length <= 100
+#  1950 <= birthi < deathi <= 2050
+#  
+#  
+
+from collections import defaultdict
+class Solution:
+    def maximumPopulation(self, logs: List[List[int]]) -> int:
+        n = len(logs)
+        line = defaultdict(int)
+
+        for s, e in logs:
+            line[s] += 1
+            line[e] -= 1
+
+        count = 0
+        max_count = 0
+        res = 0
+        for year in sorted(line.keys()):
+            count += line[year]
+            if count > max_count:
+                max_count = count
+                res = year
+        
+        return res

leetcode/1854.maximum-population-year.py

@@ -0,0 +1,80 @@
+//  Tag: Array, Prefix Sum, Line Sweep
+//  Time: O(N + M)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  You are given an integer array nums of length n and a 2D array queries, where queries[i] = [li, ri].
+//  For each queries[i]:
+//  
+//  Select a subset of indices within the range [li, ri] in nums.
+//  Decrement the values at the selected indices by 1.
+//  
+//  A Zero Array is an array where all elements are equal to 0.
+//  Return true if it is possible to transform nums into a Zero Array after processing all the queries sequentially, otherwise return false.
+//   
+//  Example 1:
+//  
+//  Input: nums = [1,0,1], queries = [[0,2]]
+//  Output: true
+//  Explanation:
+//  
+//  For i = 0:
+//  
+//  Select the subset of indices as [0, 2] and decrement the values at these indices by 1.
+//  The array will become [0, 0, 0], which is a Zero Array.
+//  
+//  
+//  
+//  
+//  Example 2:
+//  
+//  Input: nums = [4,3,2,1], queries = [[1,3],[0,2]]
+//  Output: false
+//  Explanation:
+//  
+//  For i = 0:
+//  
+//  Select the subset of indices as [1, 2, 3] and decrement the values at these indices by 1.
+//  The array will become [4, 2, 1, 0].
+//  
+//  
+//  For i = 1:
+//  
+//  Select the subset of indices as [0, 1, 2] and decrement the values at these indices by 1.
+//  The array will become [3, 1, 0, 0], which is not a Zero Array.
+//  
+//  
+//  
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 105
+//  0 <= nums[i] <= 105
+//  1 <= queries.length <= 105
+//  queries[i].length == 2
+//  0 <= li <= ri < nums.length
+//  
+//  
+
+class Solution {
+public:
+    bool isZeroArray(vector<int>& nums, vector<vector<int>>& queries) {
+        int n = nums.size();
+        vector<int> line(n + 1, 0);
+        for (auto &q: queries) {
+            line[q[0]] += 1;
+            line[q[1] + 1] -= 1;
+        }
+
+        int prefix = 0;
+        for (int i = 0; i < n; i++) {
+            prefix += line[i];
+            if (nums[i] > prefix) {
+                return false;
+            }
+        }
+        return true;
+    }
+};

leetcode/3355.zero-array-transformation-i.cpp

@@ -0,0 +1,75 @@
+#  Tag: Array, Prefix Sum, Line Sweep
+#  Time: O(N + M)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  You are given an integer array nums of length n and a 2D array queries, where queries[i] = [li, ri].
+#  For each queries[i]:
+#  
+#  Select a subset of indices within the range [li, ri] in nums.
+#  Decrement the values at the selected indices by 1.
+#  
+#  A Zero Array is an array where all elements are equal to 0.
+#  Return true if it is possible to transform nums into a Zero Array after processing all the queries sequentially, otherwise return false.
+#   
+#  Example 1:
+#  
+#  Input: nums = [1,0,1], queries = [[0,2]]
+#  Output: true
+#  Explanation:
+#  
+#  For i = 0:
+#  
+#  Select the subset of indices as [0, 2] and decrement the values at these indices by 1.
+#  The array will become [0, 0, 0], which is a Zero Array.
+#  
+#  
+#  
+#  
+#  Example 2:
+#  
+#  Input: nums = [4,3,2,1], queries = [[1,3],[0,2]]
+#  Output: false
+#  Explanation:
+#  
+#  For i = 0:
+#  
+#  Select the subset of indices as [1, 2, 3] and decrement the values at these indices by 1.
+#  The array will become [4, 2, 1, 0].
+#  
+#  
+#  For i = 1:
+#  
+#  Select the subset of indices as [0, 1, 2] and decrement the values at these indices by 1.
+#  The array will become [3, 1, 0, 0], which is not a Zero Array.
+#  
+#  
+#  
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 105
+#  0 <= nums[i] <= 105
+#  1 <= queries.length <= 105
+#  queries[i].length == 2
+#  0 <= li <= ri < nums.length
+#  
+#  
+
+class Solution:
+    def isZeroArray(self, nums: List[int], queries: List[List[int]]) -> bool:
+        n = len(nums)
+        line = [0 for i in range(n + 1)]
+        for l, r in queries:
+            line[l] += 1
+            line[r + 1] -=1
+
+        prefix = 0
+        for i in range(n):
+            prefix += line[i]
+            if nums[i] > prefix:
+                return False
+
+        return True