Merge branch 'main' into feature/LIS

Author: adityacosmos24

package-lock.json

@@ -0,0 +1,18 @@
+export function floodFill(mat, x, y, targetColor, newColor, steps = []) {
+  const rows = mat.length;
+  const cols = mat[0].length;
+
+  if (x < 0 || y < 0 || x >= rows || y >= cols) return;
+  if (mat[x][y] !== targetColor) return;
+
+  steps.push({ x, y });
+
+  mat[x][y] = newColor;
+
+  floodFill(mat, x + 1, y, targetColor, newColor, steps);
+  floodFill(mat, x - 1, y, targetColor, newColor, steps);
+  floodFill(mat, x, y + 1, targetColor, newColor, steps);
+  floodFill(mat, x, y - 1, targetColor, newColor, steps);
+
+  return steps;
+}

src/algorithms/Recursion/FloodFill.js

@@ -0,0 +1,151 @@
+export function rodCuttingTopDown(prices) {
+    const n = prices.length;
+    const memo = new Array(n + 1).fill(null); 
+    const steps = []; 
+
+    function solve(k) {
+        steps.push({
+            array: [...memo],
+            currentIndex: k, 
+            readingIndices: [],
+            priceIndex: null,
+            message: `Calling solve(k = ${k}).`
+        });
+
+        if (k === 0) {
+            steps.push({
+                array: [...memo],
+                currentIndex: k,
+                readingIndices: [],
+                priceIndex: null,
+                message: `Base case: solve(0) = 0.`
+            });
+            return 0;
+        }
+
+        if (memo[k] !== null) {
+            steps.push({
+                array: [...memo],
+                currentIndex: k,
+                readingIndices: [],
+                priceIndex: null,
+                message: `Memo hit: solve(${k}) is already computed as ${memo[k]}.`
+            });
+            return memo[k];
+        }
+
+        let currentMaxProfit = -1;
+
+        for (let j = 1; j <= k; j++) {
+            steps.push({
+                array: [...memo],
+                currentIndex: k,
+                readingIndices: [],
+                priceIndex: j - 1, 
+                message: `... for k = ${k}, trying cut j = ${j}. Need to find solve(${k - j}).`
+            });
+
+            const remainingProfit = solve(k - j);
+            let profit = prices[j - 1] + remainingProfit;
+
+            steps.push({
+                array: [...memo],
+                currentIndex: k,
+                readingIndices: [k - j], 
+                priceIndex: j - 1, 
+                message: `... cut j = ${j} gives profit = prices[${j - 1}] (${prices[j-1]}) + solve(${k - j}) (${remainingProfit}) = ${profit}.`
+            });
+
+            if (profit > currentMaxProfit) {
+                currentMaxProfit = profit;
+            }
+        }
+
+        memo[k] = currentMaxProfit;
+
+        steps.push({
+            array: [...memo], 
+            currentIndex: k,
+            readingIndices: [],
+            priceIndex: null,
+            message: `Computed solve(${k}) = ${currentMaxProfit}. Storing in memo[${k}].`
+        });
+
+        return currentMaxProfit;
+    }
+
+    const result = solve(n);
+
+    steps.push({
+        array: [...memo],
+        currentIndex: n,
+        readingIndices: [],
+        priceIndex: null,
+        message: `Computation complete. Max profit for a rod of length ${n} is ${result}.`
+    });
+
+    return { steps, result };
+}
+
+
+export function rodCuttingBottomUp(prices) {
+    const n = prices.length;
+    const dp = new Array(n + 1).fill(0); 
+    const steps = []; 
+
+    steps.push({
+        array: [...dp],
+        currentIndex: 0,
+        readingIndices: [],
+        priceIndex: null,
+        message: `Base case: Max profit for length 0 is 0. dp[0] = 0.`
+    });
+
+    for (let i = 1; i <= n; i++) {
+        let currentMaxProfit = -1;
+
+        steps.push({
+            array: [...dp],
+            currentIndex: i, 
+            readingIndices: [],
+            priceIndex: null,
+            message: `Calculating max profit for length i = ${i}.`
+        });
+
+        for (let j = 1; j <= i; j++) {
+            let profit = prices[j - 1] + dp[i - j];
+
+            steps.push({
+                array: [...dp],
+                currentIndex: i, 
+                readingIndices: [i - j], 
+                priceIndex: j - 1, 
+                message: `... trying cut j = ${j}. Profit = prices[${j - 1}] (${prices[j-1]}) + dp[${i - j}] (${dp[i-j]}) = ${profit}.`
+            });
+
+            if (profit > currentMaxProfit) {
+                currentMaxProfit = profit;
+            }
+        }
+
+        dp[i] = currentMaxProfit;
+
+        steps.push({
+            array: [...dp], 
+            currentIndex: i,
+            readingIndices: [],
+            priceIndex: null,
+            message: `Max profit for length ${i} is ${currentMaxProfit}. Storing in dp[${i}].`
+        });
+    }
+
+    steps.push({
+        array: [...dp],
+        currentIndex: n,
+        readingIndices: [],
+        priceIndex: null,
+        message: `Computation complete. Max profit for a rod of length ${n} is ${dp[n]}.`
+    });
+
+    return { steps, result: dp[n] };
+}

