Question

我们有一个元素列表 [A，B，C，D，E] 和 3组，以合并这些元素，我想打印一个列表所有唯一组合，而无需重复这3组。只有长度为[2,2,1]的组才有效（可以在之后将其过滤，这不是必须的，但这是明智的选择，如果需要，可以手动将组的长度指定为参数）。我所说的独特而无重复：

[[A，B]，[C，D]，[E]]和[[C，D]，[A，B]，[E]]和[[B，A]，[C，D] ]，[E]]相同，所以组中元素的顺序或组的顺序无关紧要，我对这些组合不感兴趣。

在我的特殊情况下，我有16个项目，每组3个，分别为5、5和6个项目。

我要实现的示例：

<?php
/*
Template name: cliente-p1
*/
?>


<?php

get_header( 'shop' );

get_template_part( 'content', 'shop' );

// Add Custom Shop Content if set
if(is_shop() && flatsome_option('html_shop_page_content') && ! $wp_query->is_search() && $wp_query->query_vars['paged'] < 1 ){
    echo do_shortcode('<div class="shop-page-content">'.flatsome_option('html_shop_page_content').'</div>');
} else {
    if ( fl_woocommerce_version_check( '3.3.0' ) ) {
        wc_get_template_part( 'woocommerce/layouts/category', flatsome_option( 'category_sidebar' ) );
    } else {
        wc_get_template_part( 'woocommerce/back-comp/layouts/w32-category', flatsome_option( 'category_sidebar' ) );
    }
}

get_footer( 'shop' );
?>

输出将是这样的：

/**
 * Returns all the unique combinations of a group into multiple groups
 * [data] the group of elements to combine
 * [numberOfGroups] the number of groups
 */
fun combinations(data: List<String>, numberOfGroups: Int): List<List<List<String>>> {
    // The combinations code
}

val data = listOf("A", "B", "C", "D", "E")
print(combinations(data, 3))

谢谢。

Answer 1

我一般不知道您的问题的答案，但是我将尝试解决将5个元素的列表分成几组[2，2，1]的特殊情况，并分享一些可能有用的原理您可以设计一个更通用的解决方案。

首先，让我们谈谈如何表示结果。如果组内元素的顺序不重要，则用Set<String>表示组很方便，因此setOf("A", "B")等于setOf("B", "A")。然后，如果组合本身中组的顺序无关紧要，则该组合可以是一组组，即Set<Set<String>>。

现在介绍算法本身。将这种算法构造为递归搜索很方便：您从数据中选择第一组项目，然后在没有选定项目的情况下解决数据问题，并将第一组与除它之外的所有解决方案合并。因此，我们搜索组合的功能可以如下所示：

fun combinationSequence(data: List<String>): Sequence<Set<Set<String>>> = sequence {
    for (group in possibleFirstGroups(data)) {
        val remaining = data - group
        if (remaining.isEmpty()) {
            yield(setOf(group))
        } else {
            yieldAll(combinationSequence(remaining).map { r -> setOf(group) + r })
        }
    }
}

然后如何以所有可能的方式选择第一个组。对于大小为1或2的组，我们可以从所有数据元素中选择组的第一个元素，然后从其余的元素中选择第二个元素：

fun possibleFirstGroups(data: List<String>): Sequence<Set<String>> =
        when (data.size) {
            0 -> emptySequence()
            1, 2 -> sequenceOf(data.toSet())
            else -> sequence {
                for (e1 in data) {
                    for (e2 in data - e1) {
                        yield(setOf(e1, e2))
                    }
                }
            }
        }

我们的combinationSequence返回结果，但是会有很多重复，例如[[A, B], [C, D], [E]]和[[C, D], [A, B], [E]]。要只保留其中的不同之处，我们可以使用函数distinct：

combinationSequence(data).distinct().forEach { println(it) }

请注意，此解决方案的复杂度会随着项目数量的增加而呈指数增长，因此我不希望16个元素的解决方案能够及时终止：）

减少复杂性的一种方法是修剪搜索空间。例如，如果我们已经找到以[A, B]组开头的 all 个组合，则可以避免产生包含该组位于中间某个位置的组合，例如[C, D], [A, B], ...。

将一个组合并为多个组而无需重复

1 个答案: