Question

我需要一种将不同制造零件分成不均匀组的算法。主要条件是组中的最大数量与所有其他数量之间的差异应尽可能低。对于

示例：

如果我们有列表[1,3,4,11,12,19,20,21]并且我们决定将其划分为3个部分，则应将其划分为[1,3,4],[11,12],[19,20,21]。在同样的情况下，如果我们决定将其分成4，我们会得到：

 [1,3,4],[11],[12],[19,20,21].

为了澄清“组中最大数量与所有其他数字之间的差异” - [1,3,4] = 4 - 1 + 4 - 3 + 4 - 4 = 4，[11] = 11 - 11 = 0，[12,19] = 19 - 12 + 19 - 19 = 7，[20,21] = 21 -20 + 21 - 21 = 1.总差异= 12.在另一种可能的情况下[1,3,4] ] = 4 - 1 + 4 - 3 + 4 - 4 = 4，[11,12,19] = 19 - 11 + 19 - 12 + 19 - 19 = 12，[20,21] = 21 - 20 + 21 - 21 = 0.总差异= 16.这是过度执行的计算。这是因为大数（代表例如强度）需要替换组中的最小数（最弱）。使用超强部件太昂贵或太重，因此需要进行优化。

首先，我想要以所有可能的组合切割列表，然后计算“组中的最大数量与组中所有其他数字之间的差异”。然后选择最小差异最小的那个作为最终结果。

我想知道在python或Spyder或类似的函数中是否有一些函数内置。如果我需要编写代码，你可以帮帮我吗？

我正在尝试将随机列表分为10，以便在不同情况下重新应用它。 l = sorted(random.sample(range(100), 10)).

Answer 1

由于你没有提到你开始切片背后的逻辑我建议这个功能：

>>> def slicer(l,n):
...  le=len(l)
...  S=int(np.around(float(le)/n))
...  return [l[i:i+S] for i in range(0,le,S)]
... 
>>> slicer([1,3,4,11,12,19,20,21],2)
[[1, 3, 4, 11], [12, 19, 20, 21]]
>>> slicer([1,3,4,11,12,19,20,21],3)
[[1, 3, 4], [11, 12, 19], [20, 21]]
>>> slicer([1,3,4,11,12,19,20,21],4)
[[1, 3], [4, 11], [12, 19], [20, 21]]

在这里，我使用numpy.around围绕float(le)/n来获得真正的切片！

Answer 2

根据您更新的评论，听起来您正在寻找K-Means算法或类似的东西，它会根据列表元素与建议中心的距离将您的列表元素聚类成不同的组（这就是您的差异计算是真正的测量）。

在您的标准中，请注意从每个子组中减去每个子组的最大值是没有意义的，因为根据定义它总是为零。所以你真的在看所有非最大元素的最大值减去每个元素的总和（如何处理重复项也是你需要回答的问题）。 K-Means将做一些不同的事情（它会看到每个点与点的平均值的距离），但在精神上它是相同的。你可以修改k-means来使用你的团队分数的概念，虽然我没有看到在聚类输出方面有任何好处 - 我需要看一些关于限制行为的数学证明。不同的标准让人相信它很重要。

您可以使用sklearn和numpy模块轻松实现此目标：

from sklearn import cluster as cluster
import numpy as np

km = cluster.KMeans(n_clusters=4)
example_data = np.asarray([1,2,3, 11,12, 20,21,22, 30,35])[:,None]

km.fit(example_data)

然后查看km.labels_：

In [65]: km.labels_
Out[65]: array([0, 0, 0, 3, 3, 1, 1, 1, 2, 2], dtype=int32)

您可以看到，这会将[1,2,3]，[11, 12]，[20, 21 , 22]，[30, 35]放在一起。下面是一些实际上适合您的代码：

In [74]: example_data.tolist()[0]
Out[74]: [1, 2, 3, 11, 12, 20, 21, 22, 30, 35]

In [75]: [[x for i,x in enumerate(example_data.tolist()[0]) if km.labels_[i] == j] 
          for j in range(km.n_clusters)]

Out[75]: [[1, 2, 3], [20, 21, 22], [30, 35], [11, 12]]

但请注意，这并不完美：它是一种不能保证收敛到任何“真实”解决方案的迭代方法，而且对于奇怪的输入数据，您可以获得奇怪的输出。

