给定一个大小为 N 的数组 A，找到数组中所有四个元素的组合，其和等于给定值 K

Question

给定一个大小为 N 的数组 A，找出数组中四个元素的所有组合，其和等于给定值 K。例如，如果给定数组是 {10,2,3,4,5,9 , 7, 8} 和 K = 23，其中一个是“3 5 7 8”（3 + 5 + 7 + 8 = 23）。

输出应该只包含唯一的四元组 例如，如果输入数组是 {1, 1, 1, 1, 1, 1} 并且 K = 4，那么输出应该只有一个四元组 {1, 1, 1 , 1}

我的方法：我试图通过将给定数组形成的所有不同对存储到哈希表 (std::unordered_multimap) 中来解决这个问题，并将它们的总和作为键。然后对于每一对总和，我在哈希表中查找 (K - sum) 键。这种方法的问题是我得到了太多重复，比如 (i, j, l, m) 和 (i, l, j, m) 是相同的，而且由于数组中的相同项目而存在重复。我不确定解决这个问题的最佳方法是什么。

上述方法的代码为：

#include <iostream>
#include <unordered_map>
#include <tuple>
#include <vector>


int main() {
    size_t tc = 0;
    std::cin >> tc; //number of test cases
    while(tc--) {
        size_t n = 0, k = 0;
        std::cin >> n >> k;
        std::vector<size_t> vec(n);
        for (size_t i = 0; i < n; ++i)
            std::cin >> vec[i];

        std::unordered_multimap<size_t, std::tuple<size_t, size_t>> m;
        for (size_t i = 0; i < n - 1; ++i)
        for (size_t j = i + 1; j < n; ++j) {
            const auto sum = vec[i] + vec[j];
            m.emplace(sum, std::make_tuple(i, j));
        }

        for (size_t i = 0; i < n - 1; ++i)
        for (size_t j = i + 1; j < n; ++j) {
            const auto sum = vec[i] + vec[j];
            auto r = m.equal_range(k - sum);
            for (auto it = r.first; it != r.second; ++it) {
                if ((i == std::get<0>(it->second))
                ||(i == std::get<1>(it->second))
                ||(j == std::get<0>(it->second))
                || (j == std::get<1>(it->second)))
                continue;
                std::cout << vec[i] << ' ' << vec[j] << ' ' 
                << vec[std::get<0>(it->second)] << ' '
                << vec[std::get<1>(it->second)] << '$';
            }

            r = m.equal_range(sum);
            for (auto it = r.first; it != r.second; ++it) {
                if ((i == std::get<0>(it->second))
                && (j == std::get<1>(it->second))) {
                    m.erase(it);
                    break;
                }
            }
        }

        std::cout << '\n';
    }
    return 0;
}

上面的代码将在注释中下面提到的链接中按原样运行。

注意：本题取自https://practice.geeksforgeeks.org/problems/find-all-four-sum-numbers/0

Answer 1

处理数组中的重复值

考虑[2, 2, 2, 3, 3] 与目标10。

唯一的解决方案是4-tuple<2,2,3,3>。重点是避免在三个2中选择两个2。

让我们考虑k-class，其中每个元组仅包含k 的元组集合。

例如：在我们的数组中，我们有 2-class 和 3-class。 2-class 包含：

<2>
<2,2>
<2,2,2>

而3-class 包含：

<3>
<3,3>

一个想法是将elem 数组（elem 是一个整数值）减少为k-class 数组。 同理

[[<2>, <2,2>, <2,2,2>], [<3>, <3,3>]]

我们可以考虑在2-class 集合和3-class 集合之间取笛卡尔积，并检查哪个结果导致解。

更具体地说，让我们取一些元组T，其最后一个（==最右边的）值为k。 （在<2,3,4> 中，最右边的值为4）。

我们可以从我们的数组 (* l > k) 中选择任何 l-class 并将元组从该 l-class 连接到 T。

例如

