相关疑难解决方法(0)

给定一组数字:{1,3,2,5,4,9},找到总和为特定值的子集数(例如,本例中为9).

这类似于子集求和问题,略有不同,不是检查集合是否有一个总和为9的子集,我们必须找到这样的子集的数量.我下面的子集和问题解决 在这里.但我想知道如何修改它以返回子集的数量.

我有一个随机正整数向量。我只想选择向量中那些总和恰好等于某个预定值的元素。

让我们举一个这样的例子。 x=1:5，我正在寻找总和等于 的元素14。解当然是向量c(2, 3, 4, 5)。

当然，可能有多种解决方案。示例 2. x=1:5，我正在寻找总和等于 的元素7。这里当然应该有以下三种解决方案：
1. c(2, 5)、
2. c(3, 4)、
3 c(1, 2, 4)..

也可能存在根本没有解决办法的情况。示例 3. x=c(1, 2, 7)，我正在寻找总和等于 的元素5。当然，这里没有正确的解决方案。

如果我们有多个元素的向量，一切看起来都非常简单。在这里，我什至想出了一些替代解决方案。然而，当向量的大小增加时，问题就出现了。

我的向量看起来像这样：

x= c(236L, 407L, 51L, 308L, 72L, 9787L, 458L, 5486L, 42L, 4290L,
  31L, 3533L, 1102L, 24L, 100L, 669L, 9352L, 4091L, 2751L, 3324L,
  3193L, 245L, 86L, 98932L, 77L, 13L, 9789L, 91L, 999L, 25L, 25379L,
  9626L, 9092L, 622L, 97L, 57L, …

我有一个数字列表,例如

numbers = [1, 2, 3, 7, 7, 9, 10]

如您所见,数字可能会在此列表中出现多次.

我需要获得具有给定总和的这些数字的所有组合,例如10.

组合中的项目可以不重复,但是每个项目numbers必须被唯一地处理,这意味着例如7列表中的两个项目表示具有相同值的不同项目.

顺序是不重要的,所以[1, 9]和[9, 1]是相同的组合.

组合没有长度限制,[10]有效[1, 2, 7].

如何创建符合上述条件的所有组合的列表？

在这个例子中,它将是 [[1,2,7], [1,2,7], [1,9], [3,7], [3,7], [10]]

这是一个采访问题:

给定金额,比如167.37美元,找到使用货币中可用面额产生此金额变化的所有可能方法？

任何想到空间和时间效率算法和支持代码的人,请分享.

这是我写的(工作)代码.我试图找到这个的运行时间,任何帮助表示赞赏

    import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;


public class change_generation {

    /**
     * @param args
     */

    public static void generatechange(float amount,LinkedList<Float> denominations,HashMap<Float,Integer> useddenominations)
    {
        if(amount<0)
            return;
        if(amount==0)
        {
            Iterator<Float> it = useddenominations.keySet().iterator();
            while(it.hasNext())
            {
                Float val = it.next();
                System.out.println(val +" :: "+useddenominations.get(val));
            }

            System.out.println("**************************************");
            return;
        }

        for(Float denom : denominations)
        {

            if(amount-denom < 0)
                continue;

            if(useddenominations.get(denom)== null)
                useddenominations.put(denom, 0);

            useddenominations.put(denom, useddenominations.get(denom)+1);
            generatechange(amount-denom, denominations, useddenominations);
            useddenominations.put(denom, useddenominations.get(denom)-1);
        }

    }

    public static void main(String[] args) {
        // …

我已经看到了类似问题的一些解决方案,但它们都需要迭代一起添加的项目数.

这是我的目标:从数字列表中,找到所有组合(无需替换),总计达到一定数量.举例来说,如果我有一个数字1,1,2,3,5和总5,它应该返回5,2,3和1,1,3.

我试图使用,combn但它要求您指定每个组合中的项目数.有没有办法可以实现任何规模的解决方案集？

我喜欢用Python处理列表的方式.它做任何递归解决方案看起来容易和干净.例如,在Python中获取元素的所有排列的典型问题如下所示:

def permutation_recursion(numbers,sol):
    if not numbers:
        print "this is a permutation", sol
    for i in range(len(numbers)):
        permutation_recursion(numbers[:i] + numbers[i+1:], sol + [numbers[i]])

def get_permutations(numbers):
    permutation_recursion(numbers,list())

if __name__ == "__main__":
    get_permutations([1,2,3])

我喜欢通过像numbers[:i] + numbers[i+1:]或者 那样简单地获取修改列表的新实例的方式 sol + [numbers[i]]

如果我尝试在Java中编写完全相同的代码,它看起来像:

import java.util.ArrayList;
import java.util.Arrays;

class rec {
    static void permutation_recursion(ArrayList<Integer> numbers, ArrayList<Integer> sol) {
       if (numbers.size() == 0)
            System.out.println("permutation="+Arrays.toString(sol.toArray()));
       for(int i=0;i<numbers.size();i++) {
             int n = numbers.get(i);

             ArrayList<Integer> remaining = new ArrayList<Integer>(numbers);
             remaining.remove(i);

             ArrayList<Integer> sol_rec = new ArrayList<Integer>(sol);
             sol_rec.add(n);

             permutation_recursion(remaining,sol_rec);
       } …

我需要一些帮助在Prolog中编写一个谓词,给定一个数字作为输入,返回一个包含数字的列表列表.

让我们调用谓词addUpList/2,它应该像这样工作:

?- addUpList(3,P).
P = [[1,2], [2,1], [1,1,1]].       % expected result

我很难解决这个问题,我开始认为这是不可能的.有任何想法吗？提前致谢.

我需要得到与目标相等的数组项的总和.如果数组项的总和不等于目标,我希望获得小于目标的最高总和.

这是一个例子:

输入: [4,6,8,12,4,6,6,12,4,4,4]

结果: [ 12 ] [ 12 ] [ 8,4 ] [ 6,6 ] [ 4,4,4 ] [ 6,4 ]

注意:数组项只能使用一次.

目前这就是我现在所拥有的:

    var subset_sum = function (items, target) {
    var results = [];

    items.sort(function (a, b) { return b - a });

    ss = function (items) {
        var item = items.shift();
        if (item < target) {
            var perms = [];
            perms.push(item);
            var isItemPush = false;

            var counter = 0
            var innerSubset = function () {
                if …

问题- 您必须找到从初始位置(1,1)到最终位置(N,M) [其中N是行数，M是列数]可以达到的方法数，假设：

1. 您可以向下移动任意数量的步骤。
2. 您可以向右移动任意数量的步骤。

注意：这里的数组索引是 1-indexed

一些条件：

• 你永远不能离开网格。
• 您不能忽略这些条件。
• 第一个单元格 (1,1) 和最后一个单元格 (N,M) 不包含障碍物。
• 一个空闲单元用 表示。障碍物用*表示。

示例测试用例：

>>> 3 3
    . . .
    . * .
    . . .

>>> 8

会有8种方式：

• (1,1),(1,2),(1,3),(2,3),(3,3)
• (1,1),(1,2),(1,3),(3,3)
• (1,1),(1,3),(2,3),(3,3)
• (1,1),(1,3),(3,3)
• (1,1),(2,1),(3,1),(3,2),(3,3)
• (1,1),(3,1),(3,2),(3,3)
• (1,1),(2,1),(3,1),(3,3)
• (1,1),(3,1),(3,3)

我的代码：

def ways(l):
    
   # Don't know how to proceed



Testcases=int(input())
lst=[]
for i in range(Testcases):
    N,M=input().split()
    N,M=int(N),int(M)
    for j in range(N):
        s=input().split(" ",M)
        lst.append(s)
    
    ways(lst)

我不知道如何继续。

我有 5 个数字1、2、3、4和5，我想得到这些数字的所有可能组合，以达到给定的总数10。

例子：

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + = 10
1 + 2 + 2 + 3 + 2 = 10
7 + 3 = 10
4 + 5 + 1 = 10
2 + 2 + 2 + 1 + 3 = 10
and so on...

如果这里有人可以就如何解决这个问题给出一个很好的解决方案，我将不胜感激？