均匀分组的最好方法是什么？

Question

I am trying to evenly distribute the total amount to each person involved.

For example i will use money.

Example 1

Person A has $20

Person B has $40

Person C has $60

So to make everything even the solution is Person C giving person A $20.

Example 2

Person A has $36

Person B has $15

Person C has $9

To make this situation even...

Person A gives Person B $16 then Person B gives Person C $11,

Or Person A gives Person B $5 and Person C $11

Example 3

Person A has $53

Person B has $95

Person C has $24

Person D has $98

Person E has $30

Each Person needs $60, How could i figure out the way to do this that involves the least amount of moving the money around?

Answer 1

A natural approach is: the person with the most gives to the person with the least; then repeat.

Specifically: you can calculate the amount V everyone should have at the end (it's just the average of everyone's starting amounts). Then if the person with the most has M and the person with the least has L, give min(MV,VL) from the person with the most to the person with the least. After that move, at least one of those two people has the correct amount. Now repeat until everyone has the desired amount.

The number of moves will be at most the number of people.

I suspect this might be optimal, but you should check that yourself. You might try applying the methods in https://cs.stackexchange.com/q/59964/755 to see if you can find a counterexample or prove it correct.

Answer 2

It seems a shame to leave such a question unanswered because it's not difficult to solve - let's use your last example:

• Person A has $53
• Person B has $95
• Person C has $24
• Person D has $98
• Person E has $30

I'll use an array for simplicity.

const totals = [53, 95, 24, 98, 30]
let sum, target, moveCounter = 0

if (totals.length) {
  sum = totals.reduce(function(a, b) { return (a + b) })
  target = sum / totals.length
}

The target is simply the average of the totals, $60 in the case of the example.

let needs = totals.map(function(a){ return target - a })
// needs = [7, -35, 36, -38, 30]

Now you know what each of the needs are.

[0] needs to get $7, [1] needs to drop $35, [2] needs to get $36, etc.

The array is zero sum : (7) + (-35) + (36) + (-38) + (30) = 0

Your problem is how to get each of the elements to 0 in as few moves as possible.

You can check if any of the elements cancel each other out, for example [20, -20]. An efficient way to check this would be to create a Set.

let unmatched = new Set([])
let matches = []
needs.forEach((need) => {
  if (0 !== need) {
    let value = Math.abs(need)
    if (unmatched.has(value)) {
      matches.concat([need, -need])
      unmatched.delete(value)
    } else {
      unmatched.add(value)
    }
  }
})

if (matches.length) {
  matches.forEach((matchElement) => {
    let index = needs.findIndex((needElement) => {
      return matchElement === needElement
    })
    if (index) {
      needs[index] = needs[index] - matchElement
      moveCounter = moveCounter + 1
  })
}

At this point all of the easy moves are done, you can sort the array and brute force the rest. Sorting makes things a little bit easier.

var sortedNeeds = needs.sort(function(a, b){ return a < b ? -1 : 1 })
// [-38, -35, 7, 30, 36]

The array is zero sum so you could split it into two parts left and right . Think of it as the left and right side of a balanced equation.

const zeroIndex = sortedNeeds.findIndex((value) => { return 0 === value })
// zeroIndex : -1

const positiveIndex = sortedNeeds.findIndex((value) => { return value > 0 })
// positiveIndex : 2

const leftLimit = (zeroIndex > -1) ? zeroIndex : positiveIndex
// leftLimit : 2

let left = sortedNeeds.slice(0, leftLimit)
// left: [-38, -35]

let right = sortedNeeds.slice(positiveIndex)
// right: [7, 30, 36]

The next piece is magic:

moveCounter = moveCounter + (left.length - 1) + right.length
// 4 = 0 + 1 + 3

It doesn't matter how you work it out because the zero sum relationship is the key.

1. D gives B $38
2. B gives A $7
3. B gives C $36
4. B gives E $30