jjzjj

c++ - 查找数组总数

coder 2024-02-19 原文

我有一个由 N 个整数组成的数组 A。我还有一个整数 K。 我想通过恰好应用以下操作 K 次，找出我可以从数组 A 中获得的不同数组的数量。

  • 选取数组中的某个元素并将其乘以-1

数组 A=[2,3,2] 且 k=2 我有四种可能的数组

1.[2,3,2] 2.[-2,-3,2] 3.[-2,3,-2] 4.[2,-3,-2]
这可以计算为 ∑nCr 的总和，其中 r 是 {k,k-2,k-4....}。

编辑

但是对于正数和负数的组合，假设我们的数组是 A=[-1,2,3] 和 k=3，所有可能的组合都是

1.[1,2,3] 2.[-1,-2,3] 3.[-1,2,-3 ] 4.[1,-2,-3]
总共4个数组，也总共4个数组。 我刚刚提交了我认为应该正确的代码是

int main()
{
   int n,k;
   int arr[11];
   arr[0]=1;
   for (int i=1;i<=10;i++)
   {
        arr[i]=arr[i-1]*i;
        //cout<<arr[i]<<" ";
   }

    long int ans=0;
    cin>>n>>k;   / n for number of elements and k for operations
    for (int i=0;i<n;i++)
    {
        int num;   array element
        cin>>num;
    }
    int i=(k%2==0?2:1);
    for(;i<=k;i+=2)
    {
        ans=ans+arr[n]/(arr[k]*arr[n-k]);
    }
    if(k%2==0)
        ans=arr[n]/(arr[k]*arr[n-k])+1; 
    if(n==1 && k%2==1)
        ans=1;
    cout<<ans;
}

但它给出了错误的答案。请帮我解决这个问题。

最佳答案

这迎合了巨大的多维设置。一些暴力编码，使用并行数组处理语言 Dyalog APL对于 K = 1...10 和 N = 1...14，显示以下数量的唯一结果:

┌────┬───┬───┬───┬───┬───┬───┬───┬───┬───┬────┬────┬────┬────┬────┐
│    │N=1│N=2│N=3│N=4│N=5│N=6│N=7│N=8│N=9│N=10│N=11│N=12│N=13│N=14│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=1 │1  │2  │3  │4  │5  │6  │7  │8  │9  │10  │11  │12  │13  │14  │
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=2 │1  │2  │4  │7  │11 │16 │22 │29 │37 │46  │56  │67  │79  │92  │
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=3 │1  │2  │4  │8  │15 │26 │42 │64 │93 │130 │176 │232 │299 │378 │
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=4 │1  │2  │4  │8  │16 │31 │57 │99 │163│256 │386 │562 │794 │1093│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=5 │1  │2  │4  │8  │16 │32 │63 │120│219│382 │638 │1024│1586│2380│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=6 │1  │2  │4  │8  │16 │32 │64 │127│247│466 │848 │1486│2510│4096│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=7 │1  │2  │4  │8  │16 │32 │64 │128│255│502 │968 │1816│3302│5812│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=8 │1  │2  │4  │8  │16 │32 │64 │128│256│511 │1013│1981│3797│7099│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=9 │1  │2  │4  │8  │16 │32 │64 │128│256│512 │1023│2036│4017│7814│
├────┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┼────┼────┤
│K=10│1  │2  │4  │8  │16 │32 │64 │128│256│512 │1024│2047│4083│8100│
└────┴───┴───┴───┴───┴───┴───┴───┴───┴───┴────┴────┴────┴────┴────┘

虽然它确实存在，但您看不到其中有任何明显的模式。我们可以看到的一件事是，当执行足够多的否定次数时(即 K 是“耗尽”数组)，我们似乎达到 2^(N-1) 个独特的结果(即 1、2、4、8、16等)。

假设我们是暴力破解的。如果我们有一个长度为 4 的数组(即 N=4)且 K=1，则数组的元素 1、2、3 或 4 可以取反:

┌─┬─┬─┬─┐
│1│2│3│4│
└─┴─┴─┴─┘

如果 K=2，我们得到一个新的 a 维度(现在是一个二维问题)并且现在有 16 个可能的索引对用于求反:

