Oct 2025 5 (#115)

* add changes

* add changes

* add changes

* add changes

* add changes

* add changes

* add change 3

* add change 4

* add change 5

* add changes 6

Author: afrozchakure

LeetCode/Algorithms/Medium/DetectSquares.cpp

@@ -0,0 +1,37 @@
+class DetectSquares {
+public:
+    unordered_map<vector<int>, int> ptsCount; 
+    vector<vector<int>> points; 
+    DetectSquares() {
+        
+    }
+    
+    void add(vector<int> point) {
+        ptsCount[point]++;     
+        points.push_back(point); 
+    }
+    
+    int count(vector<int> point) {
+        int result = 0; 
+        int px = point[0]; 
+        int py = point[1]; 
+
+        for(auto &ele: points) {
+            int x = ele[0]; 
+            int y = ele[1];
+            if(abs(py - y) != abs(px - x) or x == px or y == py) {
+                continue; 
+            }
+
+            result += ptsCount[{x, py}] * ptsCount[{px, y}];
+        }
+        return result; 
+    }
+};
+
+/**
+ * Your DetectSquares object will be instantiated and called as such:
+ * DetectSquares* obj = new DetectSquares();
+ * obj->add(point);
+ * int param_2 = obj->count(point);
+ */

LeetCode/Algorithms/Medium/DetonateTheMaximumBombs.cpp

@@ -0,0 +1,51 @@
+class Solution {
+    public:
+
+
+        int maximumDetonation(vector<vector<int>>& bombs) {
+            
+            vector<vector<int>> adj(bombs.size()); 
+
+            for(int i=0; i<bombs.size(); i++) {
+                for(int j=i + 1; j<bombs.size(); j++) {
+                    auto &temp = bombs[i]; 
+                    int x1 = temp[0]; 
+                    int y1 = temp[1]; 
+                    int r1 = temp[2]; 
+
+                    auto &temp2 = bombs[j]; 
+                    int x2 = temp2[0]; 
+                    int y2 = temp2[1]; 
+                    int r2 = temp2[2]; 
+
+                    int d = sqrt((x1 - x2)**2 + (y1 - y2)**2);
+
+                    if(d <= r1) {
+                        adj[i].push_back(j);   // bomb at index i can detonate bomb at index j 
+                    }
+                    if(d <= r2) {
+                        adj[j].push_back(i);  // bomb at index j can detonate bomb at index i 
+                    }
+                }
+            }
+
+            int result = 0; 
+            unordered_set<int> set; 
+            for(int i=0; i<bombs.size(); i++) {
+                
+                result = max(res, dfs(i, visit)); 
+            }
+        }
+
+        dfs(int i, unordered_set<int> &visit) {
+            if(visit.find(i) != visit.end()) {
+                return 0; 
+            }
+
+            visit.insert(i); 
+            for(auto nei: adj[i]) {
+                dfs(nei, visit); 
+            }
+            return len(visit); 
+        }
+    };

LeetCode/Algorithms/Medium/FindClosestNodeToGivenTwoNodes.cpp

@@ -0,0 +1,53 @@
+class Solution {
+    public:
+        int closestMeetingNode(vector<int>& edges, int node1, int node2) {
+            int n = edges.size(); 
+            vector<vector<int>> adj(n); 
+            
+            // some of the destination nodes can be -1
+            // it would also get added in the distance map in bfs traversal 
+            // it won't affect our result because we are traversing 
+            // from 0 to n indexes only 
+            for(int i=0; i<edges.size(); i++) {
+                adj[i].push_back(edges[i]); 
+            }
+
+            unordered_map<int, int> node1Dist;  // map node -> distance from node1
+            unordered_map<int, int> node2Dist;  // map node -> distance fromm node2
+
+            bfs(node1, node1Dist, adj); 
+            bfs(node2, node2Dist, adj);
+            
+            int res = -1; 
+            int resDist = INT_MAX; 
+
+            for(int i=0; i<n; i++) {
+                if(node1Dist.count(i) && node2Dist.count(i)) {
+                    dist = max(node1Dist[i] node2Dist[i]);
+                    if(dist < resDist) {  // we have to take the smallest distance node and return the result node 
+                        res = i; 
+                        resDist = dist; 
+                    }
+                }
+            }
+            return res; 
+        }
+
+        void bfs(int src, unordered_map<int, int> distMap, vector<vector<int>> &adj) {
+            queue<pair<int, int>> q; 
+            q.push({src, 0}); 
+            distMap[src] = 0; 
+            while(!q.empty()) {
+                auto temp = q.front(); 
+                int node = temp.first; 
+                int dist = temp.second; 
+
+                for(auto &nei: adj[node]) {
+                    if(distMap.find(i) == distMap.end()) {
+                        q.push({nei, dist + 1}); 
+                        distMap[nei] = dist + 1;
+                    }
+                }
+            }
+        }
+    };

LeetCode/Algorithms/Medium/FlipColumnsForMaximumNumberOfEqualRows.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {
+        unordered_map<string, int> m; 
+        int count = 0; 
+        for(auto &mat: matrix) {
+            string s = "";
+            for(auto &ele: mat) {
+                s += to_string(ele); 
+            }
+
+            if(s[0] == '1') {
+                for(int i=0; i<s.size(); i++) {
+                    if(s[i] == '0') {
+                        s[i] = '1';
+                    } else {
+                        s[i] = '0';
+                    }
+                }
+            }
+
+            m[s] += 1; 
+        }
+
+        for(auto &ele: m) {
+            count = max(count, ele.second); 
+        }
+        return count; 
+    }
+};

