Merge branch 'master' into feature/div

Author: JRS296

Problems/1976 - Number of Ways to Arrive at Destination - Medium/Explanation.md

@@ -0,0 +1,76 @@
+# Explanation of the Program
+
+### **Objective**
+The goal of the program is to count the number of distinct shortest paths from node `0` to node `n-1` in a weighted, undirected graph. The result is returned modulo \( 10^9 + 7 \).
+
+---
+
+### **Key Components**
+1. **Class `Pair`:**  
+   - Represents a pair of values (distance and node index).
+   - Used for storing the distance of a node from the source and the index of the node.
+
+2. **Adjacency List (`adj`):**  
+   - The graph is represented as an adjacency list where each node's neighbors and edge weights are stored.
+   - The adjacency list is built using input data from the `roads` array.
+
+3. **Priority Queue (`pq`):**  
+   - Implements a min-heap to efficiently get the node with the smallest distance.
+   - Helps in applying Dijkstra's algorithm.
+
+4. **Arrays `dist` and `ways`:**  
+   - `dist[i]`: Stores the shortest distance from the source node (node `0`) to node `i`.
+   - `ways[i]`: Stores the number of distinct ways to reach node `i` with the shortest distance.
+
+---
+
+### **Step-by-Step Process**
+1. **Input Parsing and Graph Construction:**
+   - The graph is built using the `roads` array, where each road connects two nodes (`u` and `v`) with a specific weight (`w`).
+   - Two directed edges are created for each road since the graph is undirected.
+
+2. **Initialization:**
+   - Initialize the `dist` array with `Long.MAX_VALUE` to signify unreachable nodes.
+   - Initialize the `ways` array to `0` (initially no paths to any node).
+   - Set `dist[0] = 0` (distance from node `0` to itself is `0`).
+   - Set `ways[0] = 1` (only one way to stay at the source).
+
+3. **Dijkstra's Algorithm:**
+   - Use the priority queue to process the node with the smallest distance.
+   - For each neighbor of the current node:
+     - If a shorter path is found, update the distance and reset the number of ways.
+     - If a path with the same shortest distance is found, add the number of ways to reach the current node to the neighbor's path count.
+
+4. **Return Result:**
+   - The number of ways to reach the destination node (`n-1`) is returned modulo \( 10^9 + 7 \).
+
+---
+
+### **Code Explanation**
+#### 1. **Graph Representation**
+```java
+ArrayList<ArrayList<Pair>> adj = new ArrayList<>();
+for(int i = 0; i < n; i++) {
+    adj.add(new ArrayList<>());
+}
+for(int i = 0; i < m; i++) {
+    adj.get(roads[i][0]).add(new Pair(roads[i][2], roads[i][1]));
+    adj.get(roads[i][1]).add(new Pair(roads[i][2], roads[i][0]));
+}
+
+Time Complexity: O((n+m)log(n)) 
+The program processes all m roads to build the adjacency list.
+This operation takes O(m) time.
+Dijkstra’s Algorithm:
+Each node and its neighbors are processed through the priority queue.
+Popping a node from the priority queue takes O(log n) time.
+Over all m edges, the operations amount to O((n + m) log n) time.
+Overall Time Complexity:
+The dominant factor is Dijkstra’s algorithm, so the time complexity is O((n + m) log n).
+
+Space Complexity: O(n)
+The adjacency list stores all m edges, requiring O(m) space.
+The dist and ways arrays require O(n) space each.
+The priority queue stores up to O(n) nodes.
+Overall Space Complexity:
+The total space complexity is O(n + m)

Problems/1976 - Number of Ways to Arrive at Destination - Medium/Solution.java

@@ -0,0 +1,52 @@
+class Pair{
+    long first;
+    long second;
+    public Pair(long first,long second) {
+        this.first = first;
+        this.second = second;
+    }
+}
+class Solution {
+    public int countPaths(int n, int[][] roads) {
+        ArrayList<ArrayList<Pair>> adj = new ArrayList<>();
+        for(int i = 0;i < n; i++){
+            adj.add(new ArrayList<>());
+        }
+        int m = roads.length;
+        for(int i = 0; i<m; i++){
+            adj.get(roads[i][0]).add(new Pair(roads[i][2], roads[i][1]));
+            adj.get(roads[i][1]).add(new Pair(roads[i][2], roads[i][0]));
+        }
+        PriorityQueue<Pair> pq = new PriorityQueue<>((x,y)->Long.compare(x.first, y.first));
+        long dist[] = new long[n];
+        long ways[] = new long[n];
+      
+
+        for(int i = 0;i < n; i++){
+            dist[i] = Long.MAX_VALUE;
+            ways[i] = 0;
+        }
+        pq.add(new Pair(0,0));
+        dist[0] = 0;
+        ways[0] = 1;
+        int mod = (int)(1e9 + 7);
+        while(!pq.isEmpty()){
+            long dis = pq.peek().first;
+            int node = (int)(pq.peek().second);
+            pq.remove();
+            for(Pair it : adj.get(node)){
+                long newDis = it.first;
+                int adjNode = (int)it.second;
+                 if(dis + newDis < dist[adjNode]){
+                    dist[adjNode] = dis + newDis;
+                    pq.add(new Pair(dis + newDis, adjNode));
+                    ways[adjNode]  = ways[node];
+                }
+                else if(dis + newDis == dist[adjNode]){
+                    ways[adjNode] = (ways[adjNode] + ways[node])%mod;
+                }
+            }
+        }
+        return (int)(ways[n-1]%mod);
+    }
+}

Problems/3191 - Minimum Operations to Make Binary Array Elements Equal to One I - Medium/Explanation.md

@@ -0,0 +1,59 @@
+# Explanation of the Code
+
+## **Objective**
+The program aims to count the minimum number of operations required to transform a binary array `nums` into a specific format where every element equals `1`. Each operation flips the value of three consecutive elements in the array (from `0` to `1` or vice versa).
+
+---
+
+## **Step-by-Step Explanation**
+
+### **1. Initialize Variables**
+```java
+int n = nums.length;
+int count = 0;
+
+for (int i = 0; i <= n - 3; i++) {
+    if (nums[i] == 0) {
+        nums[i] = 1 - nums[i];
+        nums[i + 1] = 1 - nums[i + 1];
+        nums[i + 2] = 1 - nums[i + 2];
+        count++;
+    }
+}
+This loop checks each element nums[i] in the array until n - 3 (ensuring there are at least three consecutive elements remaining).
+
+Condition (nums[i] == 0):
+
+If the current element is 0, it is flipped, along with the next two consecutive elements.
+
+This transformation ensures the first position of the current window becomes 1.
+
+count is incremented to record the operation.
+
+for (int i = n - 2; i < n; i++) {
+    if (nums[i] != 1) {
+        return -1;
+    }
+}
+After completing transformations for three-element windows, the final two elements are checked:
+
+If either of them is not 1, it means the target format cannot be achieved, and the function returns -1.
+
+return count;
+If all elements are transformed into 1, the function returns the total number of operations required.
+
+Time Complexity
+First Loop (for i = 0 to n - 3):
+
+Iterates up to n - 3 elements, performing constant-time operations for each. Time Complexity: O(n)
+
+Second Loop (for i = n - 2 to n):
+
+Iterates over the last two elements of the array. Time Complexity: O(1)
+
+Overall Time Complexity: O(n)
+
+Space Complexity
+The program modifies the input array nums in-place and uses only a few integer variables (n, count, i). No additional data structures are required.
+
+Overall Space Complexity: O(1)

Problems/3191 - Minimum Operations to Make Binary Array Elements Equal to One I - Medium/Solution.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        int n = nums.length;
+        int count = 0;
+
+        for (int i = 0; i <= n - 3; i++) {
+            if (nums[i] == 0) {
+              
+                nums[i] = 1 - nums[i];
+                nums[i + 1] = 1 - nums[i + 1];
+                nums[i + 2] = 1 - nums[i + 2];
+                count++;
+            }
+        }
+
+        for (int i = n - 2; i < n; i++) {
+            if (nums[i] != 1) {
+                return -1; 
+            }
+        }
+
+        return count;
+    }
+}