┌───┬───┬───┬───┐
│1 1│1 2│1 3│1 4│
├───┼───┼───┼───┤
│2 1│2 2│2 3│2 4│
├───┼───┼───┼───┤
│3 1│3 2│3 3│3 4│
├───┼───┼───┼───┤
│4 1│4 2│4 3│4 4│
└───┴───┴───┴───┘

例如 [4 2] 表示 array[4] 和 array[2] 都将乘以 -1。

设置 K=3 使其成为 3 维:

┌─────┬─────┬─────┬─────┐┌─────┬─────┬─────┬─────┐┌─────┬─────┬─────┬─────┐┌─────┬─────┬─────┬─────┐
│1 1 1│1 1 2│1 1 3│1 1 4││2 1 1│2 1 2│2 1 3│2 1 4││3 1 1│3 1 2│3 1 3│3 1 4││4 1 1│4 1 2│4 1 3│4 1 4│
├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤
│1 2 1│1 2 2│1 2 3│1 2 4││2 2 1│2 2 2│2 2 3│2 2 4││3 2 1│3 2 2│3 2 3│3 2 4││4 2 1│4 2 2│4 2 3│4 2 4│
├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤
│1 3 1│1 3 2│1 3 3│1 3 4││2 3 1│2 3 2│2 3 3│2 3 4││3 3 1│3 3 2│3 3 3│3 3 4││4 3 1│4 3 2│4 3 3│4 3 4│
├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤├─────┼─────┼─────┼─────┤
│1 4 1│1 4 2│1 4 3│1 4 4││2 4 1│2 4 2│2 4 3│2 4 4││3 4 1│3 4 2│3 4 3│3 4 4││4 4 1│4 4 2│4 4 3│4 4 4│
└─────┴─────┴─────┴─────┘└─────┴─────┴─────┴─────┘└─────┴─────┴─────┴─────┘└─────┴─────┴─────┴─────┘

...例如 [1 1 1] 表示数组 [1] 将连续三次乘以 -1。现在我们还可以看到 64 种可能性中有一些是重复的。

在做暴力计算的时候，其实涉及到10维的数据。随着数据变得越来越庞大，系统最终会耗尽内存。

数组包含什么数值并不重要。相反，我们当然只需要弄清楚符号的变化，即。与 -1 的乘法。以下是 K = 1...5 和 N = 1...5 的唯一组合的可能数量:

