Backtracking vs Dynamic Programming: How to Decide

The way I decide is by looking at what the problem is actually asking for. Backtracking is for enumeration and construction, when I need to find all valid solutions or build a solution to a constraint problem. Classic examples are generating all permutations, all subsets, all combinations, or solving N-Queens and Sudoku. Backtracking walks the entire decision tree, choosing, exploring, and undoing, with pruning to skip dead branches, and it's frequently exponential, partly because the set of answers itself can be exponential. Dynamic programming, on the other hand, is for optimization or counting, when I need the best value, like a minimum or maximum, or the number of ways to do something. DP applies when the problem has two properties: overlapping subproblems, meaning the same smaller problem comes up again and again, and optimal substructure, meaning an optimal solution is composed of optimal solutions to subproblems. Examples are knapsack, longest common subsequence, coin change, and edit distance. The whole point of DP is that it solves each subproblem once and reuses the answer, through memoization top-down or tabulation bottom-up, which collapses what would be exponential recursion into polynomial time. So my quick test is: if the problem says list all or construct every solution, I reach for backtracking; if it says find the best or count the number of ways, and I notice repeated subproblems, I reach for DP. And there's a nice connection between them: many problems start as a backtracking recursion that's too slow, and the moment I add memoization over the repeated states, it effectively becomes dynamic programming.