给定数组中的元素找到等于目标值的组合

Question

我一直在思考这个问题很长一段时间，但由于某种原因，它没有引起我的注意。如果给我一个数组 [1,2,3,4] 和一个目标值为 5。我想从数组中获取所有可能的组合，以便它们添加到目标值。

所以我能想到的一种方法是

1!=5
1+2!=5
1+3!=5
1+4=5
//now check with combos of 3 digits.
1+2+3 !=5
1+2+4 !=5
//now check with combos of 4...however at this point i realized i missed the combination 1+3+4 also.

我在网上看到了一些答案，但它们似乎没有意义，我对其他答案或代码并不真正感兴趣，我想学习如何以正确的方式思考，这样我就可以解决这些问题。我想知道是否有人可以指导我并帮助我解决这个问题，以及我应该如何思考解决这些问题。在这一点上，我并不真正担心效率，因为我什至无法制定一种方法，所以欢迎所有方法。此外，我更喜欢只使用数组和普通循环，而不是像哈希这样的任何其他数据结构，因为我还没有学过这些。

Answer 1

既然你说你想要“思维方式”，这是一种方式。

您从最简单的案例开始，做出各种假设

1) 假设所有数组元素都小于目标值。 -- 一个简单的验证将在实施完成时有所帮助。

高级步骤

你需要找到一种方法来获得数字的所有可能排列。

然后添加排列的每个元素并检查总和是否匹配'destination'（这是更简单的任务）

现在面临主要挑战：

如何获得所有可能的排列？

解决方法 假设我们有一个单元素数组： 解决方案很明显:)

接下来我们有一个包含两个元素的数组： 您确定数组的大小：2 您必须迭代此大小，因为您的组合将小于或等于此大小。 您的第一次迭代将具有值 1。即。您正在寻找尺寸一的组合 这很简单：你一个一个地遍历数组。

下一次迭代将寻找大小为 2 的组合。 由于迭代值 (2) 等于数组的大小 (2)，因此您知道只有一种可能的情况。

现在让我们处理一个大小为 3 的数组：

对于大小 1 的排列，您知道该怎么做。

对于大小 3 的排列，您知道组合是什么。

对于大小为 2 的排列，您需要再次迭代。 您遍历数组，保存数组的当前元素并置换大小为 2 的数组的其余部分。

接下来，您遍历第二个和第三个元素，并对大小为 (3-1 = 2) 的数组的其余部分进行置换

--------------------------------已更新---------- ---------------------------------------

接下来让我们尝试一个有 4 个元素的数组 让我们调用是 A(4)

对于大小 1 排列和大小 4 排列，这是显而易见的。

对于大小为 3 的排列，您将重复为获得大小为 3 的数组的大小为 2 的排列所做的过程。 你将持有一个元素，你将得到一个大小为 3 的数组。姑且称之为 A(3)

但请记住，您还需要大小为 2 的排列。您可以通过应用相同的可重用组件，从这个大小为 3 的数组本身确定大小为 2 的所有排列。这变成了一个递归调用。

所以本质上，你大部分时间都必须做一件事。

'如果你有一个大小为 n 的数组； A(n)，你需要遍历它，保持被迭代的元素，你将拥有一个大小为 n-1 的数组； A(n-1)'

然后再次进行递归调用。 并将粗线中的 n 替换为 n-1

所以基本上正如你所见，这变成了一个递归问题。

这是解决此问题的一种思路。我希望我清楚地解释了思考的过程。

------------------------------示例- ------------------------------------------

假设我们有一个数组 {1,2,3,4,5}

我们的函数看起来像

 function G (int[] array ) {
   Looping over array{ 
       remove array[index] from array
        you are left with restOfTheArray .// store it some where.
       then
          make a recursive call to G with restOfTheArray; 
     }
 }

循环试运行：

 Dry run 1:
  funtion G (Array (n ) ) {
    Looping over {1,2,3,4,5}{ 
        first value while looping is 1, remove it from the array;
        you have {2,3,4,5}.// store it some where.
       then
          make a recursive call to G with {2,3,4,5}
     }
 } 


  Dry run 2: 
funtion G (Array (n ) ) {
   Looping over {1,2,3,4,5}{ 
       second value while looping is 2, remove it from the array;
        you have {1,3,4,5}.// store it some where.
       then
          make a recursive call to G with {1,3,4,5}
     }
 }

等等……

现在让我们看看递归调用的试运行：

  Dry Run 1.1
 funtion G (Array (n ) ) {
   Looping over {1,2,3,4,5}{ 
       First value while looping is 1, remove it from the array;
        you have {2,3,4,5}.// store it some where.
       then
          make a recursive call to G with {2,3,4,5}
     }
 }

 Dry Run 1.2 

 funtion G (Array (n ) ) {
   Looping over {2,3,4,5}{ 
       First value while looping is 2, remove it from the array;
        you have {3,4,5}.// store it some where.
       then
          make a recursive call to G with {3,4,5}
     }
 }

等等……