Algorithms on Chinese Powered Labs

Union Find (Disjoint Set) - Complete Guide

Tue, 18 Nov 2025 16:52:44 +0000

Union Find (Disjoint Set Union, DSU) is a data structure for tracking elements partitioned into disjoint sets. It efficiently handles union and find operations.

What is Union Find? #

A data structure that maintains a collection of disjoint (non-overlapping) sets and supports two operations:

Find - Determine which set an element belongs to
Union - Merge two sets into one

Applications:

Detect cycles in graphs
Find connected components
Kruskal’s MST algorithm
Network connectivity
Image processing

Basic Implementation #

class UnionFind {
 constructor(size) {
 this.parent = Array.from({ length: size }, (_, i) => i);
 this.count = size; // Number of disjoint sets
 }

 find(x) {
 if (this.parent[x] !== x) {
 return this.find(this.parent[x]);
 }
 return x;
 }

 union(x, y) {
 const rootX = this.find(x);
 const rootY = this.find(y);

 if (rootX === rootY) {
 return false; // Already connected
 }

 this.parent[rootX] = rootY;
 this.count--;
 return true;
 }

 connected(x, y) {
 return this.find(x) === this.find(y);
 }

 getCount() {
 return this.count;
 }
}

// Usage
const uf = new UnionFind(5);
uf.union(0, 1);
uf.union(1, 2);
console.log(uf.connected(0, 2)); // true
console.log(uf.connected(0, 3)); // false
console.log(uf.getCount()); // 3 sets

Path Compression #

Optimize find operation by flattening tree structure.

Greedy Algorithms - Complete Guide

Sat, 25 Oct 2025 11:39:06 +0000

Greedy algorithms make locally optimal choices at each step to find a global optimum. This guide covers greedy strategies and classic problems.

What is a Greedy Algorithm? #

A greedy algorithm makes the best choice at each step without reconsidering previous choices. It builds up a solution piece by piece.

Key characteristics:

Makes locally optimal choice
Never reconsiders choices
Hopes to find global optimum

When to use:

Optimization problems
When local optimum leads to global optimum
Proof of correctness exists

Classic Examples #

Activity Selection #

Select maximum number of non-overlapping activities.

Dynamic Programming - Complete Guide

Mon, 22 Sep 2025 11:08:15 +0000

Dynamic Programming is a powerful technique for solving complex problems by breaking them down into simpler subproblems. This guide covers DP fundamentals and common patterns.

What is Dynamic Programming? #

Dynamic Programming (DP) is an optimization technique that solves problems by:

Breaking down into overlapping subproblems
Storing results of subproblems (memoization)
Reusing stored results instead of recomputing

When to Use DP? #

Use DP when a problem has:

Graph Traversal Algorithms - Complete Guide

Mon, 15 Sep 2025 12:47:39 +0000

Graph traversal is fundamental for solving many algorithmic problems. This guide covers depth-first search (DFS), breadth-first search (BFS), and their applications.

Graph Representation #

Adjacency List #

// Undirected graph
const graph = {
 0: [1, 2],
 1: [0, 2, 3],
 2: [0, 1, 4],
 3: [1, 4],
 4: [2, 3]
};

// Directed graph
const directedGraph = {
 'A': ['B', 'C'],
 'B': ['D'],
 'C': ['D', 'E'],
 'D': [],
 'E': []
};

// Weighted graph
const weightedGraph = {
 'A': [{ node: 'B', weight: 4 }, { node: 'C', weight: 2 }],
 'B': [{ node: 'D', weight: 3 }],
 'C': [{ node: 'D', weight: 1 }],
 'D': []
};

Adjacency Matrix #

// 0 1 2 3 4
const matrix = [
 [0, 1, 1, 0, 0], // 0
 [1, 0, 1, 1, 0], // 1
 [1, 1, 0, 0, 1], // 2
 [0, 1, 0, 0, 1], // 3
 [0, 0, 1, 1, 0] // 4
];

// Check if edge exists
const hasEdge = matrix[0][1] === 1; // true

Edge List #

const edges = [
 [0, 1],
 [0, 2],
 [1, 2],
 [1, 3],
 [2, 4],
 [3, 4]
];

Depth-First Search (DFS) #

Recursive DFS #

function dfs(graph, start, visited = new Set()) {
 console.log(start);
 visited.add(start);

 for (const neighbor of graph[start] || []) {
 if (!visited.has(neighbor)) {
 dfs(graph, neighbor, visited);
 }
 }
}

// Usage
const graph = {
 0: [1, 2],
 1: [0, 2, 3],
 2: [0, 1, 4],
 3: [1, 4],
 4: [2, 3]
};

dfs(graph, 0);
// Output: 0, 1, 2, 4, 3

Iterative DFS #

function dfsIterative(graph, start) {
 const visited = new Set();
 const stack = [start];

 while (stack.length > 0) {
 const node = stack.pop();

 if (!visited.has(node)) {
 console.log(node);
 visited.add(node);

 // Add neighbors in reverse order for same traversal as recursive
 for (let i = graph[node].length - 1; i >= 0; i--) {
 const neighbor = graph[node][i];
 if (!visited.has(neighbor)) {
 stack.push(neighbor);
 }
 }
 }
 }
}

dfsIterative(graph, 0);

DFS with Path Tracking #

function dfsPath(graph, start, end, visited = new Set(), path = []) {
 visited.add(start);
 path.push(start);

 if (start === end) {
 return path;
 }

 for (const neighbor of graph[start] || []) {
 if (!visited.has(neighbor)) {
 const result = dfsPath(graph, neighbor, end, visited, path);
 if (result) return result;
 }
 }

 path.pop();
 return null;
}

console.log(dfsPath(graph, 0, 3));
// [0, 1, 3]

All Paths #

function allPaths(graph, start, end, visited = new Set(), path = [], paths = []) {
 visited.add(start);
 path.push(start);

 if (start === end) {
 paths.push([...path]);
 } else {
 for (const neighbor of graph[start] || []) {
 if (!visited.has(neighbor)) {
 allPaths(graph, neighbor, end, visited, path, paths);
 }
 }
 }

 path.pop();
 visited.delete(start);

 return paths;
}

console.log(allPaths(graph, 0, 4));
// [[0, 1, 2, 4], [0, 1, 3, 4], [0, 2, 4]]

Breadth-First Search (BFS) #

Basic BFS #

function bfs(graph, start) {
 const visited = new Set();
 const queue = [start];
 visited.add(start);

 while (queue.length > 0) {
 const node = queue.shift();
 console.log(node);

 for (const neighbor of graph[node] || []) {
 if (!visited.has(neighbor)) {
 visited.add(neighbor);
 queue.push(neighbor);
 }
 }
 }
}

bfs(graph, 0);
// Output: 0, 1, 2, 3, 4

BFS Shortest Path #

function bfsShortestPath(graph, start, end) {
 const visited = new Set();
 const queue = [[start, [start]]];
 visited.add(start);

 while (queue.length > 0) {
 const [node, path] = queue.shift();

 if (node === end) {
 return path;
 }

 for (const neighbor of graph[node] || []) {
 if (!visited.has(neighbor)) {
 visited.add(neighbor);
 queue.push([neighbor, [...path, neighbor]]);
 }
 }
 }

 return null;
}

console.log(bfsShortestPath(graph, 0, 4));
// [0, 2, 4]

BFS Level Order #

function bfsLevelOrder(graph, start) {
 const visited = new Set();
 const queue = [[start, 0]];
 const levels = {};
 visited.add(start);

 while (queue.length > 0) {
 const [node, level] = queue.shift();

 if (!levels[level]) {
 levels[level] = [];
 }
 levels[level].push(node);

 for (const neighbor of graph[node] || []) {
 if (!visited.has(neighbor)) {
 visited.add(neighbor);
 queue.push([neighbor, level + 1]);
 }
 }
 }

 return Object.values(levels);
}

console.log(bfsLevelOrder(graph, 0));
// [[0], [1, 2], [3, 4]]

Cycle Detection #

Undirected Graph (DFS) #

function hasCycleDFS(graph) {
 const visited = new Set();

 function dfs(node, parent) {
 visited.add(node);

 for (const neighbor of graph[node] || []) {
 if (!visited.has(neighbor)) {
 if (dfs(neighbor, node)) {
 return true;
 }
 } else if (neighbor !== parent) {
 return true; // Back edge found
 }
 }

 return false;
 }

 for (const node in graph) {
 if (!visited.has(node)) {
 if (dfs(node, null)) {
 return true;
 }
 }
 }

 return false;
}

console.log(hasCycleDFS(graph)); // true

Directed Graph (DFS) #

function hasCycleDirected(graph) {
 const WHITE = 0; // Unvisited
 const GRAY = 1; // Visiting
 const BLACK = 2; // Visited

 const colors = {};

 for (const node in graph) {
 colors[node] = WHITE;
 }

 function dfs(node) {
 colors[node] = GRAY;

 for (const neighbor of graph[node] || []) {
 if (colors[neighbor] === GRAY) {
 return true; // Back edge - cycle found
 }

 if (colors[neighbor] === WHITE && dfs(neighbor)) {
 return true;
 }
 }

 colors[node] = BLACK;
 return false;
 }

 for (const node in graph) {
 if (colors[node] === WHITE) {
 if (dfs(node)) {
 return true;
 }
 }
 }

 return false;
}

Topological Sort #

DFS Approach #

function topologicalSort(graph) {
 const visited = new Set();
 const stack = [];

 function dfs(node) {
 visited.add(node);

 for (const neighbor of graph[node] || []) {
 if (!visited.has(neighbor)) {
 dfs(neighbor);
 }
 }

 stack.push(node);
 }

 for (const node in graph) {
 if (!visited.has(node)) {
 dfs(node);
 }
 }

 return stack.reverse();
}

const dag = {
 'A': ['C'],
 'B': ['C', 'D'],
 'C': ['E'],
 'D': ['F'],
 'E': ['F'],
 'F': []
};

console.log(topologicalSort(dag));
// ['B', 'D', 'A', 'C', 'E', 'F']

Kahn’s Algorithm (BFS) #

function topologicalSortBFS(graph) {
 const inDegree = {};
 const queue = [];
 const result = [];

 // Calculate in-degrees
 for (const node in graph) {
 if (!(node in inDegree)) {
 inDegree[node] = 0;
 }

 for (const neighbor of graph[node]) {
 inDegree[neighbor] = (inDegree[neighbor] || 0) + 1;
 }
 }

 // Add nodes with 0 in-degree
 for (const node in inDegree) {
 if (inDegree[node] === 0) {
 queue.push(node);
 }
 }

 while (queue.length > 0) {
 const node = queue.shift();
 result.push(node);

 for (const neighbor of graph[node] || []) {
 inDegree[neighbor]--;

 if (inDegree[neighbor] === 0) {
 queue.push(neighbor);
 }
 }
 }

 // Check for cycle
 if (result.length !== Object.keys(graph).length) {
 throw new Error('Graph has a cycle');
 }

 return result;
}

console.log(topologicalSortBFS(dag));

Connected Components #

function countComponents(n, edges) {
 const graph = Array(n).fill(0).map(() => []);

 // Build graph
 for (const [u, v] of edges) {
 graph[u].push(v);
 graph[v].push(u);
 }

 const visited = new Set();
 let count = 0;

 function dfs(node) {
 visited.add(node);

 for (const neighbor of graph[node]) {
 if (!visited.has(neighbor)) {
 dfs(neighbor);
 }
 }
 }

 for (let i = 0; i < n; i++) {
 if (!visited.has(i)) {
 count++;
 dfs(i);
 }
 }

 return count;
}

console.log(countComponents(5, [[0, 1], [1, 2], [3, 4]])); // 2

Bipartite Graph #

Check if graph can be colored with 2 colors.

Sliding Window Technique - Complete Guide

Sun, 14 Sep 2025 08:19:45 +0000

The sliding window technique is a powerful algorithmic pattern used to solve array and string problems efficiently. It reduces time complexity from O(n²) or O(n³) to O(n) in many cases.

What is the Sliding Window Technique? #

The sliding window technique involves creating a “window” that slides over the data structure (usually an array or string) to examine subsets of elements. Instead of recalculating from scratch for each position, we efficiently update the window by adding new elements and removing old ones.

String Algorithms - Complete Guide

Thu, 14 Aug 2025 10:23:15 +0000

String algorithms are fundamental for text processing, pattern matching, and manipulation. This guide covers essential string algorithms and common problems.

String Basics #

Character Operations #

const str = 'Hello';

// Character access
console.log(str[0]); // 'H'
console.log(str.charAt(0)); // 'H'
console.log(str.charCodeAt(0)); // 72

// String is immutable
str[0] = 'h'; // No effect
console.log(str); // 'Hello'

// Convert to array for manipulation
const arr = str.split('');
arr[0] = 'h';
console.log(arr.join('')); // 'hello'

String Comparison #

function compareStrings(s1, s2) {
 if (s1 === s2) return 0;
 return s1 < s2 ? -1 : 1;
}

console.log(compareStrings('abc', 'abd')); // -1
console.log(compareStrings('abc', 'abc')); // 0
console.log(compareStrings('abd', 'abc')); // 1

Pattern Matching #

Naive Pattern Matching #

function naiveSearch(text, pattern) {
 const n = text.length;
 const m = pattern.length;
 const positions = [];

 for (let i = 0; i <= n - m; i++) {
 let j;
 for (j = 0; j < m; j++) {
 if (text[i + j] !== pattern[j]) {
 break;
 }
 }
 if (j === m) {
 positions.push(i);
 }
 }

 return positions;
}

console.log(naiveSearch('ababcabcab', 'abc'));
// [2, 5]

KMP Algorithm #

Knuth-Morris-Pratt for efficient pattern matching.

Hash Tables and HashMaps Explained

Sun, 03 Aug 2025 14:42:07 +0000

Hash tables are one of the most important data structures in computer science. They provide extremely fast lookups, insertions, and deletions with O(1) average time complexity.

What is a Hash Table? #

A hash table (also called hash map) is a data structure that maps keys to values. It uses a hash function to compute an index into an array of buckets or slots, from which the desired value can be found.

Binary Search Algorithm - Complete Guide

Tue, 29 Jul 2025 16:33:28 +0000

