Occasionally I am lucky enough to run into a problem that doesn’t already have many vector solutions, so I can demonstrate how vector thinking can allow you to find an elegant solution. To build up to my insight let’s solve 2 easy variations and then we can get to the two more interesting puzzles.

The problem in question is called Best Time to Buy and Sell or more popularly simply Max Profit.

The theme is always the same you are given an ordered list of positive numbers that represent the evolution of the price of the security. You must find the maximum profit you could have made given this price series. You can only hold 1 unit at a time and you can not short, which means you must buy before you can sell (you can only profit from the price evolving upward).

The simplest and most well know variation is the 1 transaction problem (leetcode problem 121): you can only buy and sell at most 1 time what is the max profit that can be earned from the following series:

example series:

3 2 5 1 3 2 4 9 5 12 3 5

The key insight into this problem is that we are looking for the largest difference between the current element and the smallest element we have seen.

To motivate this insight, let’s look at ever larger versions of this problem starting with just one price to detect the pattern.

3 -> 0

Given just one price we can only buy and sell on the same day, so effectively max profit is 0

3 2 -> 0

Given these two points we can still only earn 0, since we must sell after we buy.

3 2 5 -> 3

Now that we have a higher number after a lower number we can plainly see that of the two options buy at 3 or buy at 2, buy at 2 and sell at 5 is better.

3 2 5 1 -> 3

The answer is still 3, since we can’t sell higher than 5, and even if we bought at 1 at the end there are no days left to sell

3 2 5 1 3 -> 3

We still do best by buying at 2 and selling at 5, buying at 1 and selling at 3 only earns 2.

3 2 5 1 3 2 -> 3

Plainly the 2 at the end doesn’t improve

3 2 5 1 3 2 4 -> 3

We can now either buy at 2 and sell at 5 or buy at 1 and sell at 4, but our max profit is still 3.

3 2 5 1 3 2 4 9 -> 8

Finally, the max profit changes! We can now buy at 1 and sell at 9. As new elements are added the new reward will be a function of the lowest element seen thus far.

We then get our solution:

{max x-mins x} 3 2 5 1 3 2 4 9 5 12 3 5

11, where we buy at 1 and sell at 12.

Or in python we could say something like:

```
import itertools
from operator import sub
def max_profit(p):
return max(map(sub,p,itertools.accumulate(p,min)))
```

To unpack this a bit, mins returns the min element up to that point:

mins[3 2 5 1 3 2 4 9 5 12 3 5]

3 2 2 1 1 1 1 1 1 1 1 1

we can then do element-wise subtraction to see what the profit is from selling at each point

0 0 3 0 2 1 3 8 4 11 2 4

taking the running max we get the max profit so far,

0 0 3 3 3 3 3 8 8 11 11 11

we can see that this series is exactly the results that we got when we were looking at the max profit for the prefixes of the series.

Easy enough, let’s look at version 2 of this problem (leetcode 122):

unlimited number of transactions: We are now allowed to buy and sell as often as we like provided we never own more than 1 share of the stock and we still must sell after we bought. To make things easier we can assume that we can buy and sell on the same day, in practice this doesn’t matter as any day we do this we can consider that we did nothing.

Keeping the same price series as before:

3 2 5 1 3 2 4 9 5 12 3 5

We now notice that we should take advantage of every single time the price goes up. Again let’s look at a smaller example to get some intuition.

3 2 5 -> 3

Nothing fancy here, we buy at 2 and sell at 5, purchasing at 3 doesn’t improve our profit since selling at 2 would incur a loss.

3 2 5 1 3 -> 5

buy at 2 sell at 5, buy at 1 sell at 3

3 2 5 1 3 2 4 -> 7

just add one more purchase at 2 and sell at 4,

3 2 5 1 3 2 4 9 -> 12

Here it becomes interesting, we can look at two interpretations

buy at 2 sell at 5 (3),buy at 1 sell at 3 (2), **buy 2 sell at 9 (7)** for a total of 12

or we can say:

buy at 2 sell at 5 (3),buy at 1 sell at 3 (2), **buy at 2 sell at 4 (2),buy at 4 sell at 9 (5) **for a total of 12.

The two approaches are identical since addition commutes, it doesn’t matter how you get from 2 – 9 you will always earn 7.

Which means that we can simply add up the positive steps in the price series. That will be the maximum profit for an unlimited number of transactions:

Our code is simply:

{(x>0) wsum x:1 _ deltas x} 3 2 5 1 3 2 4 9 5 12 3 5

21

Deltas gives us the adjacent differences. We drop the first delta since we cannot sell before we have bought. If the delta is positive >0 we want to include it in our sum. Using (w)eighted(sum) we weight the >0 with a 1 and less then 0 or =0 are given a weight of 0.

Now that we covered the case with 1 transaction and unlimited transactions, we should feel confident that we can tackle 2 transactions. Lucky for us, that’s exactly version III of the problem (leetcode 123):

Getting insight into how to solve this variation should start with thinking about how we could solve this naively. The correct heuristic to reach for is divide and conquer. Suppose that for every step along the price evolution we knew what the max profit was before and the max profit was after. Then we could sum those two max profits and take the largest combination.

assume max_profit function as before:

```
r=range(len(p))
max([max_profit(p[0:i])+max_profit(p[i:]) for i in r)])
```

For our example this gives us 15.

What we might notice is that we are recomputing the max profit over for larger and larger prefixes, and for smaller and smaller suffixes.

We know that the prefixes were already computed simply by taking the rolling max instead of the overall max in max_profit. The only thing we’re missing is how to calculate the max_profit of suffixes.

Now we notice a symmetry – while the prefixes are governed by the rolling minimum, the suffixes are bounded by the rolling maximum from the left, i.e. the largest element available at the end to sell into.

