递归地将一组n个对象的所有分区分成k个非空子集
，可以使用回溯算法来解决。回溯算法是一种通过不断尝试所有可能的解决方案来找到问题解的方法。
首先，我们需要定义一个递归函数，该函数将接收以下参数：
- objects：表示一组n个对象的列表
- k：表示要将分区分成的子集数量
- partition：表示当前的分区情况，初始为空列表
- result：表示最终的结果列表，初始为空列表
递归函数的基本思路如下：
- 如果k等于1，表示已经将分区分成了k个子集，将当前的分区情况加入结果列表中。
- 如果objects为空，表示已经遍历完所有对象，但还没有将分区分成k个子集，直接返回。
- 对于每个对象，尝试将其放入当前的分区中，并递归调用函数处理剩余的对象和k-1个子集。
- 在递归调用返回后，将当前对象从分区中移除，继续尝试下一个对象。
下面是一个示例的递归函数的实现：
def partition_objects(objects, k, partition, result):
if k == 1:
result.append(partition[:])
return
if not objects:
return
for i in range(len(objects)):
partition.append(objects[i])
partition_objects(objects[i+1:], k-1, partition, result)
partition.pop()
使用该函数可以得到所有分区的情况，然后根据需要进行进一步处理。
这个问题的应用场景比较广泛，例如在任务调度、资源分配、数据分析等领域都可能会遇到类似的问题。
腾讯云提供了丰富的云计算产品，其中一些与该问题相关的产品包括：
- 云服务器（CVM）：提供弹性计算能力，用于部署和运行应用程序。
- 云数据库MySQL版（CDB）：提供可扩展的关系型数据库服务，用于存储和管理数据。
- 云存储（COS）：提供高可靠、低成本的对象存储服务，用于存储和管理大量的非结构化数据。
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，用于实现智能化的数据分析和处理。
更多腾讯云产品的介绍和详细信息，可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
这个程序是用来计算一个有n个元素的集合划分成k个子集的个数，我把这里搞糊涂了，return k*countP(n-1, k) + countP(n-1, k-1);，有人能解释一下这里发生了什么吗？为什么我们要乘以k？
注意->我知道这不是计算DP分区数量的最佳方法
// A C++ program to count number of partitions
// of a set with n elements into k subsets
#include<iostream>
using namespace std;
// Returns count of di
浏览 4提问于2018-12-16得票数 8
2回答
这看起来是一个简单的请求，但google并不是我的朋友，因为“分区”在数据库和文件系统空间中的命中率很高。
我需要将包含N个值(N是常量)的数组的所有分区枚举到k个子数组中。子数组就是这样--一个起始索引和一个结束索引。原始数组的整体顺序将被保留。
例如，使用N=4和k=2：
[ | a b c d ] (0, 4)
[ a | b c d ] (1, 3)
[ a b | c d ] (2, 2)
[ a b c | d ] (3, 1)
[ a b c d | ] (4, 0)
使用k=3：
[ | | a b c d ] (0, 0, 4)
[ | a | b c d ] (0, 1,
浏览 0提问于2010-12-30得票数 7
回答已采纳
给定n(n <= 20)个非负数。有没有一种时间复杂度可以接受的算法来确定n个数是否可以被分成K(K <= 10)个不相交的子集，使得每个子集具有相等的和？
浏览 0提问于2014-12-06得票数 0
给定一个大小为n的数组，问题是按排序顺序返回前k个最小的元素。我的想法是更新一个QuickSort算法，首先找到第一个k元素，然后递归更新问题来找到k-1最大的元素。找不到我的错误所在。
def partition(a, left, right):
pivot = a[left]
p = left
q = right
while(p < q):
while(a[q] > pivot and p < q):
q-=1
while(a[p] <= pivot and
浏览 0提问于2019-04-02得票数 0
1回答
试图找出以下问题：
给定N个正整数的集合S，其任务是将它们划分为K个子集，使每个K子集中元素值之和相等。
我想用一组不超过10个整数的值，值不大于10，小于5个子集来实现这一点。所有整数都需要分布，只有完美解(即所有子集都相等，不接受近似)才能被接受。我想使用回溯递归地解决它，。我在网上找到的大多数资源都是使用其他我不理解的方法，使用位掩码或其他什么的，或者只用于两个子集，而不是K子集。
我的第一个想法是
按升序对集合进行排序，检查所有基本情况(例如，不可能有均匀分布)，计算所有子集必须具有的平均值，以便所有子集相等。
遍历每个子集，填充每个子集(首先从最大值开始)，直到达到平
浏览 3提问于2017-05-11得票数 0
2回答
我试图在O(n)中找到一个分而治之的算法来解决这个问题，但我什么也没找到。给定一个数组A和给定的值k，找出和大于或等于k的最小子集。有人能给我一个开始解决这个问题的想法吗？
任何帮助都是非常感谢的。
浏览 58提问于2021-03-06得票数 2
回答已采纳
2回答
分割问题Brute力算法
、、、、
我试图在蛮力中为下面的分区问题执行伪代码。
一组整数X和整数k (k >1)。找出X的k个子集，使得每个子集中的数之和为相同的数量，并且没有两个子集有一个共同的元素，或者得出这样的k子集不存在的结论。这个问题是NP-完全的。
例如，如果X= {2，5，4，9，1，7，6，8}和k= 3，一个可能的解决办法是：{2，5，7}，{4，9，1}，{6，8}，因为它们的总和都是14。
对于详尽的搜索，我知道通常情况下，我们必须搜索所有可能的解决方案，并查看目标是否类似。但由于这是分区问题，这可能很棘手。
算法蛮力：
Subset= X.sum/K //I had a guess this
浏览 1提问于2015-12-31得票数 7
回答已采纳
1回答
标准的一个小的变化是，我们想要从N的一组大小中找到K的一个子集，它的总和为S。
标准的蛮力解产生一个复杂度O(N^K)。但是，上面的链接提到了蛮力法的一个变化，复杂性O(N^(K/2))。
维基的文章说
给出了一种较好的指数时间算法，该算法在时间O(2N/2)中运行。该算法将N个元素任意分解成两组N/2。对于这两个集合中的每一个，它存储其元素的所有2N/2可能子集的和的列表。然后对这两个列表中的每一个进行排序。对于这个步骤，使用标准的比较排序算法需要时间O(2N/2N)。但是，给定k元素和的排序列表，可以通过引入(k + 1)st元素将列表扩展为两个排序列表，这两个排序列表可以在时间O(2k
浏览 4提问于2013-12-03得票数 2
3回答
我知道如何使用递归来生成所有可能的组合，即N选择K。但是如何创建K的所有可能的N/K组？当然，N总是可以被K整除。为了澄清:例如，如果N是20，K是4，那么我想生成所有可能的四个五组。如果N包含1，2，3…20，K是4，那么这样的一个分组是{1,2,3,4}，{5,6,7,8}，{9,10,11,12}，{13,14,15,16}，{17,18,19,20}。假设N相对较小，因此递归是可行的
我觉得这是一个递归中的递归问题，因为生成所有可能的四人一组(也就是N选择K)需要递归，然后生成下一个四人组成为N-4选择K，下一个N-8选择K，依此类推。但是我在实现this...any帮助时遇到了问题吗
浏览 3提问于2014-01-14得票数 5
我有一个计算子集的Haskell函数。
subsets :: [a] -> [[a]]
subsets [] = [[]]
subsets (x:xs) = [zs | ys <- subsets xs, zs <- [ys, (x:ys)]]
使用实例：
*Main> subsets [1,2,3]
[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
如果我加上这个定义：
ksubsets k xs = [ys | ys<-subsets xs, length ys==k]
我可以计算一组n个元素的子集，其中每个子集都有完全k个
浏览 1提问于2018-10-06得票数 1
1回答
划分:给定一组正整数A={a_1，.，a_n}，A的子集是否存在与其补和相等的子集？
子集和:给定一组正整数A={a_1，.，a_n}和另一个正整数B，它是否存在A的子集，使得它的和等于B？
我试图证明，如果划分是NP-完全的，那么子集和也是NP-完全的，方法是将部分归为SSUM。
我的解决方案是:设A={a1，.a}是一组正整数。如果A部分给出解I={k1，.，km} (其中k_i是解子集成员的指数)，则构造A'={a1，...an，S}，其中S是{a_k1，a_k2，…，a_km}的和.A‘是SSUM的解决方案。
我的问题是，这只会走一条路，这意味着我们不能证明给定的A‘那么A是一
浏览 0提问于2017-02-06得票数 0
回答已采纳
给定一个从1...N开始的整数列表，我试图找到元素的K个子集，同时保持元素的顺序。例如，当N=4和K=2时：
1
1，2
1、2、3
1、2、3、4
将是正确的输出。到目前为止，我已经得到了第一列可能性。但我很难找到正确的逻辑。
final = [['' for x in range(K)] for y in range(N)]
i = 0
for k in range(0, K):
# row tracker
i = 0
while i < N:
if k > 0:
浏览 25提问于2019-03-26得票数 2
回答已采纳
1回答
正整数n的分区是正整数的非递增数组。
a1，a2，.，am
满足感
a1 + a2 +. +am = n.
M称为这个分区的长度。
我们可以按指定的顺序列出n的所有分区。例如，如果我们使用词典编纂对所有英语单词进行排序的规则，就称为词典顺序。另一种方法是，如果我们使用C语言比较字符串的规则，则称为反向字典顺序。还有一个colex命令。
为了生成一个整数n的所有分区，我们有一个Stojmenovic提出的很好的算法，这个算法已经包含在Knuth的书中。生成了长度为m的所有分区，我们可以使用colex顺序，这个算法也包含在Knuth的书中。生成n的所有不超过k元素的分区，我们可以在1中使用该算法，
浏览 5提问于2010-10-16得票数 3
1回答
迭代快速排序的时间复杂度
、、、、
我已经学习了递归快速排序，它用O(nlogn)表示最佳情况，O(n^2)表示最坏情况。但是我正在努力寻找迭代快速排序的时间复杂度，我知道它是O(nlogn)表示最佳情况，O(n^2)表示最佳情况。但我不会在最好的情况下证明它是合理的。我正在学习本教程 https://www.techiedelight.com/iterative-implementation-of-quicksort/ 假设我们有15个元素，因此轴心索引的位置总是在中间，这是最理想的情况。但我发现它的条件是"while (!stack.empty())“，即分区的数量将发生6次，这与log(n)不接近。如何证明迭代快
浏览 14提问于2020-04-25得票数 0
2回答
这是一个家庭作业，所以任何帮助都是非常感谢的。
我应该证明以下问题是NP-完全的。提示说，您应该将子集和问题简化为这个问题。
给定一组形状(如下面的形状)和一个m-by-n板，决定是否可以完全覆盖所有形状。请注意，形状可能不会旋转。
例如，对于3×5板和以下部分，可以像这样覆盖板：
现在需要注意的是，我们想要减少的子集和问题应该是用、m、和n表示的输入长度多项式。
任何关于使用另一个NP-完全问题的想法都会受到赞赏。
浏览 2提问于2015-06-01得票数 5
回答已采纳
2回答
我有一个递归函数，它从一组n生成长度k的所有组合。通常称为"nCk“("n选择k")。我希望用相当大的数值(56C22)来释放它，这将产生2,142,582,442,263,900个结果。由于实现方面的限制(我必须使用VBScript，不能比工作时间更长的时间登录到计算机上)，我不能让它一次完成。因此，我希望定期保存该函数的当前状态并恢复它( later...but )--我似乎找不出如何做到这一点。递归影响了我从逻辑上思考这个问题的能力。
我在这里仔细阅读了关于SO的建议解决方案，并在“恢复递归函数”等方面进行了搜索，但没有结果。我希望有一些指点(不是编程语言双关语)
浏览 4提问于2016-07-16得票数 4
回答已采纳
2回答
我想问的是，如何检查一组数字是否可以分成子组(每个子组必须有3个成员)，每个子组成员的和都是相等的。怎么检查这么多组合？
示例：
int numbers[] = {1, 2, 5, 6, 8, 3, 2, 4, 5};
可分为
{1, 5, 6}, {2, 8, 2}, {3, 4, 5}
浏览 6提问于2017-03-21得票数 2
回答已采纳
下面的代码为给定的列表生成长度为k的所有分区(k子集分区)。该算法可以在主题中找到。
def algorithm_u(ns, m):
def visit(n, a):
ps = [[] for i in xrange(m)]
for j in xrange(n):
ps[a[j + 1]].append(ns[j])
return ps
def f(mu, nu, sigma, n, a):
if mu == 2:
yield visit(n, a)
浏览 0提问于2017-08-23得票数 20
我得到了一个数组(更确切地说，是一个多集)，比如说L。现在，我需要告诉这个集合中形成两个子集(多集)所需的元素的最小数量( L)，使得这两个子集中的每个子集的元素之和至少为k(给定的整数)。 我想到的基本想法是:最初，我们有两个空数组/集合。首先，将最大的元素添加到其中一个元素中。现在，从第二个最大的元素开始，我将一个元素添加到两个元素中具有最小和的子集，然后继续下去，直到我得到这两个元素的和至少为k。这个解决方案在许多测试用例中都有效，但后来我发现了一个反例，证明了这个解决方案是不正确的。反例是:以L=1，2，4，5，6，7，8和k=16为例。 我知道这个问题在某种程度上是子集求和问题的一
浏览 36提问于2021-01-11得票数 1
1回答
给定一个包含n个正整数(n为偶数)的列表，将该列表划分为两个子列表，使得这两个子列表中的整数之和的差值最小化。这是NP-完全问题还是NP-hard问题？
浏览 5提问于2016-05-06得票数 1
2回答
索引大小为k的子集
、、、
有大小为k的{1,2，...，n}的n个选择k子集。这些子集可以通过对元素进行排序并使用词法顺序来自然排序。
有没有一种快速的方法来确定给定子集的索引，即它在大小为k的所有子集的排序列表中的索引？一种方法是通过枚举大小为k的所有子集来创建从子集到索引的字典，但这需要n选择k个空间和时间。对于我的应用程序，n和k是不可能的大，但我只需要确定相对较少的子集的索引。
我用Python编写代码，但我对通用算法比任何具体实现更感兴趣。当然，如果在Python中有一种特别快的方法可以做到这一点，那就太好了。
动机:大小为k的{1,2，...，n}的子集双射地对应于n维向量空间的k个外幂的基向量。我在向量空
浏览 1提问于2013-11-30得票数 2
2回答
我在网上某个地方找到了这段代码，我正试图弄清楚它是如何工作的。您为partitions()函数提供了一个整数，代码将返回不包含重复编号的不同分区的数量(例如n=5 -> 2 partitions (3,2) & (4,1))。我想了解这个递归解决方案到底是如何管理这一点的。我一直在摆弄代码，跟踪递归调用，但我仍然不太明白它是如何工作的。请帮我理解一下。
def partitions(n):
memo = [[0 for _ in range(n + 2)] for _ in range(n + 2)]
return bricks(1, n, memo) - 1
浏览 3提问于2020-06-25得票数 2
有很多关于StackOverflow的信息，但我无法准确地弄清楚我需要它的方式。
我试图用中间值来实现一个quickSelect算法，但并不能完全实现它。
该算法应该使用以下步骤找到数组中输入n>1元素的第一个最小元素：
如果返回数组中的元素.
将数组中的n个元素划分为"groupSize“组和多一组"groupSize”-1元素。最初的算法是5组，但我希望它是模块化的。
通过使用插入排序和选择排序子数组的中值来查找n/groupSize的每个上限值的中值。
call Select递归地查找步骤3中发现的上限值n/groupSize中介的中位数"x“，考虑到中间值
浏览 7提问于2022-08-17得票数 1
1回答
：给定一组具有开始和结束时间的活动A，找到一个相互兼容的活动的最大子集。
我的问题
这两种方法似乎是相同的，但是firstApproach中的firstApproach是指数型的，而secondApproach中是O(n^2)的。如果我要回忆录的结果，那么我如何回忆录firstApproach？
朴素的 firstApproach
let max = 0
for (a: Activities):
let B = {Activities - allIncompatbleWith(a)}
let maxOfSubproblem = ActivitySelection(B)
浏览 0提问于2019-04-22得票数 1
我在课本上有这样一个问题:给出一组n个项目，每个项目都有不同的值V(i)，什么是将项目分成3组的最佳方法，从而具有最高值的组是minimIzed？给出这个最大群体的价值。
我知道如何做这个问题的两堆变体:它只需要在问题上反向运行背包算法。然而，我对如何解决这个问题感到相当困惑。有谁能给我指点一下吗？
答:和0-1背包差不多，虽然是2D的
浏览 0提问于2012-01-07得票数 8
回答已采纳
1回答
假设我们有一个只有唯一值的向量，并且想要生成所有对。这样做的算法是：
vector< int > data;
// ... pushback some data
vector< vector< int > > pairs;
for( size_t i = 0; i < data.size() - 1; ++i )
{
for( size_t j = i + 1; j < data.size(); ++j )
{
vector< int > pair;
pair.push_back(
浏览 3提问于2013-01-27得票数 2
回答已采纳
N元素集合的第k个分位数是k-1个顺序统计量，它将排序后的集合划分为k个大小相等的集合(小于1)。给出了一个列出集合第k个分位数的O(n lg k)-time算法。
直接的解决方案是选择每个k，2k，3k。ik是运行时间为O(kn)的最小元素(k调用O(N)的选择过程)。但这可以优化为比O(kn)做得更好。在select过程中找到索引'i‘处的中位数后，我们进行以下递归调用。
如果中位数i的中位数的索引> k，则递归调用select左子数组A0中的第k个最小元素...我
如果i< k，则递归地选择右子数组Ai+1中的第n-i+k个最小元素...n.
上面的递归调用是否可以像
浏览 0提问于2010-10-11得票数 8
1回答
我有两套-
set1 - {i1，i2，i3...iN1}
set2 - {k1，k2，k3...kN2}
对于任意一组n项，我可以使用位掩码0-2^n-1表示所有可能的子集。同样，我怎样才能代表-
set1和set2的所有可能子集，其中至少有一个项来自不同的集合。
例如
{i1，i2，k1}有效
但是{i1，i2} -无效，因为它没有来自set2的项。
我试着产生两件事-
一种方程，它可以给出所有子集的计数，就像单个n项集有2^n个子集一样。
位编码/掩码，我可以用它来表示以上类型的子集。
浏览 2提问于2017-08-15得票数 0
我需要划分一个由连续数字组成的集合S={1, 2, 3, … , n}，这样每个子集至少有2个元素(规则1)，并且它由连续数字(规则2)组成。
这些规则是：
每个子集至少有两个元素。
所有子集的所有元素都是连续的。
S的所有元素都包含在分区中。
示例：
There is 1 subset for n = 2:
1 2
There is 1 subset for n = 3:
1 2 3
There are 2 subset combinations for n = 4:
1 2 3 4
1 2 - 3 4
There are 3 subset combi
浏览 4提问于2015-03-02得票数 1
回答已采纳
2回答
递归算法的时间复杂性
、、、
每当我看到一个递归解决方案，或者我为一个问题编写递归代码时，我真的很难计算出时间的复杂性，在大多数情况下，我只是说它是指数的？它怎么会是指数呢？人们怎么说它是2^n，当它是n!，当它是n^n或n^k。
我有一些问题想问-
假设找到字符串的所有排列(O(n!))
找到数组中所有与k之和的序列(指数，我是如何计算的)。
找出k大小的所有子集，其和为0(将k表示复杂性，应该是吗？)。
any1能否帮助我计算出这些问题的精确复杂度，我能够为它们编写代码，但它很难理解确切的时间复杂度。
浏览 2提问于2012-12-09得票数 3
回答已采纳
2回答
我想在main方法中递归地打印生成的数组的所有子集。
下面几行显示了我的代码。我不知道如何递归地实现方法subsets()。
public class Main {
// Make random array with length n
public static int[] example(int n) {
Random rand = new Random();
int[] example = new int[n + 1];
for (int i = 1; i <= n; i++) {
exampl
浏览 0提问于2016-05-03得票数 2
根据的帖子：
堆栈溢出的常见原因是错误的递归调用。
那么为什么它要运行10000个元素，而获得100000元素的StackOverflowError呢？
快速排序
public static void quicksort(int[] data, int low, int high) {
if (low < high) {
int p = partition(data, low, high);
quicksort(data, low, p);
quicksort(data, p + 1, high);
}
}
publ
浏览 1提问于2017-12-13得票数 0
回答已采纳
1回答
这是一个算法问题。如果我错过了Python中任何有帮助的现有函数，请大喊一声。
给定一组s元素，我们可以在n中使用itertools.combinations()函数来查找所有唯一的k元素子集。让我们调用包含所有这些子集的集合S。注意，每个这样的子集都有k不同的元素。
问题是第二步。首先，考虑到这些k个不同的元素子集，我想组合(一些)这样的子集(一个组合仅仅是某个子集的超集)：
组合中任意两个子集之间的交集为空。
组合中所有子集之间的联合给出了原始集s。
第二，我想找到这样的作品：
不要共享任何子集
它们的联合给出了S，即所有k-element子集的集合。
作为
浏览 3提问于2014-09-18得票数 2
回答已采纳
1回答
我遇到了一个面试问题：
在礼堂里有一个活动，给定礼堂的容量是NxM。每一组人都订了票，所有的票都订完了，现在你必须给他们所有人分配座位号，这样才能使小组分裂的最小数量。
因此，基本上给出了一个2-D数组，我们有一些特定大小的组(不同的组可能具有不同的大小)，.Array需要用最小数量的组来完全填充。
我发现的一种暴力递归方法是:将第一组放在第一组，然后第二组，然后对这种排列进行on.Permute，以找到分裂最小的排列。
我发现的一个有效的解决方案是使用子集和问题。
我不能理解如何使用子集和问题来解决这个问题。请建议我如何处理这个问题。我不是在寻找代码，只是伪代码或算法就足够了。
浏览 0提问于2016-05-21得票数 1
2回答
我正试图为以下问题建立一个解决方案，我认为这与密码有关：
甲方有一套指标M，如一组人的身份证；乙方有更多人的信息，我们将这组人命名为N。让我们假设M是N的子集。乙方同意为业务目的提供甲方要求的人的信息。虽然甲方希望从乙方获得所有的M信息，但不希望在此过程中向乙方透露任何M的ID。
有人知道这是否可能吗？
谢谢。
浏览 0提问于2020-03-02得票数 1
1回答
我想在比O( N ^2)更快的时间内解决以下问题:给定一组形式的N个点(x_i、y_i、z_i)，用于I从1到N。返回一个长度N数组，其jth元素是x_k不超过x_j的整数数，y_k不超过y_j，z_k不超过z_j。
显然，可以简单地遍历集合中的所有点，然后对每个点检查它与集合中的每一个其他点。但我觉得一定有更快的办法。
浏览 3提问于2022-10-10得票数 0
10K工作，15K导致StackOverflowException，当Partition在QuickSort中时。
My MAIN:
internal class Program
{
static void Main(string[] args)
{
const int N = 15000;
const bool M_ORDERED = true;
Random random = new Random();
int[] list = (M_ORDERED)
浏览 5提问于2022-05-20得票数 1
1回答
生成x个整数分区
、、、、
我有一个递归算法，它生成一个作为参数的数字的所有组合。它还可以基于'k‘进行分区，这也可以作为参数给出。只要我们有较小的数字作为输入，它就能正常工作。但是随着‘n’的增加，计算结果需要更多的时间和空间。
是否可以给出“x”作为输入，以便算法只返回数字的x分区，而不是全部。下面是我正在寻找的例子：
投入：
n = 10,
k = 4, partition n into 'k'parts
x = 2, number of partitions required
m = 4, maximum number in the partition
产出：
4,2,2,2
浏览 4提问于2014-07-20得票数 1
3回答
用于计算从一组k项中选择n项的方式数的递归公式表示为C(n,k)，其表达式为：
1 if K = 0
C(n,k) = { 0 if n<k
c(n-1,k-1)+c(n-1,k) otherwise
我正在尝试编写一个递归函数C，它使用这个递归公式来计算C(n,k)。我写的代码应该可以根据我自己的情况工作，但它没有给我正确的答案。
这是我的代码：
def combinations(n,k):
# base case
if k ==0:
浏览 2提问于2013-05-30得票数 3
回答已采纳
我正在写一个快速排序程序，在100000的输入大小上运行。我试过在500的大小下运行它，它工作得很好，但是在输入百万的情况下，程序崩溃了，错误代码如下
"java.lang.StackOverflowError“
有人能帮我解决这个问题吗？我非常确定我不会陷入无限的递归。有一个基本情况，它应该导致递归方法返回。
public class count_comparisons {
public static int count_comp =0;
public static int partitioning(int[] A, int lo, int hi) {
浏览 0提问于2013-07-08得票数 4
1回答
我正在尝试编写一个python算法来执行以下操作。给定一组正整数S，求最小和，大于或等于k的子集。
例如:s= 50、103、85、21、30k= 140
子集=
初始集合中的数都是整数，k可以任意大。通常情况下，集合中将有大约100个数字。
当然，有一个通过所有可能子集的蛮力解，但它运行在O(2^n)中，这是不可能的。有人告诉我，这个问题是NP-完全的，但是应该有一种动态编程方法，允许它在伪多项式时间内运行，就像背包问题一样，但是到目前为止，尝试使用DP仍然会导致我找到O(2^n)的解。
有这样一种方法来解决这个问题吗？如果是这样的话，是怎么做的？我发现DP很难理解，所以我可能遗漏了一些东
浏览 0提问于2019-05-08得票数 1
回答已采纳
1回答
给出的位置数目为m，数字数为n，必须以至少一次出现每一位数字的方式填写这m个位置。
例如
如果m为4，n为3，则有4个位置和3个数字。现在，对于这个总数，可能的组合数是36。
让我们举一个简单的例子：
m=3和n=2(a，b假设)那么可能的组合是
aba aab abb bab bba baa
因此，只有6个组合是可能的。这有公式吗?因为我需要找到可能的组合数？
浏览 1提问于2014-09-15得票数 5
回答已采纳
# function counts number of ways you can
# partition n objects
# using parts up to m (assume m>=0)
n=int(input('enter n '))
m=int(input('enter m '))
def count(n, m):
if n==0:
return 1
elif m==0 or n<0:
return 0
else:
return count(n-m , m)+co
浏览 0提问于2021-05-21得票数 1
1回答
几天前，我学到了线性划分问题，这是我的代码，这段代码是正确的，我不理解它背后的公式，为什么是这样，如果你能解释为什么这个公式有效。
for(int i=1;i<=n;i++) {
rsq[i]=rsq[i-1]+arr[i];
}
int dp[n+1][k+1];
for(int i=0;i<=n;i++) {
for(int j=0;j<=k;j++) {
dp[i][j]=987654321;
}
}
dp[0][0]=0;
for(int i=1;i<=n;i++) {
dp[i][1]=rsq[i];
}
fo
浏览 0提问于2017-03-30得票数 1
2回答
累积异或小于k的子集数
、、、
给出一组N个数的集合，计数S的所有子集，其子集的元素的累积异或小于K。
我可以用蛮力方法来生成S和计数子集的所有子集，这些子集具有小于k的累积异或元素。我正在寻找优化解，而不生成S的所有子集，我可以找到所有这样的子集。
Example:
S = {1,2}
K = 4
U = {{},{1},{2},{1,2}}
Answer is 4 As
cumulative XOR values are 0 for {}, 1 for {1}, 2 for {2}, 3 for {1,2}.
浏览 0提问于2019-05-11得票数 0
1回答
假设我有一组大小为n的有限数值。
问题：是否有一个有效的算法来枚举该集合的k-组合，使组合i先于组合J当且仅当I中元素的和小于或等于J中元素的和？
显然，可以简单地列举这些组合并根据它们的总和对它们进行排序。但是，如果集合很大，则所有组合的野蛮枚举(更不用说排序)将是不可行的。如果我只对获得第一个m <<选择(n，k)组合(n，k)按和排列感兴趣，那么是否有可能在宇宙的热死之前获得它们？
浏览 1提问于2012-12-02得票数 2
回答已采纳
1回答
我有两个不相交集A和B，它们被合并成一个集，然后再进行分区。这类分区的数目是第n个。我希望筛选出分区为内射，即每个集合中的项没有与来自同一集中的项合并，然后计算出这是否显着地减少了此类分区的数量。
例如，如果
A={1,2}
B={3}
然后：C = {1,2,3}，C的分区为5：
{ {1}, {2}, {3} }
{ {1, 2}, {3} }
{ {1, 3}, {2} }
{ {1}, {2, 3} }
{ {1, 2, 3} }
然而，第二和第五分区有1和2合并，我想过滤掉，所以在这种情况下，我要寻找的数字是3，而不是5。谁知道如何计算这个受限的最近呢？
浏览 1提问于2014-09-01得票数 1
回答已采纳
我有一个数组，包含10,000至50,000种元素，代表处于困境的经济体中的风险价值。我有兴趣计算这个数组的x分位数，使用一个普通的加权.
立即进入我的问题-它是否有可能确定一个大的未排序数组的分位数，而不首先排序，然后简单的索引？或者是在实现功能的同时进行排序以确定某些分位数？在我的情况下，速度是最重要的，但是不依赖于第一次排序的较慢的方法对我来说也很有趣。
传统的方法非常简单，首先对数组进行排序，然后构建SetWeights()来进行简单的插值(Alpha是所需的分位数分数)。
protected sealed override void SetWeights()
{
doubl
浏览 2提问于2016-02-02得票数 1
2回答
上一次我发现了有趣的问题，我被困在上面了。
给定n个数a1，.，a按升序，数k (1 <= n，k <= 10^5)。
假设我们对给定序列的每一个可能子集进行了求和排序。
我们必须找出这类子集的和。
例如：
N= 4，k=8
A={ 2，7，8，15 }
1：{2 }，sum =2
2：{7 }，sum =7
3：{8 }，sum =8
4：{ 2，7 }，sum =9
5：{ 2，8 }，和= 10
6：{ 7，8 }，sum = 15
7：{ 15 }，sum = 15
8：{ 2，15 }，sum = 17
..。
K= 8，所以答案= 17 (子集{2,15})。
当然，我
浏览 5提问于2015-10-19得票数 13
回答已采纳
如何将n分区的rdd保存到k <= n位置？
例如，如果是n=10和k=2，我希望5个分区(与哪个分区无关)放入s3://bucket/key1，而将其他5个分区放入s3://bucket/key2。
我假设我需要实现自己的OutputFormat，有没有一种方法可以在没有自定义OutputFormat的情况下实现它，如果我无法避免，我应该从哪个OutputFormat扩展？
浏览 0提问于2016-03-14得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