Binary search is one of the most fundamental algorithms in computer science. It efficiently finds elements in sorted arrays with O(log n) time complexity.

What is Binary Search? #

Binary search is a divide-and-conquer algorithm that finds the position of a target value within a sorted array by repeatedly dividing the search interval in half.

How Binary Search Works #

Start with the middle element
If target equals middle, return the index
If target is less than middle, search the left half
If target is greater than middle, search the right half
Repeat until target is found or interval is empty

Visual Example #

Array: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
Target: 13

Step 1: Check middle (9)
[1, 3, 5, 7, 9, | 11, 13, 15, 17, 19]
13 > 9, search right half

Step 2: Check middle of right half (15)
[11, 13, 15, 17, 19]
 ^
13 < 15, search left half

Step 3: Check middle of left half (13)
[11, 13]
 ^
Found! Return index 6

Basic Implementation #

Iterative Approach #

function binarySearch(arr, target) {
 let left = 0;
 let right = arr.length - 1;

 while (left <= right) {
 const mid = Math.floor((left + right) / 2);

 if (arr[mid] === target) {
 return mid; // Found
 } else if (arr[mid] < target) {
 left = mid + 1; // Search right half
 } else {
 right = mid - 1; // Search left half
 }
 }

 return -1; // Not found
}

const arr = [1, 3, 5, 7, 9, 11, 13, 15];
console.log(binarySearch(arr, 7)); // 3
console.log(binarySearch(arr, 99)); // -1

Recursive Approach #

function binarySearchRecursive(arr, target, left = 0, right = arr.length - 1) {
 if (left > right) {
 return -1; // Not found
 }

 const mid = Math.floor((left + right) / 2);

 if (arr[mid] === target) {
 return mid;
 } else if (arr[mid] < target) {
 return binarySearchRecursive(arr, target, mid + 1, right);
 } else {
 return binarySearchRecursive(arr, target, left, mid - 1);
 }
}

const arr = [1, 3, 5, 7, 9, 11, 13, 15];
console.log(binarySearchRecursive(arr, 9)); // 4

Avoiding Integer Overflow #

In some languages, (left + right) / 2 can cause overflow. Use this instead:

Stacks and Queues - Complete Guide

Sat, 12 Jul 2025 09:55:23 +0000

Stacks and queues are fundamental linear data structures. This guide covers implementations, operations, and common problems.

Stack (LIFO - Last In First Out) #

Like a stack of plates - last one added is first one removed.

Stack Implementation #

class Stack {
 constructor() {
 this.items = [];
 }

 push(element) {
 this.items.push(element);
 }

 pop() {
 if (this.isEmpty()) return null;
 return this.items.pop();
 }

 peek() {
 if (this.isEmpty()) return null;
 return this.items[this.items.length - 1];
 }

 isEmpty() {
 return this.items.length === 0;
 }

 size() {
 return this.items.length;
 }

 clear() {
 this.items = [];
 }
}

// Usage
const stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
console.log(stack.pop()); // 3
console.log(stack.peek()); // 2

Stack Problems #

Valid Parentheses:

Matrix Problems - Complete Guide

Fri, 11 Jul 2025 09:14:22 +0000

Matrix problems involve 2D arrays and grids. This guide covers traversal patterns, transformations, and common algorithms for matrix-based challenges.

Matrix Basics #

// Create matrix
const matrix = [
 [1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]
];

// Access element
const val = matrix[row][col];

// Dimensions
const rows = matrix.length;
const cols = matrix[0].length;

// Iterate
for (let i = 0; i < rows; i++) {
 for (let j = 0; j < cols; j++) {
 console.log(matrix[i][j]);
 }
}

Matrix Traversal #

Spiral Order #

function spiralOrder(matrix) {
 if (matrix.length === 0) return [];

 const result = [];
 let top = 0;
 let bottom = matrix.length - 1;
 let left = 0;
 let right = matrix[0].length - 1;

 while (top <= bottom && left <= right) {
 // Right
 for (let col = left; col <= right; col++) {
 result.push(matrix[top][col]);
 }
 top++;

 // Down
 for (let row = top; row <= bottom; row++) {
 result.push(matrix[row][right]);
 }
 right--;

 // Left
 if (top <= bottom) {
 for (let col = right; col >= left; col--) {
 result.push(matrix[bottom][col]);
 }
 bottom--;
 }

 // Up
 if (left <= right) {
 for (let row = bottom; row >= top; row--) {
 result.push(matrix[row][left]);
 }
 left++;
 }
 }

 return result;
}

console.log(spiralOrder([[1, 2, 3], [4, 5, 6], [7, 8, 9]]));
// [1, 2, 3, 6, 9, 8, 7, 4, 5]

Spiral Matrix II #

Generate spiral matrix.

Recursion - Complete Guide for Beginners

Sat, 05 Jul 2025 09:16:38 +0000

