# The Blogging Gauntlet: May 10 - Splitwise is NP-Complete

*This is part of The Blogging Gauntlet of May 2016, where I try to write
500 words every day. See the May 1st post for full details.*

Say you go on a group trip. People foot the bill for different expenses, and need to get paid back later. Splitwise is a webapp that does all the bookkeeping for you.

As an example, consider this case. Alice, Bob, Carol, and Dave went on a trip together. Alice spent $60 and needs to get paid back by Bob, Carol, and Dave. Carol spent $20 and needs to get paid back by Bob and Dave. Dave spent $30 and needs to get paid back by Alice and Bob, and Alice’s share should be twice as big as Bob’s.

We can interpret these payments as a weighted directed graph, where people are vertices and edges are payments.

Alice needs $20 from everyone else, Carol needs $10 from Bob and Dave, and Dave needs $20 from Alice and $10 from Bob.

There are some redundancies in the graph. For example, Alice and Dave each need to pay each other $20. Since the net money between them is $0, we should just remove those edges to avoid doing extra transactions.

Splitwise does this for you. In fact, it goes one step further.
**Splitwise tries to minimize the total number of transactions
in the graph.**

Let’s go back to the example above. Carol receives $20 in total from Bob and Dave, then pays $20 to Alice. Instead of routing their money through Carol to Alice, Bob and Dave could pay Alice directly. Carol is still net +$0 and Alice is still net +$20, but now Carol doesn’t have to pay anyone. That reduces the graph to this one.

Bob is sending $10 to Dave, who is sending $10 to Alice. We can simplify this by having Bob send $10 to Alice straight.

We’ve simplified the graph down to a single payment. Pretty neat, right? You can see how a tool that does this automatically could be useful.

This raises an interesting question. How would you solve the Splitwise problem in general? We formalize the problem below.

Let be a weighted directed graph. Given , construct an equivalent graph such that every vertex receives/gives the same amount of money it would in , and has as few edges as possible.

## Flow Representation

My first intuition was that the Splitwise problem was very similar to a network flow problem. You want to shuffle money around a graph while minimizing costs.

This motivated looking at the min-cost flow problem. In the min-cost flow problem, sending one unit of flow through an edge has some cost. We want to minimize cost while sending enough flow through the graph.

The system on the left has total flow, while the system on the right has total flow. Assuming all edges have the same cost per unit flow, the latter graph is cheaper.

Min-cost flow is solvable through linear programming, but it’s not obvious that minimizing the flow in the graph is the same as minimizing the number of edges needed. So, I started looking elsewhere.

## A Greedy Algorithm

Note that in flow problems, we assume only edges in the graph can send things to each other. In the Splitwise problem, anyone can send money to anybody else.

Instead of trying to reduce existing edges, let’s figure out how much everybody should pay, then add edges by ourselves. To minimize the number of edges, one natural idea is to send as much money as possible in every edge. This motivates the following algorithm.

- Read the input to compute the net balance for everyone.
- While someone owes money to somebody else:
- Find the person who owes the most money.
- Find the person who requests the most money.
- Have send as much money as possible to .
- Update everyone’s net balance.

Here’s an example run. owe $1,$2,$3,$4 respectively, and request $5 each. The outputted set of edges is

- sends $4 to
- sends $3 to . (Before this step, is owed $1 and is owed $5.)
- sends $2 to . (Before this step, is owed $1 and is owed $2.)
- sends $1 to .

Every party that owes money must send money at least once, which gives a lower bound of transactions. This solution uses transactions, so it’s optimal.

On mentioning this problem to a friend, he pointed out the following example. Have owe $3, and owe $5. Then have request $6 and request $5. The output is

- sends $5 to
- sends $3 to
- sends $2 to
- sends $1 to

However, we only need transactions if sends money to in the first step.

He then proved Splitwise is NP-Complete, by showing Partition reduces to Splitwise.

## NP-Completeness Proof

First, reformulate Splitwise as a decision problem.

Let be a weighted directed graph. Given and , return whether there exists an equivalent graph with at most edges.

Given a , we can verify it’s valid and has at most edges in polynomial time. So Splitwise is in NP.

Next, construct a reduction from Partition to Splitwise. Given a list of positive integers, we want to know if there is a partition such that both sets have the same total sum.

Given , construct with vertices . Add edges such that owes , and request each.

Any solution to this instance must have at least transactions, because people owe money. Furthermore, if the solution has exactly transactions, must send for their transaction. The edges entering and correspond exactly to a partition of Thus, there is a solution with transactions if and only if a partition exists. Since Partition is NP-Complete, it follows that Splitwise is NP-Complete.

## Splitwise in Practice

It turns out the greedy algorithm gets pretty close to the optimal value in most cases. Based on a Quora post by a Splitwise founder, the site uses something similar.

So, Splitwise isn’t finding optimal solutions on a regular basis. Oh well. I still think it’s neat that an NP-Complete problem fell out at all.