┌───┬────┬───────────┬───────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│   │N=1 │N=2        │N=3                            │N=4                                                                              │N=5                                                                                                                                                                                                      │
├───┼────┼───────────┼───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│K=1│┌──┐│┌────┬────┐│┌──────┬──────┬──────┐         │┌────────┬────────┬────────┬────────┐                                            │┌──────────┬──────────┬──────────┬──────────┬──────────┐                                                                                                                                                 │
│   ││-1│││-1 1│1 -1│││-1 1 1│1 -1 1│1 1 -1│         ││-1 1 1 1│1 -1 1 1│1 1 -1 1│1 1 1 -1│                                            ││-1 1 1 1 1│1 -1 1 1 1│1 1 -1 1 1│1 1 1 -1 1│1 1 1 1 -1│                                                                                                                                                 │
│   │└──┘│└────┴────┘│└──────┴──────┴──────┘         │└────────┴────────┴────────┴────────┘                                            │└──────────┴──────────┴──────────┴──────────┴──────────┘                                                                                                                                                 │
├───┼────┼───────────┼───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│K=2│┌─┐ │┌───┬─────┐│┌─────┬───────┬───────┬───────┐│┌───────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐            │┌─────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐                                                                      │
│   ││1│ ││1 1│-1 -1│││1 1 1│-1 -1 1│-1 1 -1│1 -1 -1│││1 1 1 1│-1 -1 1 1│-1 1 -1 1│-1 1 1 -1│1 -1 -1 1│1 -1 1 -1│1 1 -1 -1│            ││1 1 1 1 1│-1 -1 1 1 1│-1 1 -1 1 1│-1 1 1 -1 1│-1 1 1 1 -1│1 -1 -1 1 1│1 -1 1 -1 1│1 -1 1 1 -1│1 1 -1 -1 1│1 1 -1 1 -1│1 1 1 -1 -1│                                                                      │
│   │└─┘ │└───┴─────┘│└─────┴───────┴───────┴───────┘│└───────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘            │└─────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘                                                                      │
├───┼────┼───────────┼───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│K=3│┌──┐│┌────┬────┐│┌──────┬──────┬──────┬────────┐│┌────────┬────────┬────────┬────────┬──────────┬──────────┬──────────┬──────────┐│┌──────────┬──────────┬──────────┬──────────┬──────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┐               │
│   ││-1│││-1 1│1 -1│││-1 1 1│1 -1 1│1 1 -1│-1 -1 -1│││-1 1 1 1│1 -1 1 1│1 1 -1 1│1 1 1 -1│-1 -1 -1 1│-1 -1 1 -1│-1 1 -1 -1│1 -1 -1 -1│││-1 1 1 1 1│1 -1 1 1 1│1 1 -1 1 1│1 1 1 -1 1│1 1 1 1 -1│-1 -1 -1 1 1│-1 -1 1 -1 1│-1 -1 1 1 -1│-1 1 -1 -1 1│-1 1 -1 1 -1│-1 1 1 -1 -1│1 -1 -1 -1 1│1 -1 -1 1 -1│1 -1 1 -1 -1│1 1 -1 -1 -1│               │
│   │└──┘│└────┴────┘│└──────┴──────┴──────┴────────┘│└────────┴────────┴────────┴────────┴──────────┴──────────┴──────────┴──────────┘│└──────────┴──────────┴──────────┴──────────┴──────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘               │
├───┼────┼───────────┼───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│K=4│┌─┐ │┌───┬─────┐│┌─────┬───────┬───────┬───────┐│┌───────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬───────────┐│┌─────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┐│
│   ││1│ ││1 1│-1 -1│││1 1 1│-1 -1 1│-1 1 -1│1 -1 -1│││1 1 1 1│-1 -1 1 1│-1 1 -1 1│-1 1 1 -1│1 -1 -1 1│1 -1 1 -1│1 1 -1 -1│-1 -1 -1 -1│││1 1 1 1 1│-1 -1 1 1 1│-1 1 -1 1 1│-1 1 1 -1 1│-1 1 1 1 -1│1 -1 -1 1 1│1 -1 1 -1 1│1 -1 1 1 -1│1 1 -1 -1 1│1 1 -1 1 -1│1 1 1 -1 -1│-1 -1 -1 -1 1│-1 -1 -1 1 -1│-1 -1 1 -1 -1│-1 1 -1 -1 -1│1 -1 -1 -1 -1││
│   │└─┘ │└───┴─────┘│└─────┴───────┴───────┴───────┘│└───────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴───────────┘│└─────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴─────────────┴─────────────┴─────────────┴─────────────┴─────────────┘│
├───┼────┼───────────┼───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│K=5│┌──┐│┌────┬────┐│┌──────┬──────┬──────┬────────┐│┌────────┬────────┬────────┬────────┬──────────┬──────────┬──────────┬──────────┐│┌──────────┬──────────┬──────────┬──────────┬──────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬──────────────┐│
│   ││-1│││-1 1│1 -1│││-1 1 1│1 -1 1│1 1 -1│-1 -1 -1│││-1 1 1 1│1 -1 1 1│1 1 -1 1│1 1 1 -1│-1 -1 -1 1│-1 -1 1 -1│-1 1 -1 -1│1 -1 -1 -1│││-1 1 1 1 1│1 -1 1 1 1│1 1 -1 1 1│1 1 1 -1 1│1 1 1 1 -1│-1 -1 -1 1 1│-1 -1 1 -1 1│-1 -1 1 1 -1│-1 1 -1 -1 1│-1 1 -1 1 -1│-1 1 1 -1 -1│1 -1 -1 -1 1│1 -1 -1 1 -1│1 -1 1 -1 -1│1 1 -1 -1 -1│-1 -1 -1 -1 -1││
│   │└──┘│└────┴────┘│└──────┴──────┴──────┴────────┘│└────────┴────────┴────────┴────────┴──────────┴──────────┴──────────┴──────────┘│└──────────┴──────────┴──────────┴──────────┴──────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴──────────────┘│
└───┴────┴───────────┴───────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

这无疑向我们展示了模式。如果 K 是奇数，我们得到奇数个否定，如果 K 是偶数，我们得到偶数个否定。两者都可能发生在数组大小 N 所允许的数量内。即。如果 K=5，我们可以得到 1 或 3 或 5 个否定或适合数组的内容； IE。如果 N=4，我们不可能有 5 个否定，而只有 1 个或 3 个。