• 考虑数组[2, 9, 9, 3, 3, 4, 6] 和元组<2, 3, 3>
• 最右边的值为3。
• 候选人k-class是4-class、6-class、9-class

我们可以加入：

<4>
<6>
<9>
<9,9>

所以下一个候选人将是：

<2, 3, 3, 4>
<2, 3, 3, 6>
<2, 3, 3, 9>
<2, 3, 3, 9, 9> //that one has too many elem, left for illustration

(* l > k 的目的是防止排列。（如果 <1,2> 是您不想要的解决方案 <2,1> 因为加法是可交换的））

算法

Foreach tuple, try to create new ones by rightjoining tuples from a "greater" k-class.
discard the resulting ones which have too many elements or whose sum is already too big...
At some point we won't have new candidates, so algorithm will stop

剪切示例：

1. 给定数组[2,3,7,8,10,11]，元组<2,3>和S == 13

   • <2,3,7> 是候选者 (2+3+7 = 12
   • <2,3,10> 是不是候选者（2+3+10 = 15 > 13）
   • <2,3,11> 更是如此。 不是
   • <2,3,8> 也不是候选者，因为下一个右连接（到达4-tuple）将溢出S

2. 给定数组[2,3,4,4,4]给定元组<2,3>和候选<4,4,4>

结果元组将是<2,3,4,4,4>，它有太多元素，丢弃它！

显然初始化是

• 一些空元组
• 总和为0
• 并且其最右边的元素小于数组中的任何k（您可以将其右加入任何人）

我相信翻译成C++应该不会太难

class TupleClass {
  sum = 0
  rightIdx = -1
  values = [] // an array of integers (hopefully summing to solution)

  //idx is the position of the k-class found in array
  add (val, idx) {
    const t = new TupleClass()
    t.values = this.values.concat(val)
    t.sum = this.sum + val
    t.rightIdx = idx

    return t;
  }

  toString () {
    return `<${this.values.join(',')}>`
  }

  addTuple (tuple, idx) {
    const t = new TupleClass
    t.values = this.values.concat(tuple.values)
    t.sum = this.sum + tuple.sum
    t.rightIdx = idx

    return t;
  }
  get size () {
    return this.values.length
  }
}

function nodupes (v, S) {

  v = v.reduce((acc, klass) => {
    acc[klass] = (acc[klass] || {duplicity: 0, klass})
    acc[klass].duplicity++
    return acc
  }, {})
  v = Object.values(v).sort((a,b) => a.klass - b.klass).map(({ klass, duplicity }, i) => {
    return Array(duplicity).fill(0).reduce((acc, _) => {
      const t = acc[acc.length-1].add(klass, i)
      acc.push(t)
      return acc
    }, [new TupleClass()]).slice(1)
  })
  //v is sorted by k-class asc
  //each k-class is an array of tuples with increasing length
  //[[<2>, <2,2>, <2,2,2>], [<3>,<3,3>]]
  let tuples = [new TupleClass()]
  const N = v.length

  let nextTuples = []

  const solutions = []
  while (tuples.length) {
    tuples.forEach(tuple => {
      //foreach kclass after our rightmost value
      for (let j = tuple.rightIdx + 1; j <= N - 1; ++j) {

        //foreach tuple of that kclass
        for (let tclass of v[j]) {
          const nextTuple = tuple.addTuple(tclass, j)

          if (nextTuple.sum > S || nextTuple.size > 4) {
            break
          }

          //candidate to solution
          if (nextTuple.size == 4) {
            if (nextTuple.sum === S) {
              solutions.push(nextTuple)
            }
            //invalid sum so adding more elem won't help, do not push
          } else {
            nextTuples.push(nextTuple)
          }
          
        }
      }
    })
    tuples = nextTuples
    nextTuples = []
  }
  return solutions;
}
const v = [1,1,1,1,1,2,2,2,3,3,3,4,0,0]
const S = 7
console.log('v:', v.join(','), 'and S:',S)
console.log(nodupes(v, 7).map(t=>t.toString()).join('\n'))