Dynamic Programming

dp[a] is the minimum coins to make amount a, computed as min over all coins of dp[a-coin] + 1, with -1 for unreachable amounts.

Coins in the outer loop, amounts in the inner loop, dp[a] += dp[a-coin], and dp[0] = 1 counts combinations not permutations.

Each new land cell adds one island, then every merge with a live neighbor subtracts one: report the count after each step.

Star means skip two pattern chars (zero occurrences) or consume one text char if the preceding pattern char matches; dot or literal char requires a single match plus the diagonal.

Star absorbs one more text char (cell above) or matches empty (cell left); question mark or exact char matches via the diagonal.

Fill the table from the base cases upward in dependency order, with no recursion needed.

Pick the LAST balloon to burst in an interval; its neighbors are the fixed padded boundaries, splitting the range into two independent subranges.

Each item once: sweep capacity downward; dp[c] = max(dp[c], dp[c - w] + v).

Split the chain at k; cost = left + right + p[i-1] * p[k] * p[j]; take the minimum.

Match characters copy the diagonal; mismatches take 1 + min(delete, insert, replace).

If subproblems repeat and the best overall answer is built from best sub-answers, cache them : that is dynamic programming.

Each Fibonacci number is the sum of the previous two, starting from zero and one.

Fill best-value cells bottom-up, and with one row iterate capacity downward so each item is used once.

Keep the smallest tail for each length and binary-search each element into place for O(n log n).

On a match add one to the diagonal; otherwise take the better of the two neighbours.

For each item choose include or skip; a table over items and capacity stores the best value.

Same table as 0/1 Knapsack, but sweep capacity low to high so items can repeat.

Fill each amount with the fewest coins by trying every denomination and taking one plus the best remainder.

Each state depends on the previous two; keep two rolling values for linear time and constant space.

Ways to reach step N equal the sum of ways to reach steps N minus one, two, and three.

Ways to reach step N equal ways to step N minus one plus ways to step N minus two, the Fibonacci sequence.

The best increasing run ending at an index is one plus the best run ending at any earlier smaller value.

Each term is the sum of the previous two, so cache results and roll two values forward.

For each span, try every first cut inside it and add the span length plus the two sub-span optima.

Define the state, write the transition, fix the base cases, then memoize or tabulate.

Ways to reach a step equal the ways to the two steps below it, so it is Fibonacci.

For each item take the better of including it (if it fits) or excluding it, and cache by index and capacity.

Sort items by value-to-weight ratio descending and fill greedily, splitting the last item if it only partly fits.

At each house, take the maximum of skipping it (best so far) or robbing it (its value plus the best from two positions back).

If the two ends of a window match, they wrap the inner palindrome and add two; otherwise take the better of dropping either end.

The number of ways to reach step i is the sum of the ways to reach step i-1 (single step) and step i-2 (double step) : it is the Fibonacci sequence.