new soln

Author: shreymehul

1438.LongestSubarray.cs

@@ -0,0 +1,90 @@
+// 1438. Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit
+
+// Given an array of integers nums and an integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is less than or equal to limit.
+
+// Example 1:
+// Input: nums = [8,2,4,7], limit = 4
+// Output: 2 
+// Explanation: All subarrays are: 
+// [8] with maximum absolute diff |8-8| = 0 <= 4.
+// [8,2] with maximum absolute diff |8-2| = 6 > 4. 
+// [8,2,4] with maximum absolute diff |8-2| = 6 > 4.
+// [8,2,4,7] with maximum absolute diff |8-2| = 6 > 4.
+// [2] with maximum absolute diff |2-2| = 0 <= 4.
+// [2,4] with maximum absolute diff |2-4| = 2 <= 4.
+// [2,4,7] with maximum absolute diff |2-7| = 5 > 4.
+// [4] with maximum absolute diff |4-4| = 0 <= 4.
+// [4,7] with maximum absolute diff |4-7| = 3 <= 4.
+// [7] with maximum absolute diff |7-7| = 0 <= 4. 
+// Therefore, the size of the longest subarray is 2.
+// Example 2:
+// Input: nums = [10,1,2,4,7,2], limit = 5
+// Output: 4 
+// Explanation: The subarray [2,4,7,2] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.
+// Example 3:
+// Input: nums = [4,2,2,2,4,4,2,2], limit = 0
+// Output: 3
+
+// Constraints:
+// 1 <= nums.length <= 105
+// 1 <= nums[i] <= 109
+// 0 <= limit <= 109
+
+public class Solution {
+    public int LongestSubarray(int[] nums, int limit) {
+        int start = 0;
+        int maxLength = 0;
+        
+        LinkedList<int> minDeque = new LinkedList<int>();
+        LinkedList<int> maxDeque = new LinkedList<int>();
+
+        for (int end = 0; end < nums.Length; end++) {
+            // Maintain the maxDeque: elements in decreasing order
+            while (maxDeque.Count > 0 && maxDeque.Last.Value < nums[end]) {
+                maxDeque.RemoveLast();
+            }
+            maxDeque.AddLast(nums[end]);
+
+            // Maintain the minDeque: elements in increasing order
+            while (minDeque.Count > 0 && minDeque.Last.Value > nums[end]) {
+                minDeque.RemoveLast();
+            }
+            minDeque.AddLast(nums[end]);
+
+            // Check if the current window is valid
+            while (maxDeque.First.Value - minDeque.First.Value > limit) {
+                if (maxDeque.First.Value == nums[start]) {
+                    maxDeque.RemoveFirst();
+                }
+                if (minDeque.First.Value == nums[start]) {
+                    minDeque.RemoveFirst();
+                }
+                start++;
+            }
+
+            // Update the maximum length
+            maxLength = Math.Max(maxLength, end - start + 1);
+        }
+
+        return maxLength;
+    }
+}
+
+// LinkedList for Deques:
+// We use LinkedList<int> directly to maintain the minimum and maximum values.
+// These linked lists (minDeque and maxDeque) will store values in a way that allows efficient addition and removal from both ends.
+
+// Maintaining Deques:
+// For maxDeque, we remove elements from the back while the current element is greater than the elements at the back to maintain a decreasing order.
+// For minDeque, we remove elements from the back while the current element is less than the elements at the back to maintain an increasing order.
+
+// Validating the Window:
+// If the difference between the maximum and minimum values in the current window exceeds the limit, we shrink the window from the start.
+// This involves removing the element at the start from the deques if it is the front element of either deque.
+
+// Max Length Calculation:
+// We update maxLength with the size of the current valid window.
+
+// Complexity:
+// Time Complexity: O(n), where n is the length of the array. Each element is added and removed from the deques at most once.
+// Space Complexity: O(n) in the worst case, for the deques.

2302.CountSubarrays.cs