Recursion is a programming technique where a function calls itself to solve smaller instances of the same problem. This guide covers recursion fundamentals and common patterns.

What is Recursion? #

Recursion occurs when a function calls itself to break down a problem into smaller, more manageable subproblems.

Key Components:

Base case - Stopping condition
Recursive case - Function calls itself with modified parameters

Basic Recursion Example #

Countdown #

function countdown(n) {
 // Base case
 if (n <= 0) {
 console.log("Done!");
 return;
 }

 // Recursive case
 console.log(n);
 countdown(n - 1);
}

countdown(5);
// Output: 5, 4, 3, 2, 1, Done!

How Recursion Works #

Call Stack #

function factorial(n) {
 if (n === 0) return 1;
 return n * factorial(n - 1);
}

factorial(3);

Call Stack Visualization:

Sorting Algorithms - Complete Guide

Sat, 14 Jun 2025 14:28:41 +0000

Sorting is one of the most fundamental operations in computer science. This guide covers all essential sorting algorithms with implementations and analysis.

Why Learn Sorting Algorithms? #

Interview staple - Frequently asked
Foundation - Understanding algorithm design
Practical - Used everywhere in software
Optimization - Learn time/space tradeoffs

Bubble Sort #

Repeatedly swap adjacent elements if they’re in wrong order.

function bubbleSort(arr) {
 const n = arr.length;

 for (let i = 0; i < n - 1; i++) {
 let swapped = false;

 for (let j = 0; j < n - i - 1; j++) {
 if (arr[j] > arr[j + 1]) {
 [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
 swapped = true;
 }
 }

 if (!swapped) break; // Already sorted
 }

 return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90]));
// [11, 12, 22, 25, 34, 64, 90]

Time: O(n²), Space: O(1) Stable: Yes

Monotonic Stack - Complete Guide

Mon, 09 Jun 2025 08:45:31 +0000

A monotonic stack maintains elements in sorted order (increasing or decreasing). It’s powerful for problems involving next greater/smaller elements.

What is a Monotonic Stack? #

A stack that maintains monotonic (either increasing or decreasing) order by removing elements that break the monotonicity.

Types:

Monotonic Increasing - Elements increase from bottom to top
Monotonic Decreasing - Elements decrease from bottom to top

Use cases:

Next greater element
Next smaller element
Histogram problems
Stock span problems

Monotonic Increasing Stack #

Elements increase from bottom to top.

Graph Algorithms - Complete Guide

Sun, 08 Jun 2025 15:33:47 +0000

Graphs are one of the most versatile data structures in computer science. This guide covers essential graph algorithms and their implementations.

What is a Graph? #

A graph is a data structure consisting of:

Vertices (nodes) - The entities
Edges - Connections between vertices

Types of Graphs #

Directed vs Undirected #

Directed (Digraph): Edges have direction (one-way streets) Undirected: Edges have no direction (two-way streets)

Weighted vs Unweighted #

Weighted: Edges have values (distance, cost) Unweighted: All edges are equal

Heaps and Priority Queues - Complete Guide

Sun, 18 May 2025 14:07:33 +0000

Heaps are tree-based data structures that maintain a specific ordering property. This guide covers heap operations, priority queues, and common heap problems.

What is a Heap? #

A heap is a complete binary tree where each node satisfies the heap property:

Max Heap: Parent ≥ children
Min Heap: Parent ≤ children

Max Heap: Min Heap:
 50 10
 / \ / \
 30 40 20 30
 / \ / / \ /
 10 20 35 40 50 35

Array Representation #

Heaps are typically stored in arrays.

Tree Traversal Algorithms - Complete Guide

Mon, 21 Apr 2025 10:29:55 +0000

Trees are hierarchical data structures that require specific traversal techniques. This guide covers all essential tree traversal algorithms and patterns.

Tree Basics #

Binary Tree Node #

class TreeNode {
 constructor(val) {
 this.val = val;
 this.left = null;
 this.right = null;
 }
}

// Create sample tree
const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);

// 1
// / \
// 2 3
// / \
// 4 5

Depth-First Traversals #

Inorder Traversal (Left-Root-Right) #

Recursive:

Linked Lists - Complete Guide

Fri, 28 Mar 2025 13:47:19 +0000

Linked lists are fundamental data structures that store elements in nodes connected by pointers. This guide covers linked list operations and common problems.

What is a Linked List? #

A linked list is a linear data structure where elements are stored in nodes. Each node contains:

Data - The value
Next - Pointer to the next node

Types of Linked Lists #

Singly Linked List #

Each node points to the next node:

LRU Cache - Complete Implementation Guide

Sat, 22 Mar 2025 14:17:08 +0000

LRU (Least Recently Used) Cache is a data structure that stores key-value pairs with a size limit, evicting the least recently used item when capacity is reached.

What is LRU Cache? #

An LRU cache maintains items in order of use. When capacity is reached, the least recently used item is removed.

Operations:

get(key) - Get value, mark as recently used
put(key, value) - Add/update value, mark as recently used
Both operations should be O(1)

Requirements:

Two Pointers Technique - Complete Guide

Tue, 25 Feb 2025 16:37:12 +0000

The two pointers technique is a powerful pattern for solving array and string problems efficiently. This guide covers all essential two pointer patterns and problems.

What is the Two Pointers Technique? #

Two pointers is a pattern where you use two references (pointers/indices) to traverse a data structure. This approach often reduces time complexity from O(n²) to O(n).

When to Use Two Pointers #

Sorted arrays - Search, remove duplicates
Pairs/triplets - Find pairs with target sum
Palindromes - Check if string is palindrome
Subarrays - Find subarray meeting condition
Merging - Merge sorted arrays

Common Patterns #

1. Opposite Ends Pattern #

Pointers start at beginning and end, move toward each other.

Bit Manipulation - Complete Guide

Tue, 11 Feb 2025 10:55:27 +0000

Bit manipulation uses bitwise operators to solve problems efficiently. This guide covers essential bit manipulation techniques and common problems.

Binary Basics #

Binary Representation #

const num = 5;

// Convert to binary string
console.log(num.toString(2)); // "101"

// Parse binary string
console.log(parseInt('101', 2)); // 5

// Binary representation
// 5 = 0000 0101 (8-bit)
// 128 64 32 16 8 4 2 1
// 0 0 0 0 0 1 0 1

Signed Integers #

// Positive: 5 = 0000 0101
// Negative: -5 = 1111 1011 (two's complement)

// Two's complement:
// 1. Flip all bits: 0000 0101 → 1111 1010
// 2. Add 1: 1111 1010 → 1111 1011

Bitwise Operators #

AND (&) #

Both bits must be 1.

Interval Problems - Complete Guide

Wed, 29 Jan 2025 11:38:56 +0000

Interval problems involve working with ranges or time periods. This guide covers common patterns and algorithms for solving interval-related challenges.

Understanding Intervals #

An interval is a continuous range represented as [start, end].

const interval = [1, 5]; // Includes 1 and 5
// Represents: 1, 2, 3, 4, 5

// Common representations:
// [start, end] - Closed interval (inclusive)
// (start, end) - Open interval (exclusive)
// [start, end) - Half-open (start inclusive, end exclusive)

Merge Intervals #

Combine overlapping intervals.

Backtracking Algorithms - Complete Guide

Thu, 09 Jan 2025 12:04:36 +0000

Backtracking is a algorithmic technique for solving problems recursively by trying to build a solution incrementally and abandoning solutions that fail to satisfy constraints.

What is Backtracking? #

Backtracking is a form of recursion where you:

Make a choice
Explore that path
If it doesn’t work, undo the choice (backtrack)
Try another option

Backtracking Template #

function backtrack(path, choices) {
 // Base case
 if (satisfiesCondition(path)) {
 result.push([...path]);
 return;
 }

 // Try each choice
 for (const choice of choices) {
 // Make choice
 path.push(choice);

 // Explore
 backtrack(path, getNextChoices());

 // Undo choice (backtrack)
 path.pop();
 }
}

Classic Backtracking Problems #

Generate All Subsets #

function subsets(nums) {
 const result = [];

 function backtrack(start, current) {
 result.push([...current]);

 for (let i = start; i < nums.length; i++) {
 current.push(nums[i]);
 backtrack(i + 1, current);
 current.pop();
 }
 }

 backtrack(0, []);
 return result;
}

console.log(subsets([1, 2, 3]));
// [[], [1], [1,2], [1,2,3], [1,3], [2], [2,3], [3]]

Generate All Permutations #

function permute(nums) {
 const result = [];

 function backtrack(current, remaining) {
 if (remaining.length === 0) {
 result.push([...current]);
 return;
 }

 for (let i = 0; i < remaining.length; i++) {
 current.push(remaining[i]);
 const next = remaining.slice(0, i).concat(remaining.slice(i + 1));
 backtrack(current, next);
 current.pop();
 }
 }

 backtrack([], nums);
 return result;
}

console.log(permute([1, 2, 3]));
// [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]

Combination Sum #

function combinationSum(candidates, target) {
 const result = [];

 function backtrack(start, current, sum) {
 if (sum === target) {
 result.push([...current]);
 return;
 }

 if (sum > target) return;

 for (let i = start; i < candidates.length; i++) {
 current.push(candidates[i]);
 backtrack(i, current, sum + candidates[i]);
 current.pop();
 }
 }

 backtrack(0, [], 0);
 return result;
}

console.log(combinationSum([2, 3, 6, 7], 7));
// [[2,2,3], [7]]

Letter Combinations of Phone Number #

function letterCombinations(digits) {
 if (!digits) return [];

 const phone = {
 '2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl',
 '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz'
 };

 const result = [];

 function backtrack(index, current) {
 if (index === digits.length) {
 result.push(current);
 return;
 }

 const letters = phone[digits[index]];
 for (const letter of letters) {
 backtrack(index + 1, current + letter);
 }
 }

 backtrack(0, '');
 return result;
}

console.log(letterCombinations("23"));
// ["ad","ae","af","bd","be","bf","cd","ce","cf"]

N-Queens #

function solveNQueens(n) {
 const result = [];
 const board = Array(n).fill(0).map(() => Array(n).fill('.'));

 function isValid(row, col) {
 // Check column
 for (let i = 0; i < row; i++) {
 if (board[i][col] === 'Q') return false;
 }

 // Check diagonal
 for (let i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
 if (board[i][j] === 'Q') return false;
 }

 // Check anti-diagonal
 for (let i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
 if (board[i][j] === 'Q') return false;
 }

 return true;
 }

 function backtrack(row) {
 if (row === n) {
 result.push(board.map(r => r.join('')));
 return;
 }

 for (let col = 0; col < n; col++) {
 if (isValid(row, col)) {
 board[row][col] = 'Q';
 backtrack(row + 1);
 board[row][col] = '.';
 }
 }
 }

 backtrack(0);
 return result;
}

console.log(solveNQueens(4));

Sudoku Solver #

function solveSudoku(board) {
 function isValid(row, col, num) {
 // Check row
 for (let j = 0; j < 9; j++) {
 if (board[row][j] === num) return false;
 }

 // Check column
 for (let i = 0; i < 9; i++) {
 if (board[i][col] === num) return false;
 }

 // Check 3x3 box
 const boxRow = Math.floor(row / 3) * 3;
 const boxCol = Math.floor(col / 3) * 3;
 for (let i = 0; i < 3; i++) {
 for (let j = 0; j < 3; j++) {
 if (board[boxRow + i][boxCol + j] === num) return false;
 }
 }

 return true;
 }

 function backtrack() {
 for (let row = 0; row < 9; row++) {
 for (let col = 0; col < 9; col++) {
 if (board[row][col] === '.') {
 for (let num = 1; num <= 9; num++) {
 const char = num.toString();

 if (isValid(row, col, char)) {
 board[row][col] = char;

 if (backtrack()) return true;

 board[row][col] = '.';
 }
 }

 return false;
 }
 }
 }

 return true;
 }

 backtrack();
 return board;
}

Word Search #

function exist(board, word) {
 const rows = board.length;
 const cols = board[0].length;

 function backtrack(row, col, index) {
 if (index === word.length) return true;

 if (row < 0 || row >= rows || col < 0 || col >= cols ||
 board[row][col] !== word[index]) {
 return false;
 }

 const temp = board[row][col];
 board[row][col] = '#';

 const found = backtrack(row + 1, col, index + 1) ||
 backtrack(row - 1, col, index + 1) ||
 backtrack(row, col + 1, index + 1) ||
 backtrack(row, col - 1, index + 1);

 board[row][col] = temp;

 return found;
 }

 for (let i = 0; i < rows; i++) {
 for (let j = 0; j < cols; j++) {
 if (backtrack(i, j, 0)) return true;
 }
 }

 return false;
}

Palindrome Partitioning #

function partition(s) {
 const result = [];

 function isPalindrome(str) {
 let left = 0, right = str.length - 1;
 while (left < right) {
 if (str[left] !== str[right]) return false;
 left++;
 right--;
 }
 return true;
 }

 function backtrack(start, current) {
 if (start === s.length) {
 result.push([...current]);
 return;
 }

 for (let end = start + 1; end <= s.length; end++) {
 const substring = s.slice(start, end);

 if (isPalindrome(substring)) {
 current.push(substring);
 backtrack(end, current);
 current.pop();
 }
 }
 }

 backtrack(0, []);
 return result;
}

console.log(partition("aab"));
// [["a","a","b"], ["aa","b"]]

Generate Parentheses #

function generateParenthesis(n) {
 const result = [];

 function backtrack(current, open, close) {
 if (current.length === 2 * n) {
 result.push(current);
 return;
 }

 if (open < n) {
 backtrack(current + '(', open + 1, close);
 }

 if (close < open) {
 backtrack(current + ')', open, close + 1);
 }
 }

 backtrack('', 0, 0);
 return result;
}

console.log(generateParenthesis(3));
// ["((()))","(()())","(())()","()(())","()()()"]

Restore IP Addresses #

function restoreIpAddresses(s) {
 const result = [];

 function isValid(segment) {
 if (segment.length > 3) return false;
 if (segment[0] === '0' && segment.length > 1) return false;
 return parseInt(segment) <= 255;
 }

 function backtrack(start, current) {
 if (current.length === 4) {
 if (start === s.length) {
 result.push(current.join('.'));
 }
 return;
 }

 for (let len = 1; len <= 3; len++) {
 if (start + len > s.length) break;

 const segment = s.slice(start, start + len);

 if (isValid(segment)) {
 current.push(segment);
 backtrack(start + len, current);
 current.pop();
 }
 }
 }

 backtrack(0, []);
 return result;
}

console.log(restoreIpAddresses("25525511135"));
// ["255.255.11.135","255.255.111.35"]

Subsets II (With Duplicates) #

function subsetsWithDup(nums) {
 nums.sort((a, b) => a - b);
 const result = [];

 function backtrack(start, current) {
 result.push([...current]);

 for (let i = start; i < nums.length; i++) {
 if (i > start && nums[i] === nums[i - 1]) continue;

 current.push(nums[i]);
 backtrack(i + 1, current);
 current.pop();
 }
 }

 backtrack(0, []);
 return result;
}

console.log(subsetsWithDup([1, 2, 2]));
// [[],[1],[1,2],[1,2,2],[2],[2,2]]

Permutations II (With Duplicates) #

function permuteUnique(nums) {
 nums.sort((a, b) => a - b);
 const result = [];
 const used = new Array(nums.length).fill(false);

 function backtrack(current) {
 if (current.length === nums.length) {
 result.push([...current]);
 return;
 }

 for (let i = 0; i < nums.length; i++) {
 if (used[i]) continue;
 if (i > 0 && nums[i] === nums[i - 1] && !used[i - 1]) continue;

 current.push(nums[i]);
 used[i] = true;
 backtrack(current);
 current.pop();
 used[i] = false;
 }
 }

 backtrack([]);
 return result;
}

Combination Sum III #

function combinationSum3(k, n) {
 const result = [];

 function backtrack(start, current, sum) {
 if (current.length === k && sum === n) {
 result.push([...current]);
 return;
 }

 if (current.length >= k || sum >= n) return;

 for (let i = start; i <= 9; i++) {
 current.push(i);
 backtrack(i + 1, current, sum + i);
 current.pop();
 }
 }

 backtrack(1, [], 0);
 return result;
}

console.log(combinationSum3(3, 9));
// [[1,2,6],[1,3,5],[2,3,4]]

Optimization Techniques #

Pruning #

Stop exploring paths that can’t lead to solution:

Trie Data Structure - Complete Guide

Sun, 05 Jan 2025 16:42:19 +0000

A Trie (prefix tree) is a tree data structure for efficient string storage and retrieval. This guide covers trie implementation and common problems.

What is a Trie? #

A trie stores strings character by character, with each node representing a character. Common prefixes share the same path.

Trie containing: "cat", "car", "dog"

 root
 / \
 c d
 | |
 a o
 / \ |
 t r g
 * * *

* = end of word

Basic Implementation #

class TrieNode {
 constructor() {
 this.children = new Map();
 this.isEndOfWord = false;
 }
}

class Trie {
 constructor() {
 this.root = new TrieNode();
 }

 insert(word) {
 let node = this.root;

 for (const char of word) {
 if (!node.children.has(char)) {
 node.children.set(char, new TrieNode());
 }
 node = node.children.get(char);
 }

 node.isEndOfWord = true;
 }

 search(word) {
 let node = this.root;

 for (const char of word) {
 if (!node.children.has(char)) {
 return false;
 }
 node = node.children.get(char);
 }

 return node.isEndOfWord;
 }

 startsWith(prefix) {
 let node = this.root;

 for (const char of prefix) {
 if (!node.children.has(char)) {
 return false;
 }
 node = node.children.get(char);
 }

 return true;
 }
}

// Usage
const trie = new Trie();
trie.insert('apple');
console.log(trie.search('apple')); // true
console.log(trie.search('app')); // false
console.log(trie.startsWith('app')); // true
trie.insert('app');
console.log(trie.search('app')); // true

Delete Operation #

class Trie {
 delete(word) {
 this.deleteHelper(this.root, word, 0);
 }

 deleteHelper(node, word, index) {
 if (index === word.length) {
 if (!node.isEndOfWord) {
 return false; // Word doesn't exist
 }

 node.isEndOfWord = false;

 // Delete node if it has no children
 return node.children.size === 0;
 }

 const char = word[index];

 if (!node.children.has(char)) {
 return false; // Word doesn't exist
 }

 const childNode = node.children.get(char);
 const shouldDelete = this.deleteHelper(childNode, word, index + 1);

 if (shouldDelete) {
 node.children.delete(char);

 // Delete current node if:
 // - Not end of another word
 // - Has no other children
 return !node.isEndOfWord && node.children.size === 0;
 }

 return false;
 }
}

const trie = new Trie();
trie.insert('apple');
trie.insert('app');
trie.delete('app');
console.log(trie.search('app')); // false
console.log(trie.search('apple')); // true

Array Implementation #

Using arrays instead of Maps (for lowercase letters).