UI enhancements

Author: Prakash-sa

Dynamic Programming/Kadane/1594. Maximum Non Negative Product in a Matrix.py

@@ -0,0 +1,67 @@
+# https://leetcode.com/problems/maximum-non-negative-product-in-a-matrix/description/
+
+'''
+You are given a m x n matrix grid. Initially, you are located at the top-left corner (0, 0), and in each step, you can only move right or down in the matrix.
+Among all possible paths starting from the top-left corner (0, 0) and ending in the bottom-right corner (m - 1, n - 1), find the path with the maximum non-negative product. The product of a path is the product of all integers in the grid cells visited along the path.
+Return the maximum non-negative product modulo 109 + 7. If the maximum product is negative, return -1.
+Notice that the modulo is performed after getting the maximum product.
+
+
+Example 1:
+Input: grid = [[-1,-2,-3],[-2,-3,-3],[-3,-3,-2]]
+Output: -1
+Explanation: It is not possible to get non-negative product in the path from (0, 0) to (2, 2), so return -1.
+
+Example 2:
+Input: grid = [[1,-2,1],[1,-2,1],[3,-4,1]]
+Output: 8
+Explanation: Maximum non-negative product is shown (1 * 1 * -2 * -4 * 1 = 8).
+
+Example 3:
+Input: grid = [[1,3],[0,-4]]
+Output: 0
+Explanation: Maximum non-negative product is shown (1 * 0 * -4 = 0).
+ 
+Constraints:
+m == grid.length
+n == grid[i].length
+1 <= m, n <= 15
+-4 <= grid[i][j] <= 4
+'''
+
+class Solution:
+    MOD=10**9+7
+    def maxProductPath(self, grid: List[List[int]]) -> int:
+        m,n=len(grid),len(grid[0])
+        maxgt=[[0]*n for _ in range(m)]
+        minlt=[[0]*n for _ in range(m)]
+
+        maxgt[0][0]=minlt[0][0]=grid[0][0]
+
+        for i in range(1,n):
+            maxgt[0][i]=minlt[0][i]=maxgt[0][i-1]*grid[0][i]
+        for i in range(1,m):
+            maxgt[i][0]=minlt[i][0]=maxgt[i-1][0]*grid[i][0]
+        
+        for i in range(1,m):
+            for j in range(1,n):
+                if grid[i][j]>=0:
+                    maxgt[i][j]=max(maxgt[i][j-1],maxgt[i-1][j])*grid[i][j]
+                    minlt[i][j]=min(minlt[i][j-1],minlt[i-1][j])*grid[i][j]
+                else:
+                    maxgt[i][j]=min(minlt[i][j-1],minlt[i-1][j])*grid[i][j]
+                    minlt[i][j]=max(maxgt[i][j-1],maxgt[i-1][j])*grid[i][j]
+
+        return maxgt[m-1][n-1]%self.MOD if maxgt[m-1][n-1]>=0 else -1
+
+
+'''
+Complexity Analysis
+Let m and n be the number of rows and columns of the matrix.
+
+Time complexity: O(mn).
+We traverse each cell once, and each transition takes constant time.
+
+Space complexity: O(mn).
+We maintain two matrices of size m×n.
+'''

Segment Trees/README.md

@@ -2,6 +2,19 @@
 
 This directory stores advanced range query data structures in Python.
 
+## Sqrt decomposition (`SQRT_DECOMPOSITION.md`)
+- Splits an array into blocks of size about `sqrt(n)`.
+- Precomputes one summary per block (sum/min/max/frequency, depending on the problem).
+- Best fit when:
+  - You need something simpler than a segment tree.
+  - Constraints are moderate (`n, q` around `10^5`).
+  - Queries are online and updates are not too heavy.
+- Typical complexity:
+  - Build: `O(n)`
+  - Query: `O(sqrt(n))`
+  - Point update: `O(1)` or `O(sqrt(n))`, depending on block metadata
+- Closely related: Mo's algorithm uses the same block intuition for offline queries.
+
 ## Fenwick tree (`feenwick.py`)
 - Supports point updates and prefix sums in `O(log n)` using least-significant-bit jumps.
 - Ideal for:
@@ -26,3 +39,12 @@ This directory stores advanced range query data structures in Python.
 ## When to use which
 - Fenwick tree: easier to code, handles prefix queries and range updates with small tweaks.
 - Segment tree: more flexible (min/max, gcd, lazy propagation, two-dimensional variants).
+- Sqrt decomposition: simpler than a segment tree, strong fallback for online range queries when `O(sqrt(n))` is fast enough.
+- Mo's algorithm: use for offline range queries, especially distinct-count and frequency-style problems.
+
+## Contest decision guide
+- Static range sum, no updates: prefix sum.
+- Prefix/range sum with point updates: Fenwick tree.
+- Complex online range queries or heavy updates: segment tree.
+- Medium constraints and faster implementation pressure: sqrt decomposition.
+- Offline frequency/distinct queries: Mo's algorithm.

Segment Trees/SQRT_DECOMPOSITION.md