src/algorithms/dynamic-programming/rodCutting.js

@@ -0,0 +1,96 @@
+// src/algorithms/graph/prim.js
+
+// Build adjacency list from list of edges
+function buildAdjacency(edges, n) {
+  const adj = Array.from({ length: n }, () => []);
+  for (const e of edges) {
+    const u = e.from - 1;
+    const v = e.to - 1;
+    const w = e.weight;
+
+    adj[u].push({ u, v, w });
+    adj[v].push({ u: v, v: u, w }); // undirected graph
+  }
+  return adj;
+}
+
+/**
+ * Prim's Algorithm – Step Generator
+ * Yields one step at a time:
+ *  type: "consider" | "add" | "skip" | "done"
+ *  edge: {from, to, weight}
+ *  visited: boolean[]
+ *  frontier: edge[]
+ *  mst: collected MST edges
+ */
+export function* primSteps(edges, nodeCount, startNode = 1) {
+  if (nodeCount === 0) {
+    yield { type: "done", mst: [], visited: [], frontier: [] };
+    return;
+  }
+
+  const adj = buildAdjacency(edges, nodeCount);
+  const visited = Array(nodeCount).fill(false);
+  const mst = [];
+  const frontier = [];
+
+  const pushEdges = (u) => {
+    for (const { v, w } of adj[u]) {
+      if (!visited[v]) {
+        frontier.push({ from: u + 1, to: v + 1, weight: w });
+      }
+    }
+  };
+
+  const startIdx = Math.max(1, Math.min(startNode, nodeCount)) - 1;
+  visited[startIdx] = true;
+  pushEdges(startIdx);
+
+  while (mst.length < nodeCount - 1 && frontier.length > 0) {
+    frontier.sort((a, b) => a.weight - b.weight);
+    const edge = frontier.shift();
+
+    yield {
+      type: "consider",
+      edge,
+      visited: [...visited],
+      frontier: [...frontier],
+      mst: [...mst],
+    };
+
+    const u = edge.from - 1;
+    const v = edge.to - 1;
+
+    if (visited[u] && visited[v]) {
+      yield {
+        type: "skip",
+        edge,
+        visited: [...visited],
+        frontier: [...frontier],
+        mst: [...mst],
+      };
+      continue;
+    }
+
+    const nextNode = visited[u] ? v : u;
+    visited[nextNode] = true;
+
+    mst.push(edge);
+    pushEdges(nextNode);
+
+    yield {
+      type: "add",
+      edge,
+      visited: [...visited],
+      frontier: [...frontier],
+      mst: [...mst],
+    };
+  }
+
+  yield {
+    type: "done",
+    mst: [...mst],
+    visited: [...visited],
+    frontier: [...frontier],
+  };
+}