@@ -0,0 +1,83 @@
+// 2302. Count Subarrays With Score Less Than K
+// The score of an array is defined as the product of its sum and its length.
+// For example, the score of [1, 2, 3, 4, 5] is (1 + 2 + 3 + 4 + 5) * 5 = 75.
+// Given a positive integer array nums and an integer k, return the number of non-empty subarrays of nums whose score is strictly less than k.
+// A subarray is a contiguous sequence of elements within an array.
+
+// Example 1:
+// Input: nums = [2,1,4,3,5], k = 10
+// Output: 6
+// Explanation:
+// The 6 subarrays having scores less than 10 are:
+// - [2] with score 2 * 1 = 2.
+// - [1] with score 1 * 1 = 1.
+// - [4] with score 4 * 1 = 4.
+// - [3] with score 3 * 1 = 3. 
+// - [5] with score 5 * 1 = 5.
+// - [2,1] with score (2 + 1) * 2 = 6.
+// Note that subarrays such as [1,4] and [4,3,5] are not considered because their scores are 10 and 36 respectively, while we need scores strictly less than 10.
+
+// Example 2:
+// Input: nums = [1,1,1], k = 5
+// Output: 5
+// Explanation:
+// Every subarray except [1,1,1] has a score less than 5.
+// [1,1,1] has a score (1 + 1 + 1) * 3 = 9, which is greater than 5.
+// Thus, there are 5 subarrays having scores less than 5.
+
+// Constraints:
+// 1 <= nums.length <= 105
+// 1 <= nums[i] <= 105
+// 1 <= k <= 1015
+
+public class Solution {
+    public long CountSubarrays(int[] nums, long k) {
+        // n is the length of the input array
+        int n = nums.Length;
+        // Variable to keep track of the count of subarrays
+        long count = 0;
+        // Variable to keep the current sum of the window
+        long currentSum = 0;
+        // Start pointer for the sliding window
+        int start = 0;
+        
+        // Iterate through each element in the array with the end pointer
+        for (int end = 0; end < n; end++) {
+            // Add the current element to the currentSum
+            currentSum += nums[end];
+            
+            // While the score of the current window is not less than k
+            while (currentSum * (end - start + 1) >= k) {
+                // Remove the start element from the currentSum and move the start pointer to the right
+                currentSum -= nums[start];
+                start++;
+            }
+            
+            // Add the number of valid subarrays ending at the current end pointer
+            count += (end - start + 1);
+        }
+        
+        // Return the total count of valid subarrays
+        return count;
+    }
+}
+
+/*
+Complexity Analysis:
+- Time Complexity: O(n)
+Each element is added and removed from the currentSum at most once, resulting in a linear time complexity.
+- Space Complexity: O(1)
+We use a few extra variables (currentSum, count, start) that do not depend on the input size, resulting in constant space complexity.
+
+
+Sliding Window Approach:
+We use a sliding window to keep track of the current subarray sum.
+The start pointer moves right whenever the score condition currentSum * (end - start + 1) >= k is not met.
+
+Efficiency:
+The sliding window ensures that each element is processed in linear time, improving efficiency from the original nested loop approach.
+
+Loop Indices:
+Using int for indices since array indices are integers.
+
+*/

MinHeap.cs

@@ -0,0 +1,123 @@
+using System;
+
+public class MinHeap
+{
+    private int[] heap;
+    private int size;
+    private int capacity;
+
+    public MinHeap(int capacity)
+    {
+        this.capacity = capacity;
+        this.size = 0;
+        this.heap = new int[capacity];
+    }
+
+    private int GetLeftChildIndex(int index) => 2 * index + 1;
+    private int GetRightChildIndex(int index) => 2 * index + 2;
+    private int GetParentIndex(int index) => (index - 1) / 2;
+
+    private bool HasLeftChild(int index) => GetLeftChildIndex(index) < size;
+    private bool HasRightChild(int index) => GetRightChildIndex(index) < size;
+    private bool HasParent(int index) => GetParentIndex(index) >= 0;
+
+    private int LeftChild(int index) => heap[GetLeftChildIndex(index)];
+    private int RightChild(int index) => heap[GetRightChildIndex(index)];
+    private int Parent(int index) => heap[GetParentIndex(index)];
+
+    private void Swap(int indexOne, int indexTwo)
+    {
+        int temp = heap[indexOne];
+        heap[indexOne] = heap[indexTwo];
+        heap[indexTwo] = temp;
+    }
+
+    public int Peek()
+    {
+        if (size == 0) throw new InvalidOperationException("Heap is empty");
+        return heap[0];
+    }
+
+    public void Enqueue(int item)
+    {
+        EnsureExtraCapacity();
+        heap[size] = item;
+        size++;
+        HeapifyUp();
+    }
+
+    public int Dequeue()
+    {
+        if (size == 0) throw new InvalidOperationException("Heap is empty");
+        int item = heap[0];
+        heap[0] = heap[size - 1];
+        size--;
+        HeapifyDown();
+        return item;
+    }
+
+    private void EnsureExtraCapacity()
+    {
+        if (size == capacity)
+        {
+            Array.Resize(ref heap, capacity * 2);
+            capacity *= 2;
+        }
+    }
+
+    private void HeapifyUp()
+    {
+        int index = size - 1;
+        while (HasParent(index) && Parent(index) > heap[index])
+        {
+            Swap(GetParentIndex(index), index);
+            index = GetParentIndex(index);
+        }
+    }
+
+    private void HeapifyDown()
+    {
+        int index = 0;
+        while (HasLeftChild(index))
+        {
+            int smallerChildIndex = GetLeftChildIndex(index);
+            if (HasRightChild(index) && RightChild(index) < LeftChild(index))
+            {
+                smallerChildIndex = GetRightChildIndex(index);
+            }
+
+            if (heap[index] < heap[smallerChildIndex])
+            {
+                break;
+            }
+            else
+            {
+                Swap(index, smallerChildIndex);
+            }
+
+            index = smallerChildIndex;
+        }
+    }
+}
+
+// Example usage:
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        MinHeap minHeap = new MinHeap(10);
+        minHeap.Enqueue(5);
+        minHeap.Enqueue(3);
+        minHeap.Enqueue(8);
+        minHeap.Enqueue(1);
+
+        Console.WriteLine(minHeap.Peek()); // Output: 1
+
+        Console.WriteLine(minHeap.Dequeue()); // Output: 1
+        Console.WriteLine(minHeap.Dequeue()); // Output: 3
+
+        minHeap.Enqueue(2);
+
+        Console.WriteLine(minHeap.Peek()); // Output: 2
+    }
+}