a divide-and-conquer recurrence
Most recursive algorithms that 'split, solve, and stitch back together' share one family of recurrences, and it is worth recognising that family on sight. The story is always the same: break the problem into a few pieces of equal smaller size, solve each piece recursively, then spend some extra effort combining the answers.
The standard divide-and-conquer recurrence has the shape T(n) = a T(n/b) + f(n). Here a is the number of subproblems (how many recursive calls), b is the factor by which the size shrinks (each subproblem has size n/b), and f(n) is the cost of dividing the input and combining the results at this level — everything that is NOT a recursive call. For merge sort, a = 2, b = 2, f(n) = Theta(n) (the merge). For binary search, a = 1, b = 2, f(n) = Theta(1). For Karatsuba multiplication, a = 3, b = 2, f(n) = Theta(n). Note a and b are independent: a can be larger or smaller than b, and that comparison is exactly what decides the answer.
This single template is what the Master Theorem solves directly, which is why almost every divide-and-conquer running time you meet is just a plugging-in exercise. The key intuition is a tug-of-war: the recursive calls multiply the work by a at each level while the size shrinks by b, so the total depends on whether the work grows, stays balanced, or shrinks as you go down the tree. When the splits are uneven or unequal (sizes like n/3 and 2n/3 in the same call), this exact form no longer applies and you reach for the Akra-Bazzi method instead.
Strassen's matrix multiplication does 7 recursive multiplications of half-dimension matrices plus Theta(n^2) additions, so a = 7, b = 2, f(n) = Theta(n^2), giving T(n) = 7 T(n/2) + Theta(n^2).
Identify a (call count), b (shrink factor), and f(n) (non-recursive work) to name the recurrence.
a is the number of subproblems, not the depth, and b is a divisor of the size, not of the time. A common slip is using a = b 'because we split in two' — for merge sort that is right (2 calls, halved size), but for binary search a = 1 even though b = 2.