Question

我需要计算长度大于1的连续子序列的数量，这样子序列中没有对的总和为k。

即如果a = {1,3,4}且k = 4 所有contiguos子序列包括

{1,3} (sum of the only pair is 4)
{3,4}
{1,3,4} ( sum of one of the pair is 4 )

然后有效的子序列只有{3,4} ..但我的问题的答案是1。这是另外一个例子...

a = {1,4,3,2,0} k = 4; 所有亚系列包括

{1,4}
{1,4,3} (sum of one pair is 4)
{1,4,3,2} (sum of one pair is 4)
{1,4,3,2,0} (sum of more than one pair is 4)
{4,3}
{4,3,2}
{4,3,2,0} (sum of one pair is 4)
{3,2)
{3,2,0}
{2,0}

以上答案中有6个有效序列

我甚至不知道如何开始。

Answer 1

使用for循环遍历数组。从数组中获取第一项，从数组中获取下一项，如果这两项的总和等于k，则转到下一项并重复上一步。如果总和不等于k，则表示您匹配。

int x;
for (x = 0; x < (sizeof(a) - 1); x++) {
    if ((a[x] + a[x+1]) == k) {
        // no match
    } else {
        // match
    }
}

显然，这个例子非常简单，你可以对此进行扩展，但这是开始的。

Answer 2

你需要获得长度大于一的所有间隔

然后对子数组进行排序

然后通过二分查找

在子数组中的每个元素的左侧和右侧查找键

java代码：

int[] a  = {1, 4, 3, 2, 0};
    int k = 4;
    int n = a.length;
    int answer = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i + 1; j++) {
            if ((n - (i + 1)) > 0) {
                int[] subArray = new int[n - i];
                for (int h = j; h <= (n - (i - j + 1)); h++) {
                    subArray[h - j] = a[h];
                }

                // sort
                Arrays.sort(subArray);

                boolean exist = false;
                for (int h = 0; h < subArray.length; h++) {
                    int key = k - subArray[h];
                    // look for key in left side [0, h)
                    int index1 = Arrays.binarySearch(subArray, 0, h, key);
                    // look for key in right side [h+1, subArray.length)
                    int index2 = Arrays.binarySearch(subArray, h + 1, subArray.length, key);
                    if (index1 >= 0 || index2 >= 0) {
                        exist = true;
                        break;
                    }
                }
                answer = !exist ? answer + 1 : answer;
            }
        }
    }
    System.out.println(answer);

输出：

6

Answer 3

您可以从背面遍历阵列。

例如：

数组是

1,2,3,1

在每个点i，我们将尝试计算从i开始具有和K的子阵列。

让我们保留另一个数组，告诉我们右边的索引j的最小leftmost_Right_End，以便存在位置e
（i＆lt; e＆lt; j） A [E] + A [J] ==ķ

现在每当我们处于位置i时，子数组从第i个元素开始应该包含一对，由于第i个元素或右边的某个元素，可以形成该对！

注意：如果我们找到任何对的最小索引，使得A [x] + A [y] == K所有其他z＆gt; y对我们来说是浪费，因为条件说应该不存在A [x] + A [y] == K！

因此，如果K-A [i]存在并且从leftmost_Right_End获取该索引的最小值，则问题将减少为找到每个元素的索引。现在这个索引说如果子阵列从i开始那么它应该至少延伸到索引找到！所以与i相关的子阵列是（N-i + 1）

现在从N *（N-1）/ 2

中减去结果

我有一个代码，我可以更好地解释，但自学习需要提示而不是解决方案:)。附：：我也是一个自学者！

连续子序列的数量

3 个答案: