Merge branch 'master' into feature/lru-cache

Author: JRS296

Arrays & Strings/#31 - Next Permutation - Medium/Explanation.md

@@ -0,0 +1,126 @@
+# 31. Next Permutation
+
+**Difficulty:** *Medium*  
+**Category:** *Arrays, Permutations, Greedy*  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/next-permutation/)
+
+---
+
+## 📝 Introduction
+
+*Given an array Arr[] of integers, rearrange the numbers into the lexicographically next greater permutation of numbers.  
+If such an arrangement is not possible, rearrange it to the lowest possible order (i.e., sorted in ascending order).*
+
+*Constraints typically include:<br>
+- All integers may be distinct or contain duplicates.<br>
+- The transformation must be done in-place with only constant extra memory.*
+
+---
+
+## 💡 Approach & Key Insights
+
+*There are three main approaches to solve this problem:<br>
+- Brute Force: Generate all permutations and pick the next.<br>
+- In-Built Function: Use next_permutation() if language provides it.<br>
+- Optimal: Use the standard algorithm to compute the next permutation by identifying a break point, swapping, and reversing.*
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:** *Generate all permutations of the array, sort them, and locate the input permutation. Return the next one in sequence. If not found or if it's the last permutation, return the first (sorted array).*
+- **Time Complexity:** *O(N! × N) – N! permutations each of length N.*
+- **Space Complexity:** *O(1) – ignoring recursion stack used for generating permutations.*
+- **Example/Dry Run:**
+
+```plaintext
+Input: [1, 2, 3]
+All permutations: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]
+Current permutation: [1,2,3]
+Next permutation: [1,3,2]
+```
+
+### 2️⃣ Language Built-in (C++ std::next_permutation)
+
+- **Explanation:** *C++ provides next_permutation() which directly modifies the array to the next permutation.*
+- **Time Complexity:** *O(N) – internally optimized.*
+- **Space Complexity:** *O(1).*
+- **Example:**
+
+```cpp
+std::vector<int> nums = {1, 2, 3};
+std::next_permutation(nums.begin(), nums.end());
+// nums is now [1, 3, 2]
+```
+
+### 3️⃣ Optimal Approach
+
+- **Explanation:**  
+  1. Find the break-point: The first index i from the back where arr[i] < arr[i+1].  
+  2. If no such index exists, reverse the whole array (it was the last permutation).  
+  3. Else, find the smallest number greater than arr[i] from the right half, swap it with arr[i].  
+  4. Reverse the subarray from i+1 to end.
+
+- **Time Complexity:** *O(3N) = O(N) – each of the three steps (finding break-point, finding next greater, reversing) takes O(N).*
+- **Space Complexity:** *O(1) – all operations are done in-place.*
+- **Example/Dry Run:**
+
+```plaintext
+Input: [1, 2, 3]
+
+Step 1: Find break-point: 2 < 3 at index 1 → i = 1  
+Step 2: Find element just greater than arr[i]: 3 at index 2  
+Step 3: Swap 2 and 3 → [1, 3, 2]  
+Step 4: Reverse from i+1 = 2 to end → Already sorted
+
+Output: [1, 3, 2]
+```
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach       | Time Complexity   | Space Complexity |
+| -------------- | ----------------- | ---------------- |
+| Brute Force    | O(N! × N)         | O(1)             |
+| In-Built       | O(N)              | O(1)             |
+| Optimal        | O(N)              | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+*The optimal solution is already efficient for all constraints.  
+You may consider early exits in case the array is already in decreasing order to avoid redundant operations.*
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+```plaintext
+Example 1:
+Input: [1, 3, 2]
+Break-point: index 0 (1 < 3)
+Swap with next greater: swap 1 and 2 → [2, 3, 1]
+Reverse after index 0 → [2, 1, 3]
+Output: [2, 1, 3]
+
+Example 2:
+Input: [3, 2, 1]
+Break-point: None (fully decreasing)
+Reverse entire array → [1, 2, 3]
+Output: [1, 2, 3]
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [C++ next_permutation documentation](https://en.cppreference.com/w/cpp/algorithm/next_permutation)
+
+---
+
+Author: Neha Amin <br>
+Date: 19/07/2025

Arrays & Strings/#31 - Next Permutation - Medium/nextPermutation.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    void nextPermutation(vector<int>& nums) {
+        int n = nums.size();
+        int ind = -1;
+        // Step 1: Find the break point
+        for (int i = n - 2; i >= 0; i--) {
+            if (nums[i] < nums[i + 1]) {
+                ind = i;
+                break;
+            }
+        }
+        // If break point does not exist, reverse the whole array
+        if (ind == -1) {
+            reverse(nums.begin(), nums.end());
+            return;
+        }
+        // Step 2: Find element just greater than nums[ind] and swap
+        for (int i = n - 1; i > ind; i--) {
+            if (nums[i] > nums[ind]) {
+                swap(nums[i], nums[ind]);
+                break;
+            }
+        }
+        // Step 3: Reverse the right half
+        reverse(nums.begin() + ind + 1, nums.end());
+    }
+};

Arrays & Strings/#31 - Next Permutation - Medium/nextPermutation.py

@@ -0,0 +1,23 @@
+class Solution:
+    def nextPermutation(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        n = len(nums)
+        ind = -1
+        # Step 1: Find the break point
+        for i in range(n-2, -1, -1):
+            if nums[i] < nums[i + 1]:
+                ind = i
+                break
+        # If break point does not exist, reverse the whole array
+        if ind == -1:
+            nums.reverse()
+            return
+        # Step 2: Find the next greater element and swap
+        for i in range(n - 1, ind, -1):
+            if nums[i] > nums[ind]:
+                nums[i], nums[ind] = nums[ind], nums[i]
+                break
+        # Step 3: Reverse the right half
+        nums[ind+1:] = reversed(nums[ind+1:])

Stacks & Queues/#146 - LRU Cache -Medium/LRUCache.java

@@ -0,0 +1,70 @@
+class LRUCache {
+    class Node {
+        int key;
+        int val;
+        Node next;
+        Node prev;
+        
+        Node(int key, int val) {
+            this.key = key;
+            this.val = val;
+            this.next = null;
+            this.prev = null;
+        }
+    }
+    
+    Node head = new Node(-1, -1);
+    Node tail = new Node(-1, -1);
+    int cap;
+    HashMap<Integer, Node> cache;
+
+    public LRUCache(int capacity) {
+        cap = capacity;
+        cache = new HashMap<>();
+        head.next = tail;
+        tail.prev = head;
+    }
+    
+    private void addNode(Node newNode) {
+        Node temp = head.next;
+        newNode.next = temp;
+        newNode.prev = head;
+        head.next = newNode;
+        temp.prev = newNode;
+    }
+    
+    private void deleteNode(Node delNode) {
+        Node delPrev = delNode.prev;
+        Node delNext = delNode.next;
+        delPrev.next = delNext;
+        delNext.prev = delPrev;
+    }
+    
+    public int get(int key) {
+        if (cache.containsKey(key)) {
+            Node resNode = cache.get(key);
+            int result = resNode.val;
+            cache.remove(key);
+            deleteNode(resNode);
+            addNode(resNode);
+            cache.put(key, head.next);
+            return result;
+        }
+        return -1;
+    }
+    
+    public void put(int key, int value) {
+        if (cache.containsKey(key)) {
+            Node existingNode = cache.get(key);
+            cache.remove(key);
+            deleteNode(existingNode);
+        }
+        if (cache.size() == cap) {
+            Node lruNode = tail.prev;
+            cache.remove(lruNode.key);
+            deleteNode(lruNode);
+        }
+        addNode(new Node(key, value));
+        cache.put(key, head.next);
+    }
+}

Stacks & Queues/#146 - LRU Cache -Medium/LRUCache.py

@@ -0,0 +1,64 @@
+class LRUCache:
+    class Node:
+        def __init__(self, key=0, val=0):
+            self.key = key
+            self.val = val
+            self.next = None
+            self.prev = None
+
+    def __init__(self, capacity: int):
+        self.cap = capacity
+        self.cache = {}  # key -> node
+        
+        # Create dummy head and tail nodes
+        self.head = self.Node(-1, -1)
+        self.tail = self.Node(-1, -1)
+        self.head.next = self.tail
+        self.tail.prev = self.head
+
+    def add_node(self, new_node):
+        """Add node right after head"""
+        temp = self.head.next
+        new_node.next = temp
+        new_node.prev = self.head
+        self.head.next = new_node
+        temp.prev = new_node
+
+    def delete_node(self, del_node):
+        """Remove node from the list"""
+        del_prev = del_node.prev
+        del_next = del_node.next
+        del_prev.next = del_next
+        del_next.prev = del_prev
+
+    def get(self, key: int) -> int:
+        if key in self.cache:
+            res_node = self.cache[key]
+            result = res_node.val
+            
+            # Move to head (mark as recently used)
+            del self.cache[key]
+            self.delete_node(res_node)
+            self.add_node(res_node)
+            self.cache[key] = self.head.next
+            
+            return result
+        return -1
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            # Update existing key
+            existing_node = self.cache[key]
+            del self.cache[key]
+            self.delete_node(existing_node)
+        
+        if len(self.cache) == self.cap:
+            # Remove LRU (tail.prev)
+            lru_node = self.tail.prev
+            del self.cache[lru_node.key]
+            self.delete_node(lru_node)
+        
+        # Add new node
+        new_node = self.Node(key, value)
+        self.add_node(new_node)
+        self.cache[key] = self.head.next