To get a sense of this, look at the solutions to the suffixes

3 5 -> 2 (buy at 3 sell at 5)

12 3 5 -> 2 (buy at 3 sell at 5)

5 12 3 5 -> 7 (buy at 5 sell at 12)

9 5 12 3 5 -> 7 (buy at 5 sell at 12)

4 9 5 12 3 5 -> 8 (buy at 4 sell at 12)

Which leads to this solution in q:

`{max reverse[maxs maxs[x]-x:reverse x]+maxs x-mins x}`

maxs x -mins x / is familiar from earlier

If we want to walk backwards through a list, we can reverse the list and apply the logic forwards then reverse the result, which is the same as applying the logic to the suffixes.

So all we need to do is to subtract each element from the running maximum then take the running max of this result to get the max profit for the suffix so far.

In Python this simply becomes:

```
from itertools import accumulate as acc
from operator import add,sub
def max_profit_2trans(p):
before=list(acc(map(sub,p,acc( p,min)),max))
p.reverse()
after=list(acc(map(sub,acc(p,max),p),max))
after.reverse()
return max(map(add,b,a))
```

Alright, finally we should be able to tackle the most general version of this problem (leetcode 188). You are given both a series of prices and allowed to make up to k transactions. Obviously, if k is 1, we solved that first. We just solved k is 2. You can verify for yourself, but if k is larger than half the length of the price series the max is the same as the second problem we solved. Since every pair of days can allow for at most one transaction, effectively k is unlimited at that point.

We need to solve the k>2 but less than k<n/2. The standard CS technique that comes to mind is some kind of dynamic programming approach. To quote MIT’s Erik Demaine CS6006 dynamic programing is recursion plus memoization.

Let’s setup the recursive solution and assume we are at a particular (i)ndex in our price series, with k transactions left.

Let’s start with the base cases:

If k equals 0 we return 0

If i is greater than the last index, i.e. there are no elements left in the list: we return 0.

Otherwise the solution to the problem is simply the maximum of 2 options:

do nothing at this step:

0+the function increment i

do something:

If we are (h)olding a share we can sell at this step which adds the current price +the result of this function with one less k and i incremented by 1.

Otherwise we buy at this step, which is minus the current price (we spend money to buy) plus the result of this function with i incremented and we are now holding a share.

Here is the code for this in q:

p:3 2 5 1 3 2 4 9 5 12 3 5

cache:(0b,'0,'til[count p])!count[p]#0

f:{[h;k;i]$[i=count p;0;(h;k;i) in key cache;cache[(h;k;i)];

:cache[(h;k;i)]:.z.s[h;k;i+1]|$[h;p[i]+.z.s[0b;k-1;i+1];.z.s[1b;k;i+1]-p i]]}

We can test this and see that it results in the right answer for k=0,1,2

f[0b;0;0] -> 0 no surprise with 0 transaction no profit is possible

f[0b;1;0] -> 11 the original problem

f[0b;2;0] -> 15 buy at 1, sell at 9, buy at 5 sell at 12

However, we know that a vector solution is possible for k=1,2,infinity, so we might hope there is a vector solution for when k is 3 and above.

We can analyze the intermediate results of the cache to get some sense of this.

code to look at the table

```
t:(flip `h`k`j!flip key cache)!([]v:value cache)
exec (`$string[j])!v by k from t where not h
```

output table:

```
| 11 10 9 8 7 6 5 4 3 2 1 0
-| --------------------------------
0| 0 0 0 0 0 0 0 0 0 0 0 0
1| 0 2 2 7 7 8 10 10 11 11 11 11
2| 0 2 2 9 9 12 14 14 15 15 15 15
3| 0 2 2 9 9 14 16 16 17 17 18 18
4| 0 2 2 9 9 14 16 16 18 18 20 20
```

What we might notice is that the first row is the running maximum from selling at the prefixes. Then it’s the combination of the previous row and 1 additional transaction. In other words, each row allows you to spend money from the previous row and sell at the current price.

Putting this into action we get the following:

{[k;p]last {maxs x+maxs y-x}[p]/[k;p*0]}

We can look at intermediate rows by writing the scan version of the code and we know it will converge to the unlimited transaction case:

```
{[p]{maxs x+maxs y-x}[p]\[p*0]} p
0 0 0 0 0 0 0 0 0 0 0 0
0 0 3 3 3 3 3 8 8 11 11 11
0 0 3 3 5 5 6 11 11 15 15 15
0 0 3 3 5 5 7 12 12 18 18 18
0 0 3 3 5 5 7 12 12 19 19 20
0 0 3 3 5 5 7 12 12 19 19 21
```

What’s really nice about this code is that it actually describes the problem quite well to the computer and in effect finds exactly what we want.

p*0 / assume we have 0 transactions and therefore 0 dollars at each step.

y-x / subtract the current price(x) from the current profit(y) element wise

maxs y-x/ find the rolling max revenue

x+maxs y-x / add back the current selling price

maxs x + maxs y-x / find the rolling max profit

repeating this k times finds the max profit of the k’th transaction.

Here is the python code that implements this logic:

```
import itertools
from operator import add,sub
def max_profit(k: int, prices: List[int]) -> int:
if k==0 or len(prices)<2:
return 0
z=[0]*len(prices)
maxs=lambda x: itertools.accumulate(x,max)
addeach=lambda x,y: map(add,x,y)
subeach=lambda x,y: map(sub,x,y)
for i in range(k):
z=maxs(addeach(prices,maxs(subeach(z,prices))))
return list(z)[-1]
```

I think this post covers this puzzle, let me know if there are interesting variations I haven’t explored.