When should you use greedy instead of dynamic programming?

Greedy is faster and simpler, but it needs a correctness argument. The usual proof is an exchange argument: show that any optimal solution can be transformed to include the greedy choice without becoming worse. Without that argument, a greedy solution is just a guess.

function coinChange(coins, amount) {
  const dp = new Array(amount + 1).fill(Infinity);
  dp[0] = 0;
  for (let value = 1; value <= amount; value++) {
    for (const coin of coins) {
      if (coin <= value) {
        dp[value] = Math.min(dp[value], dp[value - coin] + 1);
      }
    }
  }
  return dp[amount] === Infinity ? -1 : dp[amount];
}

Signals for each approach

• Greedy: interval scheduling by earliest finish, Huffman coding, minimum spanning trees
• DP: knapsack, coin change with arbitrary denominations, edit distance
• Greedy needs an exchange argument or a matroid-style structure
• DP is safer when choices can conflict across steps
• If a greedy solution is wrong on a small counterexample, switch to DP

A useful interview move is to try a greedy idea, find a counterexample, then explain why DP is needed. That shows you can evaluate a strategy rather than pattern-match a topic name.