Arrays 从O（n）中的一个数字序列中找到一个连续子序列的算法，该子序列的和将是一个被询问的数字M

假设我们有一个正数数组，我们得到一个值

M

。我们的目标是找出在正数数组中是否有一个连续的子序列，使得序列的和正好等于和M。如果

a[1]，a[2]，…a[n]

是一个数组，那么我们必须找出是否存在

i

和

j

，使得

a[i]+…+a[j]=M

我试图用贪婪的方法得到O（n）解。

（编辑：参见templatetypedef的评论）

使用两个索引方法：如果子序列太小，则增加较低的索引，否则增加较高的索引

例如：

void solve(int *a, int n, int M) {
    if (n <= 0) return;
    int i, j, s;
    i = 0, j = 0, s = a[j];
    while (j < n) {
        if (s == M) {
            printf("%dth through %dth elements\n", i + 1, j + 1);
            return;
        } else if (s < M) {
            j++;
            s += a[j];
        } else {
            s -= a[i];
            i++;
        }
    }
}

void solve（int*a，int n，int M）{
如果（n（编辑：参见templatetypedef的注释）

使用两个索引方法：如果子序列太小，则增加较低的索引，否则增加较高的索引

例如：

void solve(int *a, int n, int M) {
    if (n <= 0) return;
    int i, j, s;
    i = 0, j = 0, s = a[j];
    while (j < n) {
        if (s == M) {
            printf("%dth through %dth elements\n", i + 1, j + 1);
            return;
        } else if (s < M) {
            j++;
            s += a[j];
        } else {
            s -= a[i];
            i++;
        }
    }
}

void solve（int*a，int n，int M）{
如果（n我相信你可以用指针追踪算法在线性时间内解决这个问题

直觉是这样的。在数组的左侧开始一个指针。继续向右移动指针，跟踪到目前为止看到的元素的总和，直到您正好击中M（完成！），总数超过M（现在停止，添加更多元素只会使情况更糟），或者您击中数组的末尾，但未达到至少M（所有合并的元素都太小）。如果最终的总和超过M，则可以保证从数组开头开始的子数组的总和不会正好等于M，因为您尝试了所有元素，但它们要么太小，要么太大

现在，在第一个元素上开始第二个指针，并继续向前移动，减去当前元素，直到精确到M（完成！），到达第一个指针（现在停止），或者总数下降到M以下（现在停止）。使用此指针跳过的所有元素都不能作为要查找的子数组的起点。此时，请再次开始向前移动第一个指针

总的来说，每个指针最多前进n次，并且每一步都要做O（1）个工作，所以这是在时间O（n）内运行的。另外，它只使用O（1）个空间，这与它将得到的空间一样好！
我相信你可以用指针追踪算法在线性时间内解决这个问题

直觉是这样的。在数组的左侧开始一个指针。继续向右移动指针，跟踪到目前为止看到的元素的总和，直到您正好击中M（完成！），总数超过M（现在停止，添加更多元素只会使情况更糟），或者您击中数组的末尾，但未达到至少M（所有合并的元素都太小）。如果最终的总和超过M，则可以保证从数组开头开始的子数组的总和不会正好等于M，因为您尝试了所有元素，但它们要么太小，要么太大

现在，在第一个元素上开始第二个指针，并继续向前移动，减去当前元素，直到精确到M（完成！），到达第一个指针（现在停止），或者总数下降到M以下（现在停止）。使用此指针跳过的所有元素都不能作为要查找的子数组的起点。此时，请再次开始向前移动第一个指针

总的来说，每个指针最多前进n次，并且每个步骤都要做O（1）个工作，因此它在O（n）时间内运行。另外，它只使用O（1）这是一个标准的双指针问题。首先，创建一个数组，
prefix
，它将存储给定数组的前缀和，比如
arr

所以

从两个指针开始，
lower
和
upper
。将它们初始化为

lower = 0
upper = 1

（注意：将
前缀[0]
初始化为
0
）

现在，请尝试理解以下代码：

lower = 0, upper = 1;
while(upper <= n) { // n is the number of elements
  if(prefix[upper] - prefix[lower] == m) {
    return true;
  } else if(prefix[upper] - prefix[lower] > m) {
    lower++;
  } else {
    upper++;
  }
}
return false;

lower=0，upper=1；
while（上m）{
低级++；
}否则{
上位机++；
}
}
返回false；

这里我们使用的是数组由正整数组成的事实，
因此，
前缀
正在增加
这是一个标准的双指针问题。首先，创建一个数组，
前缀
，它将存储给定数组的前缀和，比如
arr

所以

从两个指针开始，
lower
和
upper
。将它们初始化为

lower = 0
upper = 1

（注意：将
前缀[0]
初始化为
0
）

现在，请尝试理解以下代码：

lower = 0, upper = 1;
while(upper <= n) { // n is the number of elements
  if(prefix[upper] - prefix[lower] == m) {
    return true;
  } else if(prefix[upper] - prefix[lower] > m) {
    lower++;
  } else {
    upper++;
  }
}
return false;

lower=0，upper=1；
while（上m）{
低级++；
}否则{
上位机++；
}
}
返回false；

这里我们使用的是数组由正整数组成的事实，
因此，
前缀
正在增加
假设索引为X的子阵列≤ 我认为这可能是解决办法

从X=1，Y=1，元素之和=0开始

只要和小于M，且Y假设具有指数X的子阵列≤ 我认为这可能是解决办法

从X=1，Y=1，元素之和=0开始

只要总和小于M，并且Y
公共类FindSumEquals{
公共静态void main（字符串[]args）{
int n=15；
System.out.println（“计数为”+findPossible（n））；
}
私有静态int findPossible（int n）{
内部温度=n；
int-arraylelength=n/2+2；
System.out.println（“arrayllength:+arrayllength”）；
int a[]=新的int[arrayLength]；
整数计数=0；
对于（int i=1；i
公共类FindSumEquals{
公共静电