LeetCode/Algorithms/Medium/GridGame.cpp

@@ -0,0 +1,56 @@
+class Solution {
+public:
+    #define ll long long 
+    long long gridGame(vector<vector<int>>& grid) {
+        int n = grid[0].size();
+        if(n < 2) return 0; 
+
+        ll minSum = LONG_MAX;  // remember this is LONG_MAX
+        ll bottomSum = 0;
+        ll topSum = accumulate(grid[0].begin(), grid[0].end(), 0LL); 
+
+        for(int i=0; i<n; i++) {
+            topSum -= grid[0][i];
+            minSum = min(minSum, max(topSum, bottomSum));
+            bottomSum += grid[1][i];
+        }
+        return minSum; 
+    }
+};
+
+// Time Complexity - O(N)
+// Space Complmexity - O(1), since we're using variables
+
+/*
+
+Required time complexity - < N^2
+
+Note: If a robo comes down then it can't go up. 
+
+Robo 1 choses a path which minimizes the sum for robo-2 
+Return the sum for Robo - 2 (it also tries to maximize the sum)
+
+Optimal strategy -> 
+
+
+Robo-2 picks = max(top sum, bottom sum)
+
+Robo-1 will choose a partition point which 
+minimizes the value for Robo-2 pick 
+
+for(pp=0; pp<n; ++pp) {
+    topSum += grid[0][pp];
+    minSum = min(minSum, max(topSum, bottomSum));
+    bottomSum -= grid[1][pp];
+}
+
+
+Available Option
+
+TopSum = 10
+minSum = INT_MAX
+BottomSum = 0 
+
+Time Complexity - O(N)
+Space Complmexity - O(1), since we're using variables
+*/

LeetCode/Algorithms/Medium/LongestNiceSubarray.cpp

@@ -0,0 +1,117 @@
+class Solution {
+public:
+    int longestNiceSubarray(vector<int>& nums) {
+        int left =0 ; 
+        int right = 0;
+        int max_window_size = 0; 
+        int curr_sum = 0; 
+        int curr_xor = 0; 
+        int n = nums.size(); 
+
+        while(left <= right && right < n) {
+            curr_sum += nums[right]; 
+            curr_xor ^= nums[right]; 
+
+            while(curr_xor != curr_sum) {
+                curr_sum -= nums[left]; 
+                curr_xor ^= nums[left];
+                left++; 
+            }
+            
+            max_window_size = max(max_window_size, right - left + 1);
+            right++; 
+        }
+        return max_window_size; 
+    }
+};
+
+/*
+
+Time Complexity - O(N)
+Space Complexity - O(1)
+
+Bitwise AND 
+
+     x ---> 8 ----> 1000
+   & y ---> 6 ----> 0110 
+     ?      0       0000
+
+If not set bits occur at same position then Bitwise AND is always 0
+
+  x ->  10 --->    1010 
+  y ->   6  ---> & 0110 
+                   0010 (non-zero)
+
+Bitwise and with sum 
+
+If x and y have no set bits at the same position then 
+
+x ^ y = x + y , this means Bitwise and will be 0 
+
+                                            |
+(10) x   --->   1010      (10) x   --->   1010 
+(4)  y   ---> ^ 0100      (6)  y   ---> ^ 0110 
+(14) x^y --->   1110      (12) x^y --->   1100  (not equal)
+Equal 
+
+10 + 6 = 16 
+
+Note: If x and y have corresponding set bits at the same position then XOR 
+will make it 0 in result 
+
+// XOR decreases value in this case 
+
+Nice Subarray 
+ 
+ Goal: find longest subarray starting at index 0    
+ 0  1  2  3
+[8, 5, 2, 6]
+
+
+    8 4 2 1
+8 - 1 0 0 0
+5 - 0 1 0 1
+2 - 0 0 1 0
+6 - 0 1 1 0 
+
+curr_sum = 0 -> 8 -> 13 -> 15 -> 21 - 8 = 13 - 5 = 8 - 2 = 6 
+xor_sum =  0 -> 8 -> 13 -> 15 -> 9 -> 1 (xor 5) -> 4 (xor 2) -> 6 (both equal)
+
+when it seases to be valid, remove 8 from 21 (take xor with 8 and minus 8 from sum)
+
+8 ^ 8 = 0 
+
+1 1 0 1
+0 0 1 0 ^
+1 1 1 1 
+0 1 1 0 ^
+1 0 0 1 
+
+1 0 0 1  - 9 
+1 0 0 0  - 8 (xor)
+0 0 0 1  - 1 
+0 1 0 1  - 5 (xor)
+0 1 0 0  - 4
+0 0 1 0 -> 2 (xor)
+0 1 1 0 -> 6
+ 
+max_window_size 
+curr_sum =  0 
+xor_sum = 0
+
+while(left <= right && right < n) {
+    curr_sum += a[right];
+    curr_xor ^= a[right];
+
+    if(curr_sum == curr_xor) {
+        right++; 
+    } else {
+        curr_sum -= a[left];
+        curr_xor ^= a[left];
+        left++;
+    }
+
+    max_window_size = max(max_window_size, right -left + 1);
+}
+*/
+