@@ -0,0 +1,240 @@
+# Square Root Decomposition
+
+Square root decomposition is a block-based range-query technique. Instead of processing every element inside a query range, split the array into blocks of size about `sqrt(n)` and precompute one answer per block.
+
+It belongs to the broader topic of data structures and range query optimization.
+
+## What it does
+
+- Break an array into blocks of size about `sqrt(n)`.
+- Store precomputed information for each block.
+- Answer queries by combining:
+  - a partial prefix block
+  - zero or more full blocks
+  - a partial suffix block
+
+This is usually much faster than brute force and much easier to implement than a segment tree.
+
+## Where it fits
+
+- Data Structures
+- Range Queries
+- Query Processing
+- Block Decomposition
+
+Closely related topics:
+
+- Prefix Sum
+- Fenwick Tree
+- Segment Tree
+- Mo's Algorithm
+
+## When to use it
+
+Use sqrt decomposition when:
+
+- You have many range queries on an array.
+- Updates exist, but the problem does not justify a full segment tree.
+- `O(sqrt(n))` per query is fast enough for the given constraints.
+- You want a contest-safe implementation with low bug risk.
+
+Common use cases:
+
+- Range sum
+- Range min / max
+- Frequency counting per block
+- Jump queries
+- Range updates with block rebuild ideas
+
+## Complexity
+
+- Build: `O(n)`
+- Query: `O(sqrt(n))`
+- Point update: `O(1)` for block sums, sometimes `O(sqrt(n))` if block metadata must be rebuilt
+- Space: `O(n)`
+
+## Core intuition
+
+Array:
+
+```text
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+Choose block size `3`:
+
+```text
+[1,2,3] [4,5,6] [7,8,9]
+```
+
+Store block sums:
+
+```text
+[6, 15, 24]
+```
+
+Now query sum from index `2` to `7`:
+
+- Take partial left block: `3`
+- Take full middle block: `4 + 5 + 6 = 15`
+- Take partial right block: `7 + 8`
+
+Total: `26`
+
+The key idea is that full blocks are answered in `O(1)` each.
+
+## Python template
+
+```python
+import math
+
+
+class SqrtDecomposition:
+    def __init__(self, nums):
+        self.n = len(nums)
+        self.block_size = int(math.sqrt(self.n)) + 1
+        self.nums = nums[:]
+        self.blocks = [0] * ((self.n + self.block_size - 1) // self.block_size)
+
+        for i, val in enumerate(self.nums):
+            self.blocks[i // self.block_size] += val
+
+    def update(self, idx, val):
+        block_idx = idx // self.block_size
+        self.blocks[block_idx] += val - self.nums[idx]
+        self.nums[idx] = val
+
+    def query(self, left, right):
+        total = 0
+        start_block = left // self.block_size
+        end_block = right // self.block_size
+
+        if start_block == end_block:
+            for i in range(left, right + 1):
+                total += self.nums[i]
+            return total
+
+        end_of_start = min(self.n, (start_block + 1) * self.block_size)
+        for i in range(left, end_of_start):
+            total += self.nums[i]
+
+        for block in range(start_block + 1, end_block):
+            total += self.blocks[block]
+
+        start_of_end = end_block * self.block_size
+        for i in range(start_of_end, right + 1):
+            total += self.nums[i]
+
+        return total
+
+
+nums = [1, 2, 3, 4, 5, 6, 7, 8]
+sq = SqrtDecomposition(nums)
+
+print(sq.query(2, 6))  # 25
+sq.update(3, 10)       # nums[3] = 10
+print(sq.query(2, 6))  # 31
+```
+
+## Decision map
+
+### 1. Prefix Sum
+
+Use when:
+
+- There are only queries.
+- There are no updates.
+- The operation is additive and easy to prefix.
+
+Complexity:
+
+- Build: `O(n)`
+- Query: `O(1)`
+
+### 2. Fenwick Tree
+
+Use when:
+
+- You need point updates.
+- Queries are prefix sums or reducible to prefix sums.
+- You want `O(log n)` with a compact implementation.
+
+Complexity:
+
+- Query: `O(log n)`
+- Update: `O(log n)`
+
+### 3. Segment Tree
+
+Use when:
+
+- Queries are more complex: min, max, gcd, custom merge.
+- You need many updates and many queries.
+- You may need lazy propagation.
+
+Complexity:
+
+- Query: `O(log n)`
+- Update: `O(log n)`
+
+### 4. Sqrt Decomposition
+
+Use when:
+
+- You want simpler code.
+- Constraints are moderate.
+- `O(sqrt(n))` is acceptable.
+
+Complexity:
+
+- Query: `O(sqrt(n))`
+- Update: `O(1)` or `O(sqrt(n))`
+
+### 5. Mo's Algorithm
+
+Use when:
+
+- Queries are offline.
+- The answer depends on frequencies or distinct counts.
+- Reordering queries helps maintain a moving window.
+
+Complexity:
+
+- About `O((n + q) * sqrt(n))`
+
+## Quick contest checklist
+
+Ask:
+
+1. Are there updates?
+2. Are the queries online or offline?
+3. Is the operation simple sum/frequency, or a custom merge?
+4. Is implementation speed more important than asymptotic optimality?
+
+Typical choices:
+
+- No updates: prefix sum
+- Sum with point updates: Fenwick tree
+- Complex range query: segment tree
+- Simple and good enough: sqrt decomposition
+- Offline distinct/frequency query: Mo's algorithm
+
+## Interview and contest notes
+
+- Sqrt decomposition is often the easiest correct solution under time pressure.
+- It is a strong stepping stone before learning segment trees and Mo's algorithm.
+- If `O(sqrt(n))` is too slow, upgrade to Fenwick tree or segment tree.
+- If the problem is offline and frequency-based, think about Mo's algorithm immediately.
+
+## Practice ideas
+
+- Range sum query with point update
+- Range minimum query with updates
+- Distinct elements in range
+- Frequency of a value in range
+- Jump query / teleport blocks
+- Offline range query reordering with Mo's algorithm
+
+## Recommended study order
+
+Prefix Sum -> Fenwick Tree -> Sqrt Decomposition -> Segment Tree -> Mo's Algorithm