Предложение на алгоритме для распределения объектов другого значения

как насчет этого:

упорядочить значения k. упорядочить игроков.

перебирайте значения k, передавая следующее значение следующему игроку. когда вы дойдете до конца игроков, развернитесь и продолжайте раздавать значения k игрокам в обратном направлении.

Жадное решение, предложенное несколькими людьми, кажется лучшим вариантом, я запускал его несколько раз с некоторыми случайными значениями, и, кажется, каждый раз все получается правильно.
Если это не оптимально, то, по крайней мере, очень близко, и оно выполняется за O (нм) или около того (я не могу сейчас потрудиться с математикой)
Реализация C #:

 статический список > Dist (значения int n, IList )
{
var result = new List > ();
для (int i = 1; i <= n; i ++)
result.Add (новый список  ());
var sortedValues ​​= values.OrderByDescending (val => val);
foreach (int val в sortedValues)
 {
var low = result.OrderBy (a => a.Sum ()). First ();
самый низкий.Добавить (val);
 }
вернуть результат;
}

РЕДАКТИРОВАТЬ:

Целью было использовать жадное решение с небольшим улучшением реализации, которое может быть прозрачным в C #:

static List<List<int>> Dist(int n, IList<int> values) 
{ 
    var result = new List<List<int>>(); 
    for (int i = 1; i <= n; i++) 
        result.Add(new List<int>()); 
    var sortedValues = values.OrderByDescending(val => val);//Assume the most efficient sorting algorithm - O(N log(N))
    foreach (int val in sortedValues) 
    { 
        var lowest = result.OrderBy(a => a.Sum()).First();//This can be done in O(M * log(n)) [M - size of sortedValues, n - size of result]
        lowest.Add(val); 
    } 
    return result; 
} 

Относительно этого этапа:

var lowest = result.OrderBy(a => a.Sum()).First();//This can be done in O(M * log(n)) [M - size of sortedValues, n - size of result]

Идея состоит в том, что список всегда отсортирован (в этот код делает OrderBy). В конце концов, эта сортировка не займет больше, чем O (log (n)) - потому что нам просто нужно ВСТАВИТЬ не более одного элемента в отсортированный список - что должно принимать то же самое, что и двоичный поиск. Поскольку нам нужно повторить эту фазу для sortedValues.Length раз, весь алгоритм выполняется за O (M * log (n)).

Таким образом, это можно перефразировать так: Повторяйте шаги ниже, пока не закончите значения Значения : 1. Добавьте наибольшую ценность к наименьшему игроку. 2. Проверьте, есть ли у этого игрока наименьшая сумма. 3. Если да, переходите к шагу 1. 4. Вставьте последнего полученного игрока в отсортированный список игроков

Шаг 4 - это шаг O (log (n)), поскольку список всегда отсортирован.

Несколько раз отдавайте доступный объект с наибольшим значением игроку, у которого наименьшее общее значение назначенных ему объектов.

30 ^ 6 не так уж и много (это меньше 1 миллиарда). Переберите все возможные варианты распределения и выберите тот, который является самым справедливым по любой мерке, которую вы определите.

Это прямая реализация ответа Джастина Пила:

M = 3
players = [[] for i in xrange(M)]

values = [10,4,3,1,1,1]
values.sort()
values.reverse()
for v in values:
    lowest=sorted(players, key=lambda x: sum(x))[0]
    lowest.append(v)

print players
print [sum(p) for p in players]

Я новичок в Python, но, кажется, все работает нормально. Этот пример выведет

[[10], [4, 1], [3, 1, 1]]
[10, 5, 5]