或者，对您想要的内容有一个更基本的了解是选择索引整数i[0]到i[k]，这样

sub_lists[j] = original_list[i[j]:i[j+1]]

i[0]=0和i[k+1]被理解为“列表中的其他所有内容”。然后定义：

sub_lens = [len(s) for s in sub_lists]
max_len  = max(sub_lens)
criterion(k, i[0], ..., i[k]) = max(max_len - s_len for s_len in sub_lens)

因此，您的解决方案是一个参数元组(k, i[0], ..., i[k])，您希望选择最小化上述表达式criterion。

这个问题的通用解决方案非常复杂。但是如果你愿意接受一个非常平衡的贪婪解决方案，除了最终的子列表之外，很多these solutions都会这样做。

Answer 3

编辑：根据澄清的问题，这是另一种算法。如果相关，我仍然保留下面的原始回复。

您可以使用动态编程解决问题。请注意，下面的代码没有针对速度进行优化，因为我认为这会让它太难理解。如果您仔细实施，可以在O(N * K)中执行，其中N的长度为a，K是要分区的数量。

a = [1,3,4,11,12,19,20,21]
S = []
K = 3

# memoize results in (len(a) + 1) by K array                                                                                                                             
memo_partitions = [[None for j in xrange(len(a) + 1)] for i in xrange(K + 1)]

def compute_cost(arr):
    # this is the objective to be minimized                                                                                                                              
    if len(arr) == 0:
        return 0
    return sum(arr[-1] - x for x in arr)

def compute_best_partition(k, n):
    # computes the best partition of the first `n` elements of `a`                                                                                                       
    # into `k` parts                                                                                                                                                     
    if n == 0:
        return [[] for _ in xrange(k)], 0
    if k == 1:
        return [a[:n]], compute_cost(a[:n])

    if memo_partitions[k][n] is not None:
        return memo_partitions[k][n]

    best_partition = [[] for _ in xrange(k - 1)] + [a[:n]]
    best_cost = compute_cost(a[:n])
    for i in xrange(1, n):
        last_group = a[i:n]
        additional_cost = compute_cost(last_group)
        partition, cost = compute_best_partition(k - 1, i)

        if cost + additional_cost < best_cost:
            best_partition = partition[:]
            best_partition.append(last_group)
            best_cost = cost + additional_cost

    memo_partitions[k][n] = (best_partition, best_cost)
    return memo_partitions[k][n]

best_partition, cost = compute_best_partition(K, len(a))
print best_partition

以下原始回复。

以下两种方法可能会满足您的需求。假设您的数字按升序排列

a[0], a[1], ... , a[n - 1]

让max_diff(S)表示集S的两个元素之间的最大差异。我们希望将数字分成集S[0], ... , S[k - 1]，以使max_diff(S[i])很小。

首先，假设我们正在尝试最小化max_diff(S[i])的总和。请注意，max_diff(S[i])的总和仅为a[n - 1] - a[0]减去＆＃34;间隙＆＃34;在S[i]之间。因此，您可以找到k - 1中最大的a[i + 1] - a[i]并排除它们。在python代码中，

a = [1,3,4,11,12,19,20,21]
S = []
k = 3

diffs = [(a[i + 1] - a[i], i) for i in xrange(len(a) - 1)]
diffs.sort()
best_cuts = [i for diff, i in diffs[-k:]]
best_cuts.sort()

last_cut = 0
for cut in best_cuts:
    S.append(a[last_cut:cut + 1])
    last_cut = cut + 1
S.append(a[last_cut:])
print S

或者，假设我们正在尝试最小化max_diff(S[i])的最大值。然后，我们可以对可实现的值进行二进制搜索。在代码中，

a = [1,3,4,11,12,19,20,21]
S = []
k = 3

best_partition = None
low, high = 0, max(a)
while low < high:
    mid = (low + high) / 2

    # try to get all max_diffs <= mid                                                                                                                                    
    full_partition = []
    last_set = [a[0]]
    for val in a[1:]:
        if val > last_set[0] + mid:
            full_partition.append(last_set)
            last_set = [val]
        else:
            last_set.append(val)
    full_partition.append(last_set)

    if len(full_partition) > k:
        low = mid + 1
    else:
        high = mid
        best_partition = full_partition

S = best_partition
print S

在特殊条件下将列表拆分为不同长度的部件

3 个答案: