Greedy vs DP How to Know Which to Apply in DSA Typescript - Complexity Comparison

Time Complexity: Greedy vs DP How to Know Which to Apply

O(n)

Understanding Time Complexity

When deciding between Greedy and Dynamic Programming (DP), understanding how their time costs grow helps us choose the right method.

We want to know which approach runs faster as the problem size grows.

Scenario Under Consideration

Analyze the time complexity of these two simplified approaches.

// Greedy approach example
function greedySolution(items: number[]): number {
  let total = 0;
  for (const item of items) {
    if (item > 0) total += item;
  }
  return total;
}

// DP approach example
function dpSolution(items: number[]): number {
  const dp = new Array(items.length + 1).fill(0);
  for (let i = 1; i <= items.length; i++) {
    dp[i] = Math.max(dp[i - 1], dp[i - 1] + items[i - 1]);
  }
  return dp[items.length];
}
    

The greedy function sums positive items quickly. The DP function considers combinations to find the best sum.

Identify Repeating Operations

Look at the loops and repeated steps in each approach.

• Greedy primary operation: One loop over all items.
• Greedy loop count: Runs once for each item (n times).
• DP primary operation: One loop filling the dp array.
• DP loop count: Also runs once for each item (n times), but does extra work inside.

How Execution Grows With Input

Both methods loop through the input once, but DP does more work per step.

Input Size (n)	Greedy Approx. Operations	DP Approx. Operations
10	~10 simple checks	~10 calculations and comparisons
100	~100 simple checks	~100 calculations and comparisons
1000	~1000 simple checks	~1000 calculations and comparisons

Pattern observation: Both grow linearly, but DP does more work per item.

Final Time Complexity

Time Complexity: O(n) for both Greedy and DP in this example.

This means both take time proportional to the number of items, but DP usually has more steps per item.

Common Mistake

[X] Wrong: "Greedy is always faster and better than DP."

[OK] Correct: Greedy is faster but only works when local choices lead to a global best. DP handles complex cases but may be slower.

Interview Connect

Knowing when to pick Greedy or DP shows you understand problem patterns and efficiency, a key skill interviewers look for.

Self-Check

"What if the DP solution used nested loops to compare all pairs? How would the time complexity change?"

Practice

1. Which of the following best describes when to use a greedy algorithm instead of dynamic programming?

easy

A. When the problem has the greedy choice property and optimal substructure

B. When the problem requires checking all possible combinations

C. When the problem has overlapping subproblems but no optimal substructure

D. When the problem needs to store all intermediate results

Solution

1. Step 1: Understand greedy choice property

   A greedy algorithm works when choosing the best option at each step leads to a global optimum.

2. Step 2: Check optimal substructure

   Optimal substructure means the optimal solution can be built from optimal solutions of subproblems.

3. Final Answer:

   When the problem has the greedy choice property and optimal substructure -> Option A

4. Quick Check:

   Greedy = greedy choice + optimal substructure [OK]

Hint: Use greedy if local best leads to global best [OK]

Common Mistakes:

• Confusing overlapping subproblems with greedy applicability
• Using greedy when problem needs full exploration
• Ignoring optimal substructure requirement

2. Which syntax correctly declares a memoization object in TypeScript for dynamic programming?

easy

A. var memo: number[] = [];

B. let memo = new Map();

C. const memo: Record = {};

D. const memo = {} as number[];

Solution

1. Step 1: Understand memo type for DP

   Memoization stores results with keys, so Record is suitable.

2. Step 2: Check syntax correctness

   const memo: Record = {}; correctly declares an empty object with number keys and values.

3. Final Answer:

   const memo: Record = {}; -> Option C

4. Quick Check:

   Memo object uses Record type [OK]

Hint: Use Record for memo objects [OK]

Common Mistakes:

• Using var instead of const or let
• Incorrect type assertion for memo
• Using Map without type parameters

3. Consider this TypeScript code snippet for a problem that can be solved by greedy or DP:

function maxSum(arr: number[]): number {
  let sum = 0;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 0) sum += arr[i];
  }
  return sum;
}
console.log(maxSum([-1, 2, 3, -5, 4]));

What is the output?

medium

A. 9

B. 4

C. 0

D. Error

Solution

1. Step 1: Trace the loop and sum positive numbers

   Positive numbers are 2, 3, and 4. Sum = 2 + 3 + 4 = 9.

2. Step 2: Confirm return value

   The function returns sum = 9, so console.log prints 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   Sum positives = 9 [OK]

Hint: Sum only positive numbers for max sum greedy [OK]

Common Mistakes:

• Adding negative numbers mistakenly
• Returning zero instead of sum
• Confusing output with array length

4. The following TypeScript function is intended to solve the Fibonacci sequence using DP with memoization. What is the bug?

function fib(n: number, memo: Record = {}): number {
  if (n <= 1) return n;
  if (memo[n]) return memo[n];
  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
  return memo[n];
}
console.log(fib(5));

medium

A. The recursive calls should be fib(n + 1) and fib(n + 2)

B. The base case should be 'if (n < 0) return 0;'

C. The function should not use default parameter for memo

D. The memo check should be 'if (memo[n] !== undefined)' to handle zero

Solution

1. Step 1: Analyze memo check condition

   Checking 'if (memo[n])' fails when memo[n] is 0, which is falsy.

2. Step 2: Correct memo check

   Use 'if (memo[n] !== undefined)' to correctly detect stored values including zero.

3. Final Answer:

   The memo check should be 'if (memo[n] !== undefined)' to handle zero -> Option D

4. Quick Check:

   Memo check must handle zero values [OK]

Hint: Check memo with !== undefined, not truthy check [OK]

Common Mistakes:

• Using truthy check for memo causing wrong cache hits
• Wrong base case for Fibonacci
• Incorrect recursive call directions

5. You have a set of tasks with durations and deadlines. You want to maximize the number of tasks completed before their deadlines. Which approach is best and why?

interface Task {
  duration: number;
  deadline: number;
}
function scheduleTasks(tasks: Task[]): number {
  // Implementation needed
}

hard

A. Use dynamic programming to try all subsets and pick max count

B. Use a greedy algorithm sorting tasks by earliest deadline to maximize count

C. Use greedy sorting by longest duration first to minimize total time

D. Use dynamic programming to minimize total duration ignoring deadlines

Solution

1. Step 1: Understand problem goal

   Maximize number of tasks completed before deadlines means scheduling tasks efficiently.

2. Step 2: Identify best approach

   Greedy algorithm sorting by earliest deadline ensures maximum tasks fit before deadlines.

3. Final Answer:

   Use a greedy algorithm sorting tasks by earliest deadline to maximize count -> Option B

4. Quick Check:

   Earliest deadline first greedy maximizes tasks [OK]

Hint: Sort tasks by earliest deadline for max count [OK]

Common Mistakes:

• Trying all subsets with DP causing inefficiency
• Sorting by longest duration wastes time
• Ignoring deadlines in scheduling