因此，我们可以使用阶乘/二项式 (m!n) 来解决这个问题，它告诉我们 n 个数字空间中 m 个元素的唯一组合的可能数量。 IE。 3!5 将返回 10，因为有 10 种方法可以组合 1,2,3,4,5 的 3 个元素:

1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5

4!5 会返回 5:

1 2 3 4
1 2 3 5
1 2 4 5
1 3 4 5
2 3 4 5

3!3 将返回 1:

1 2 3

这个问题的公式是(2个例子):

combinations = (1!6) + (3!6) + (5!6) + (7!6) // K=7, N=6 - note that K is odd
combinations = (0!6) + (2!6) + (4!6) + (6!6) // K=6, N=6 - note that K is even

注意:
0!n 始终为 1
n!n 始终为 1
(>n)!n 始终为 0(例如 12!7 将返回 0)

要解决这个任务，请执行(同样，对于一个大集合，其中 K = 1...10 和 N = 1...14):

┌────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬────────────────────────────────────┬──────────────────────────────────────────┬──────────────────────────────────────────┬──────────────────────────────────────────┬──────────────────────────────────────────┬──────────────────────────────────────────┐
│    │N=1                                 │N=2                                 │N=3                                 │N=4                                 │N=5                                 │N=6                                 │N=7                                 │N=8                                 │N=9                                 │N=10                                      │N=11                                      │N=12                                      │N=13                                      │N=14                                      │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=1 │(1!1)                               │(1!2)                               │(1!3)                               │(1!4)                               │(1!5)                               │(1!6)                               │(1!7)                               │(1!8)                               │(1!9)                               │(1!10)                                    │(1!11)                                    │(1!12)                                    │(1!13)                                    │(1!14)                                    │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=2 │(0!1)+(2!1)                         │(0!2)+(2!2)                         │(0!3)+(2!3)                         │(0!4)+(2!4)                         │(0!5)+(2!5)                         │(0!6)+(2!6)                         │(0!7)+(2!7)                         │(0!8)+(2!8)                         │(0!9)+(2!9)                         │(0!10)+(2!10)                             │(0!11)+(2!11)                             │(0!12)+(2!12)                             │(0!13)+(2!13)                             │(0!14)+(2!14)                             │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=3 │(1!1)+(3!1)                         │(1!2)+(3!2)                         │(1!3)+(3!3)                         │(1!4)+(3!4)                         │(1!5)+(3!5)                         │(1!6)+(3!6)                         │(1!7)+(3!7)                         │(1!8)+(3!8)                         │(1!9)+(3!9)                         │(1!10)+(3!10)                             │(1!11)+(3!11)                             │(1!12)+(3!12)                             │(1!13)+(3!13)                             │(1!14)+(3!14)                             │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=4 │(0!1)+(2!1)+(4!1)                   │(0!2)+(2!2)+(4!2)                   │(0!3)+(2!3)+(4!3)                   │(0!4)+(2!4)+(4!4)                   │(0!5)+(2!5)+(4!5)                   │(0!6)+(2!6)+(4!6)                   │(0!7)+(2!7)+(4!7)                   │(0!8)+(2!8)+(4!8)                   │(0!9)+(2!9)+(4!9)                   │(0!10)+(2!10)+(4!10)                      │(0!11)+(2!11)+(4!11)                      │(0!12)+(2!12)+(4!12)                      │(0!13)+(2!13)+(4!13)                      │(0!14)+(2!14)+(4!14)                      │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=5 │(1!1)+(3!1)+(5!1)                   │(1!2)+(3!2)+(5!2)                   │(1!3)+(3!3)+(5!3)                   │(1!4)+(3!4)+(5!4)                   │(1!5)+(3!5)+(5!5)                   │(1!6)+(3!6)+(5!6)                   │(1!7)+(3!7)+(5!7)                   │(1!8)+(3!8)+(5!8)                   │(1!9)+(3!9)+(5!9)                   │(1!10)+(3!10)+(5!10)                      │(1!11)+(3!11)+(5!11)                      │(1!12)+(3!12)+(5!12)                      │(1!13)+(3!13)+(5!13)                      │(1!14)+(3!14)+(5!14)                      │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=6 │(0!1)+(2!1)+(4!1)+(6!1)             │(0!2)+(2!2)+(4!2)+(6!2)             │(0!3)+(2!3)+(4!3)+(6!3)             │(0!4)+(2!4)+(4!4)+(6!4)             │(0!5)+(2!5)+(4!5)+(6!5)             │(0!6)+(2!6)+(4!6)+(6!6)             │(0!7)+(2!7)+(4!7)+(6!7)             │(0!8)+(2!8)+(4!8)+(6!8)             │(0!9)+(2!9)+(4!9)+(6!9)             │(0!10)+(2!10)+(4!10)+(6!10)               │(0!11)+(2!11)+(4!11)+(6!11)               │(0!12)+(2!12)+(4!12)+(6!12)               │(0!13)+(2!13)+(4!13)+(6!13)               │(0!14)+(2!14)+(4!14)+(6!14)               │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=7 │(1!1)+(3!1)+(5!1)+(7!1)             │(1!2)+(3!2)+(5!2)+(7!2)             │(1!3)+(3!3)+(5!3)+(7!3)             │(1!4)+(3!4)+(5!4)+(7!4)             │(1!5)+(3!5)+(5!5)+(7!5)             │(1!6)+(3!6)+(5!6)+(7!6)             │(1!7)+(3!7)+(5!7)+(7!7)             │(1!8)+(3!8)+(5!8)+(7!8)             │(1!9)+(3!9)+(5!9)+(7!9)             │(1!10)+(3!10)+(5!10)+(7!10)               │(1!11)+(3!11)+(5!11)+(7!11)               │(1!12)+(3!12)+(5!12)+(7!12)               │(1!13)+(3!13)+(5!13)+(7!13)               │(1!14)+(3!14)+(5!14)+(7!14)               │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=8 │(0!1)+(2!1)+(4!1)+(6!1)+(8!1)       │(0!2)+(2!2)+(4!2)+(6!2)+(8!2)       │(0!3)+(2!3)+(4!3)+(6!3)+(8!3)       │(0!4)+(2!4)+(4!4)+(6!4)+(8!4)       │(0!5)+(2!5)+(4!5)+(6!5)+(8!5)       │(0!6)+(2!6)+(4!6)+(6!6)+(8!6)       │(0!7)+(2!7)+(4!7)+(6!7)+(8!7)       │(0!8)+(2!8)+(4!8)+(6!8)+(8!8)       │(0!9)+(2!9)+(4!9)+(6!9)+(8!9)       │(0!10)+(2!10)+(4!10)+(6!10)+(8!10)        │(0!11)+(2!11)+(4!11)+(6!11)+(8!11)        │(0!12)+(2!12)+(4!12)+(6!12)+(8!12)        │(0!13)+(2!13)+(4!13)+(6!13)+(8!13)        │(0!14)+(2!14)+(4!14)+(6!14)+(8!14)        │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=9 │(1!1)+(3!1)+(5!1)+(7!1)+(9!1)       │(1!2)+(3!2)+(5!2)+(7!2)+(9!2)       │(1!3)+(3!3)+(5!3)+(7!3)+(9!3)       │(1!4)+(3!4)+(5!4)+(7!4)+(9!4)       │(1!5)+(3!5)+(5!5)+(7!5)+(9!5)       │(1!6)+(3!6)+(5!6)+(7!6)+(9!6)       │(1!7)+(3!7)+(5!7)+(7!7)+(9!7)       │(1!8)+(3!8)+(5!8)+(7!8)+(9!8)       │(1!9)+(3!9)+(5!9)+(7!9)+(9!9)       │(1!10)+(3!10)+(5!10)+(7!10)+(9!10)        │(1!11)+(3!11)+(5!11)+(7!11)+(9!11)        │(1!12)+(3!12)+(5!12)+(7!12)+(9!12)        │(1!13)+(3!13)+(5!13)+(7!13)+(9!13)        │(1!14)+(3!14)+(5!14)+(7!14)+(9!14)        │
├────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┼──────────────────────────────────────────┤
│K=10│(0!1)+(2!1)+(4!1)+(6!1)+(8!1)+(10!1)│(0!2)+(2!2)+(4!2)+(6!2)+(8!2)+(10!2)│(0!3)+(2!3)+(4!3)+(6!3)+(8!3)+(10!3)│(0!4)+(2!4)+(4!4)+(6!4)+(8!4)+(10!4)│(0!5)+(2!5)+(4!5)+(6!5)+(8!5)+(10!5)│(0!6)+(2!6)+(4!6)+(6!6)+(8!6)+(10!6)│(0!7)+(2!7)+(4!7)+(6!7)+(8!7)+(10!7)│(0!8)+(2!8)+(4!8)+(6!8)+(8!8)+(10!8)│(0!9)+(2!9)+(4!9)+(6!9)+(8!9)+(10!9)│(0!10)+(2!10)+(4!10)+(6!10)+(8!10)+(10!10)│(0!11)+(2!11)+(4!11)+(6!11)+(8!11)+(10!11)│(0!12)+(2!12)+(4!12)+(6!12)+(8!12)+(10!12)│(0!13)+(2!13)+(4!13)+(6!13)+(8!13)+(10!13)│(0!14)+(2!14)+(4!14)+(6!14)+(8!14)+(10!14)│
└────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴────────────────────────────────────┴──────────────────────────────────────────┴──────────────────────────────────────────┴──────────────────────────────────────────┴──────────────────────────────────────────┴──────────────────────────────────────────┘

结果与之前的暴力破解结果相同:

       N=1  N=2  N=3  N=4  N=5  N=6  N=7  N=8  N=9  N=10  N=11  N=12  N=13  N=14 
 K=1     1    2    3    4    5    6    7    8    9    10    11    12    13    14 
 K=2     1    2    4    7   11   16   22   29   37    46    56    67    79    92 
 K=3     1    2    4    8   15   26   42   64   93   130   176   232   299   378 
 K=4     1    2    4    8   16   31   57   99  163   256   386   562   794  1093 
 K=5     1    2    4    8   16   32   63  120  219   382   638  1024  1586  2380 
 K=6     1    2    4    8   16   32   64  127  247   466   848  1486  2510  4096 
 K=7     1    2    4    8   16   32   64  128  255   502   968  1816  3302  5812 
 K=8     1    2    4    8   16   32   64  128  256   511  1013  1981  3797  7099 
 K=9     1    2    4    8   16   32   64  128  256   512  1023  2036  4017  7814 
 K=10    1    2    4    8   16   32   64  128  256   512  1024  2047  4083  8100

这些是经过 K 次修改后唯一数组的总数。希望这能澄清 :-)。

关于c++ - 查找数组总数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37709170/

amp43code1011c++arraysalgorithmcombinationspermutation

有关c++ - 查找数组总数的更多相关文章

  1. ruby-on-rails - 在 Ruby 中循环遍历多个数组 - 2

    我有多个ActiveRecord子类Item的实例数组，我需要根据最早的事件循环打印。在这种情况下，我需要打印付款和维护日期，如下所示:ItemAmaintenancerequiredin5daysItemBpaymentrequiredin6daysItemApaymentrequiredin7daysItemBmaintenancerequiredin8days我目前有两个查询，用于查找maintenance和payment项目(非排他性查询)，并输出如下内容:paymentrequiredin...maintenancerequiredin...有什么方法可以改善上述(丑陋的)代

  2. ruby - 多次弹出/移动 ruby​​ 数组 - 2

    我的代码目前看起来像这样numbers=[1,2,3,4,5]defpop_threepop=[]3.times{pop有没有办法在一行中完成pop_three方法中的内容？我基本上想做类似numbers.slice(0,3)的事情，但要删除切片中的数组项。嗯...嗯，我想我刚刚意识到我可以试试slice! 最佳答案 是numbers.pop(3)或者numbers.shift(3)如果你想要另一边。 关于ruby-多次弹出/移动ruby​​数组，我们在StackOverflow上找到一

  3. ruby - 将数组的内容转换为 int - 2

    我需要读入一个包含数字列表的文件。此代码读取文件并将其放入二维数组中。现在我需要获取数组中所有数字的平均值，但我需要将数组的内容更改为int。有什么想法可以将to_i方法放在哪里吗？ClassTerraindefinitializefile_name@input=IO.readlines(file_name)#readinfile@size=@input[0].to_i@land=[@size]x=1whilex 最佳答案 只需将数组映射为整数:@land边注如果你想得到一条线的平均值，你可以这样做:values=@input[x]

  4. ruby-on-rails - 如何优雅地重启 thin + nginx？ - 2

    我的瘦服务器配置了nginx，我的ROR应用程序正在它们上运行。在我发布代码更新时运行thinrestart会给我的应用程序带来一些停机时间。我试图弄清楚如何优雅地重启正在运行的Thin实例，但找不到好的解决方案。有没有人能做到这一点？ 最佳答案 #Restartjustthethinserverdescribedbythatconfigsudothin-C/etc/thin/mysite.ymlrestartNginx将继续运行并代理请求。如果您将Nginx设置为使用多个上游服务器，例如server{listen80;server

  5. ruby - 通过 erb 模板输出 ruby​​ 数组 - 2

    我正在使用puppet为ruby​​程序提供一组常量。我需要提供一组主机名，我的程序将对其进行迭代。在我之前使用的bash脚本中，我只是将它作为一个puppet变量hosts=>"host1,host2"我将其提供给bash脚本作为HOSTS=显然这对ruby​​不太适用——我需要它的格式hosts=["host1","host2"]自从phosts和putsmy_array.inspect提供输出["host1","host2"]我希望使用其中之一。不幸的是，我终其一生都无法弄清楚如何让它发挥作用。我尝试了以下各项:我发现某处他们指出我需要在函数调用前放置“function_”……这

  6. ruby - 检查数组是否在增加 - 2

    这个问题在这里已经有了答案:Checktoseeifanarrayisalreadysorted?(8个答案)关闭9年前。我只是想知道是否有办法检查数组是否在增加？这是我的解决方案，但我正在寻找更漂亮的方法:n=-1@arr.flatten.each{|e|returnfalseife

  7. ruby - 如果指定键的值在数组中相同，如何合并哈希 - 2

    我有一个这样的哈希数组:[{:foo=>2,:date=>Sat,01Sep2014},{:foo2=>2,:date=>Sat,02Sep2014},{:foo3=>3,:date=>Sat,01Sep2014},{:foo4=>4,:date=>Sat,03Sep2014},{:foo5=>5,:date=>Sat,02Sep2014}]如果:date相同，我想合并哈希值。我对上面数组的期望是:[{:foo=>2,:foo3=>3,:date=>Sat,01Sep2014},{:foo2=>2,:foo5=>5:date=>Sat,02Sep2014},{:foo4=>4,:dat

  8. ruby - 在 Ruby 中用键盘诅咒数组浏览 - 2

    我正在尝试在Ruby中制作一个cli应用程序，它接受一个给定的数组，然后将其显示为一个列表，我可以使用箭头键浏览它。我觉得我已经在Ruby中看到一个库已经这样做了，但我记不起它的名字了。我正在尝试对soundcloud2000中的代码进行逆向工程做类似的事情，但他的代码与SoundcloudAPI的使用紧密耦合。我知道cursesgem，我正在考虑更抽象的东西。广告有没有人见过可以做到这一点的库或一些概念证明的Ruby代码可以做到这一点？ 最佳答案 我不知道这是否是您正在寻找的，但也许您可以使用我的想法。由于我没有关于您要完成的工作

  9. ruby - 当使用::指定模块时，为什么 Ruby 不在更高范围内查找类？ - 2

    我刚刚被困在这个问题上一段时间了。以这个基地为例:moduleTopclassTestendmoduleFooendend稍后，我可以通过这样做在Foo中定义扩展Test的类:moduleTopmoduleFooclassSomeTest但是，如果我尝试通过使用::指定模块来最小化缩进:moduleTop::FooclassFailure这失败了:NameError:uninitializedconstantTop::Foo::Test这是一个错误，还是仅仅是Ruby解析变量名的方式的逻辑结果？ 最佳答案 Isthisabug,or

  10. ruby - 如何在 Grape 中定义哈希数组？ - 2

    我使用Ember作为我的前端和GrapeAPI来为我的API提供服务。前端发送类似:{"service"=>{"name"=>"Name","duration"=>"30","user"=>nil,"organization"=>"org","category"=>nil,"description"=>"description","disabled"=>true,"color"=>nil,"availabilities"=>[{"day"=>"Saturday","enabled"=>false,"timeSlots"=>[{"startAt"=>"09:00AM","endAt"=>

随机推荐