和为给定值的子数组

2025年3月17日 | 阅读20分钟

在这个问题中，我们得到了一个由非负整数组成的未排序数组和一个整数和。
我们需要找到数组中的一部分，或者说我们需要找到一个子数组，其元素的总和恰好等于给定的和。
我们需要应用算法来解决这个问题，最终得到期望的输出。

让我们通过一个例子来理解它——

我们给出了一个数组和一个和。

示例 1

给定

arr = { 10 , 12 , 2 , 4 , 13 , 19 , 5 }

sum = 18

输出

给定的和在索引 1 到 3 之间找到

子数组是：{ 12 , 2 , 4 }

对应元素索引之间的所需和是：12 + 2 + 4 = 18

示例 2

给定

arr = { 1 , 12 , 2 , 14 , 3 , 16 , 4 }

sum = 19

输出

给定的和在索引 4 到 5 之间找到

子数组是：{ 3, 16 }

对应元素索引之间的所需和是：3 + 16 = 19

示例 3

给定

arr = { 1 , 12 , 2 , 14 , 3 , 16 , 4 }

sum = 5

输出

在给定的数组中未找到给定的和

示例 4

给定

arr = { 1 , 13 , 2 , 14 , 3 , 7 , 4 }

sum = 14

输出

给定的和在索引 0 到 1 之间找到

子数组是：{ 1, 13 }

对应元素索引之间的所需和是：1 + 13 = 14

这里如果我们观察到，有不止一个子数组，其中所有元素的总和等于 14，即如下所示——

第一个子数组在索引 0 到 1 之间找到，即 { 1 , 13 }。
第二个子数组在索引 3 处找到，即 { 14 }。
第三个子数组在索引 4 到 6 之间找到，即 { 3, 7, 4 }。

如果我们得到多个这样的子数组，通过相加它们的元素得到期望的和，那么输出会是什么？

它将显示**第一个最短的子数组**，其元素的总和恰好等于给定的和。我们基于以上逻辑推导算法，简而言之，我们查找与相应的给定和首次匹配的子数组。

用于从给定数组中查找子数组，其元素总和与给定和匹配的方法——

使用暴力方法，一种低效且简单的方法。
使用线性复杂度方法，一种高效的方法。

让我们使用上述方法从给定数组中找到匹配给定和的子数组。

方法 # 1 暴力方法，一种低效且简单的方法——

程序员必须始终首选的方法是暴力方法，这将增加我们对问题的理解。一旦我们用这种方法解决了这个问题，它将提高我们的信心水平，之后我们可以进一步尝试其他方法，这些方法可能比此方法更有效。

让我们用这种方法来讨论上述问题

正如我们已经看到的，对于这个问题的工作，我们都需要找到一个子数组，其中所有元素的总和与给定的和值匹配。

用于解决此问题的暴力方法实现算法——

步骤 1 - 从用户那里获取一个包含 ' n ' 个元素的数组；在主函数中，这些元素是指非负整数。我们也可以从用户那里获取和值，以便相应地生成结果。

步骤 2 - 调用一个函数来查找一个子数组，其中所有元素的总和与给定的和匹配。将原始数组、元素数量和给定的和值作为参数传递给函数。

步骤 3 - 在子数组函数中，运行两个循环；一个循环将从数组的第 0 个索引运行到最后一个索引。我们可以定义 i = 0 到 i = n-1 来遍历从索引 0 到最后一个索引的数组。

步骤 4 - 另一个循环在第一个循环内部，正如我们所说，它是嵌套循环，它将从 j = i + 1 运行到 n。

步骤 5 - 在这个子数组函数的开始，声明一个名为 currentsum 的变量；它最初将用 arr [ 0 ] 初始化。

步骤 6 - 在第二个循环中，推导一个条件来检查当前总和是否等于给定的总和；如果相等，则以索引的形式打印结果。

步骤 7 - 如果不相等，则检查 currentsum 是否大于 j == n 的总和；如果此条件为真，则从循环中中断。

步骤 8 - 最后，将 currentsum = currentsum + arr [ j ] 赋值。

步骤 9 - 如果 currentsum == sum 条件失败，步骤 8 将通过将 arr [ j ] 的值加到 currentsum 来计算当前总和。

步骤 10 - 在执行完循环 1 和嵌套在循环 1 中的循环 2 后，我们将得到期望的结果。

步骤 11 - 如果仍然出现 currentsum 与给定的和不匹配的情况，则表示主数组中不存在这样的子数组。

步骤 12 - 最后，我们将在屏幕上看到期望的输出。

使用方法 # 1 在 C 编程语言中实现带给定和的子数组问题

/* C program to print Subarray with given sum using Brute force approach */
#include <stdio.h>
/* The program will print the indexes if the currentsum is equal to the sum, else it will print sum will not found */
int  subarray ( int arr[], int n, int sum )
{
	int currentsum, i , j , k ;
	// Start with initial index 0 element
	for ( i = 0 ; i < n ; i++ ) 
	{
		currentsum = arr[ i ] ;
		// try all subarrays starting with 'i'
		for ( j = i + 1 ; j <= n ; j++ ) 
		{
			if (currentsum == sum) {
			printf ( " Sum found between indexes %d and %d\n " , i , j -1 ) ;
				printf( " Printing the required subarray: \n " ) ;
				for( k = i ; k <= j - 1 ; k++ )
				{
					printf( "  %d ",arr[ k ] ) ;
				}
                                               return 0 ;
			}
			if ( currentsum > sum || j == n )
				break ;
			currentsum = currentsum + arr[ j ] ;
		}
	}
	
		printf( " \n No subarray found \n " ) ;
}
int main()
{
	int i , A[ 100 ] , n , sum ;
	printf ( " Enter number of elements present in the array : " ) ;
	scanf ( "%d " , &n ) ;
	printf( " Enter array: " ) ;
	for ( i = 0 ;  i < n ; i++ )
	{
		scanf ( "%d " , &A[ i ] ) ;
	}
	printf( " Enter sum value: " ) ;
	scanf( "%d " , &sum ) ;
	subarray ( A , n , sum ) ;
	return 0 ;
}

使用方法 # 1 解决带给定和的子数组问题的以下 C 程序输出

使用方法 # 1 在 C++ 编程语言中实现带给定和的子数组问题

/* C++ program to print subarray with given sum using Brute force approach */
#include <iostream>
using namespace std;
/* The program will print the indexes if the currentsum is equal to the sum, else it will print sum will not found */
int subarray ( int arr[] , int n , int sum )
{
	int currentsum, i, j, k ;

	// Start with initial index 0 element
	for ( i = 0 ; i < n ; i++ ) 
	{
		currentsum = arr[ i ] ;

		// try all subarrays starting with ' i '
		for ( j = i + 1 ; j <= n ; j++ ) 
		{
			if ( currentsum == sum ) 
			{	
			cout<<  " Sum found between indexes  " <<  i << " and " <<  j - 1 << endl ;
				cout << " Printing the required subarray : " << endl ;
				for( k = i ; k <= j-1 ; k++ )
				{
					cout << arr[ k ] << " " ;
				}
				return 0 ;
			}
			if ( currentsum  >  sum || j == n )
				break ;
			currentsum = currentsum + arr[ j ] ;
		}
		
	}
		cout << endl ;
		cout  << " No subarray found " << endl ;
}

int main()
{
	int i ,  A[ 100 ] , n , sum ;
	cout << " Enter number of elements present in the array : " << endl ;
	cin >> n ;
	cout << " Enter array :  " << endl ;
	for ( i = 0 ; i < n ; i++ )
	{
		cin >> A [ i ] ; 
	}
	cout << " Enter sum value:  " ;
	cin >> sum ;
	subarray ( A , n , sum ) ;

	return 0 ;
}

使用方法 # 1 解决带给定和的子数组问题的以下 C++ 程序输出

使用方法 # 1 在 Python 编程语言中实现带给定和的子数组问题

# Python program to print Subarray with given sum using Brute force approach 
# The program will print the indexes if the currentsum is equal to the sum; else, it will print sum will not be found 

def subarray(A,n,sum):
  for i in range(n):
        currentsum = A[i]
        # start array with the initial index 
        # try all subarrays
        # starting with 'i'
        j = i + 1
        while j <= n:
         
            if currentsum == sum:
                print("Sum found between")
                print("indexes % d and % d"%( i, j-1))
                 
                return 1
                 
            if currentsum > sum or j == n:
                break
             
            currentsum = currentsum + A[j]
            j = j + 1
        print("No subarray found")
        return 0

print("Enter size of an array: ")
n=int(input())
print("Enter array elements: ")
i=0
A=[]
while(i<n):
  ele=int(input())
  A.append(ele)
  i=i+1
print("Enter value of sum: ")
sum=int(input())
subarray(A,n,sum)

使用方法 # 1 解决带给定和的子数组问题的以下 Python 程序输出

使用方法 # 1 在 Java 编程语言中实现带给定和的子数组问题

// Java program to print Subarray with given sum using Brute force approach 
// The program will print the indexes if the currentsum is equal to the sum; else, it will print sum will not be found 

import java.util.Scanner ;  
class Main {
	/* If our function subarray seems to be successful in finding any subarray whose sum of elements matches with the given sum value, then we will print the resulting Subarray, else we will return -1./
	static int subarray(int arr[] , int n , int sum )
	{
		int currentsum, i , j ;
		// start array with the initial index try all subarrays starting with  ' i '

		for ( i = 0 ; i < n ; i++ ) {
			currentsum = arr[ i ] ;
			for (j = i + 1 ; j <= n ; j++) {
				if (currentsum == sum) {
					int p = j - 1 ;
					System.out.println(
						" Sum found between indexes  " + i
						+ " and " + p) ;
					return 1 ;
				}
				if (currentsum > sum || j == n)
					break ;
				currentsum = currentsum + arr[j] ;
			}
		}

		System.out.println(" No subarray found " ) ;
		return 0 ;
	}

	public static void main( String[] args )
	{
		int n ;
 Scanner sc = new Scanner ( System.in ) ; 
 System.out.println ( " Enter number of elements :  " ) ;
 n = sc.nextInt() ;
 int [] array = new int[ 100 ] ;
 System.out.println ( " Enter elements of the array :  " ) ;
 for ( int i = 0 ; i < n ; i++ )
 {
	 array[ i ] = sc.nextInt() ;
 }
 System.out.println( " Enter value of sum : " ) ;
 int sum = sc.nextInt() ;
 subarray( array , n , sum ) ;
	}
}

使用方法 # 1 解决带给定和的子数组问题的以下 Java 程序输出

使用方法 # 1 在 C# 编程语言中实现带给定和的子数组问题

// C# program to print Subarray with given sum using Brute force approach 
// The program will print the indexes if the currentsum is equal to the sum; else, it will print sum will not be found 

using System ;
class Main {
	/* If our function subarray seems to be successful in finding any subarray whose sum of elements matches with the given sum value, then we will print the resulting Subarray, else we will return -1./

	int subarray( int[] arr, int n , int sum )
	{
		int currentsum , i, j ;

         // start array with the initial index 
        //  try all subarrays starting with  ' i '

		for (i = 0 ; i < n ; i++) {
			currentsum = arr[i] ;
			for (j = i + 1 ; j <= n ; j++) {
				if (currentsum == sum) {
					int p = j - 1 ;
					Console.Write("Sum found between "
								+ "indexes " + i + " and " + p) ;
					return 1 ;
				}
				if (currentsum > sum || j == n)
					break ;
				currentsum = currentsum + arr[j] ;
			}
		}

		Console.Write("No subarray found") ;
		return 0 ;
	}
	public static void Main()
	{
		Main arraysum = new Main();
		int[] arr = { 1, 2, 4, 5, 9, 10, 14, 23 };
		int n = arr.Length;
		int sum = 11;
		arraysum.subarray(arr, n, sum);
	}
}

使用方法 # 1 解决带给定和的子数组问题的以下 C# 程序输出

在特定编程语言中成功执行程序并遵循**双重遍历方法**的暴力算法后，我们将获得正确的结果，即找到结果子数组，其元素总和恰好等于给定的和值。

现在让我们分析我们正在应用的算法的运行时间和性能，以通过查找方法 # 1 中使用的算法的时间复杂度和空间复杂度来按升序查找数组。

方法 # 1 的时间复杂度——

为了找到时间复杂度，我们需要观察算法并分析特定行执行所花费的时间。我们可以看到，我们需要使用两个 for 循环遍历数组并检查查找和的条件。因此，时间复杂度将是——

T ( n ) = O ( n ).O ( n )

T ( n ) = O ( n² )

因此，时间复杂度将是 O ( n² )，因为我们对需要 ' n² ' 时间来解决 ' n ' 个元素的问题进行了渐近的粗略估计。

方法 # 1 的空间复杂度——

为了找出空间复杂度，我们需要观察程序并分析存储所有变量所需的空间；当我们注意到程序时，我们将观察到不需要额外的空间来存储元素。

S ( n ) = O ( 1 )

因此，上述方法 # 1 的空间复杂度将是常数。

方法 # 2 线性复杂度方法，一种低效且简单的方法——

正如我们已经看到方法 1（即暴力方法）的工作，我们将进一步研究一种更有效的方法；它非常容易实现来解决任何问题；顾名思义，线性复杂度方法具有线性复杂度。一旦你成功地创建了程序，就尝试找到其他最佳替代方法来以更有效的方式解决给定的问题，其性能优于此方法，时间复杂度低于此方法。

让我们用这种方法来讨论上述问题

正如我们已经看到的，对于这个问题的工作，我们都需要找到一个子数组，其中所有元素的总和与给定的和值匹配。

用于解决此问题的线性复杂度方法实现算法——

步骤 1 - 从用户那里获取一个包含 ' n ' 个元素的数组；在主函数中，这些元素是指非负整数。还要从用户那里获取和值，以便我们可以相应地生成结果。

步骤 2 - 调用一个函数来查找一个子数组，其中所有元素的总和与给定的和匹配。将原始数组、元素数量和给定的和值作为参数传递给函数。

步骤 3 - 在子数组函数中，只运行一个循环；它将从数组的第 0 个索引运行到最后一个索引。我们可以定义 i = 0 到 i = n-1 来遍历从索引 0 到最后一个索引的数组。还将一个名为 ' begin ' 的变量设置为 0。

步骤 4 - 在这个子数组函数的开始，声明一个名为 currentsum 的变量；这个变量最初将用 arr [ 0 ] 初始化。

步骤 5 - 在该循环内，我们将运行一个 while 循环来检查 currentsum 是否大于给定和且 begin 小于 i - 1 的条件；如果此条件为真，那么我们将更新 current sum 变量为 current sum - arr [ begin ]，然后递增 begin，即 begin = begin + 1。

步骤 6 - 之后，在 while 循环之外，使用 if 语句检查 currentsum 是否等于 sum。

步骤 7 - 如果为真，则将结果打印为 begin 和 i - 1 之间的和。

步骤 8 - 之后，使用 if 语句再检查一个语句，看 i 是否小于 n。

步骤 9 - 如果证明为真，则用 currentsum + arr [ i ] 更新 currentsum。

步骤 10 - 如果仍然出现 currentsum 与给定的和不匹配的情况，则表示主数组中不存在这样的子数组。

步骤 11 - 最后，我们将在屏幕上看到期望的输出。

使用方法 # 2 在 C 编程语言中实现带给定和的子数组问题

/* C program to print subarray with given sum using Linear complexity method */
#include <stdio.h>
/* The program will print the indexes if the currentsum is equal to the sum, else it will print sum will not found */
int subarray ( int arr[] , int n , int sum )
{
	int currentsum = arr [ 0 ] , begin = 0 , i ;
 
    /* Add elements one by one to
currentsum and if the currentsum
       exceeds the sum, then remove
starting element */
    for ( i = 1 ; i <= n ; i++ )
 {
        // If currentsum exceeds the sum ,
        // then remove the starting elements
        while (currentsum > sum && begin < i - 1 ) {
            currentsum = currentsum - arr[ begin ] ;
            begin++ ;
        }
 
        // If currentsum becomes equal to sum,
        // then return true
        if ( currentsum == sum ) {
            printf(
                " Sum found between indexes %d and %d " ,
                Begin , i - 1) ;
            return 1 ;
        }
 
        // Add this element to currentsum
        if ( i < n)
            currentsum = currentsum + arr [ i ] ;
    }
 
    // If we reach here, then no subarray
    printf ( " No subarray found") ;
    return 0 ; 
}

int main()
{
	int i , A[ 100 ] , n , sum ;
	printf ( " Enter number of elements present in the array : " ) ;
	scanf ( "%d " , &n ) ;
	printf ( " Enter array : " ) ;
	for( i = 0 ; i < n ; i++ )
	{
		scanf ("%d " , &A[ i ] ) ;
	}
	printf ( " Enter sum value : " ) ;
	scanf ("%d " , &sum ) ;
	subarray ( A , n , sum ) ;
	return 0 ;
}

使用方法 # 2 解决带给定和的子数组问题的以下 C 程序输出

使用方法 # 2 在 C++ 编程语言中实现带给定和的子数组问题

/* C++ program to print subarray with given sum using Linear complexity method */
#include <iostream>
using namespace std ;
/* The program will print the indexes if the currentsum is equal to the sum, else it will print sum will not found */
int subarray(int arr[] , int n , int sum )
{
	int currentsum = arr[ 0 ] , begin = 0 , i ;
 
    /* Add elements one by one to
currentsum and if the currentsum
       exceeds the sum , then remove
starting element */
    for ( i = 1 ; i <= n ; i++) {
        // If currentsum exceeds the sum ,
        // then remove the starting elements
        while ( currentsum > sum && begin < i - 1) {
            currentsum = currentsum - arr[ begin ] ;
            begin++ ;
        }
 
        // If currentsum becomes equal to sum,
        // then return true
        if ( currentsum == sum ) {
            cout<<" Sum found between indexes " << begin << " and " << i - 1 << endl ;
            return 1 ;
        }
        // Add this element to currentsum
        if (i < n)
            currentsum = currentsum + arr[ i ] ;
    }
 
    // If we reach here, then no subarray
    cout << " No subarray found " << endl ;
    return 0 ;
}

int main()
{
	int i , A[ 100 ] ,n , sum ;
	cout << " Enter number of elements present in the array : " << endl ;
	cin >> n ;
	cout << " Enter array : " << endl ;
	for ( i = 0 ; i < n ; i++ )
	{
		cin >> A[ i ] ;
	}
	cout << " Enter sum value : " << endl ;
	cin >> sum ;
	subarray ( A , n , sum ) ;
	
	return 0 ;
}

使用方法 # 2 解决带给定和的子数组问题的以下 C++ 程序输出

使用方法 # 2 在 Java 编程语言中实现带给定和的子数组问题

/* Java program to print Subarray with given sum using Linear complexity method */
/* The program will print the indexes if the currentsum is equal to the sum, else it will print sum will not found */

import java.util.Scanner ;  
class Main {
	/* Returns true if the there is a
subarray of arr[] with a sum equal to
	'sum' otherwise returns false.
Also, prints the result */
	static int subarray(int arr[], int n, int sum)
	{
		int currentsum = arr[0], begin = 0, i;
 
        // Always start with the initial index of an array
        for (i = 1; i <= n; i++) {
            // If currentsum exceeds the sum,
            // then remove the starting elements
            while (currentsum > sum && begin < i - 1) {
                currentsum = currentsum - arr[begin];
                begin++;
            }
 
            // If currentsum becomes equal to sum,
            // then return true
            if (currentsum == sum) {
                int p = i - 1;
                System.out.println(
                    "Sum found between indexes " + begin
                    + " and " + p);
                return 1;
            }
 
            // Add this element to currentsum
            if (i < n)
                currentsum = currentsum + arr[i];
        }
 
        System.out.println("No subarray found");
        return 0;
	}

	public static void main(String[] args)
	{
		int n ;
 Scanner sc = new Scanner ( System.in ) ;
 System.out.println ( " Enter number of elements :  " ) ;
 n = sc.nextInt() ;
 int [] array = new int[ 100 ] ;
 System.out.println ( " Enter elements of the array :  " ) ;
 for ( int i = 0 ; i < n ; i++ )
 {
	 array[ i ] = sc.nextInt() ;
 }
 System.out.println( " Enter value of sum : " ) ;
 int sum = sc.nextInt();
 subarray( array , n , sum ) ;
	}
}

使用方法 # 2 解决带给定和的子数组问题的以下 Java 程序输出

使用方法 # 2 在 Python 编程语言中实现带给定和的子数组问题

# Python program to print Subarray with given sum using Linear complexity method 
# The program will print the indexes if the currentsum is equal to the sum; else, it will print sum will not be found 

def subarray(arr,n,sum):
  currentsum = arr[0]
  begin = 0
 
    # Add elements one by
    # one to currentsum and
    # if the currentsum exceeds
    # the sum, then remove
    # starting element
  i = 1
  while i <= n:
         
        # If currentsum exceeds
        # the sum, then remove
        # the starting elements
      while currentsum > sum and begin < i-1:
         
          currentsum = currentsum - arr[begin]
          begin = begin + 1
             
        # If currentsum becomes
        # equal to sum, then
        # return true
      if currentsum == sum:
          print("Sum found between indexes")
          print("% d and % d"%(begin, i-1))
          return 1
 
        # Add this element
        # to currentsum
      if i < n:
          currentsum = currentsum + arr[i]
      i = i + 1
 
    # If we reach here,
    # then no subarray
  print("No subarray found")
  return 0
print("Enter size of an array: ")
n=int(input())
print("Enter array elements: ")
i=0
A=[]
while(i<n):
  ele=int(input())
  A.append(ele)
  i=i+1
print("Enter value of sum: ")
sum=int(input())
subarray( A , n , sum )

使用方法 # 2 解决带给定和的子数组问题的以下 Python 程序输出

使用方法 # 2 在 C# 编程语言中实现带给定和的子数组问题

/* C# program to print Subarray with given sum using Linear complexity method */
/* The program will print the indexes if the currentsum is equal to the sum, else it will print sum will not found */
using System ;

class Main {

	// Returns true if the
	// there is a subarray of
	// arr [ ] with sum equal to
	// ' sum ' otherwise returns false.
	// Also, prints the result
	int subarray( int[] arr , int n , int sum )
	{
		int currentsum = arr[ 0 ] ,
			begin = 0 , i ;
		// Always start with an initial index of an array
		for ( i = 1 ; i <= n ; i++ ) {
			// If currentsum exceeds
			// the sum, then remove
			// the starting elements
			while ( currentsum > sum && begin < i - 1 ) {
				currentsum = currentsum - arr[ begin ] ;
				begin++ ;
			}

			// If currentsum becomes equal to
			// sum, then return true
			if (currentsum == sum) {
				int p = i - 1 ;
				Console.WriteLine(" Sum found between "+ " indexes " + begin + " and " + p) ;
				return 1 ;
			}

			// Add this element to currentsum
			if (i < n)
				currentsum = currentsum + arr[ i ] ;
		}
		Console.WriteLine( " No subarray found " ) ;
		return 0 ;
	}
	public static void main()
	{
		Main arraysum = new Main() ;
		int[] arr = new int[] { 15 , 2 , 19 , 20 , 9 , 5 , 10 } ;
		int n = arr.Length ;
		int sum = 39 ;
		arraysum.subarray( arr , n , sum ) ;
	}
}

使用方法 # 2 解决带给定和的子数组问题的以下 C# 程序输出

现在让我们分析我们正在应用的算法的性能和运行时间，以通过查找方法 # 2 中使用的算法的时间复杂度和空间复杂度来找到一个子数组，其中其元素的总和等于给定的和值。

方法 # 2 的时间复杂度——

为了找到时间复杂度，首先，我们需要观察算法并分析一行代码执行所花费的时间。我们可以看到，数组的遍历是通过只使用一个 for 循环和检查查找和的条件来完成的。因此，时间复杂度将是——

T ( n ) = O ( n ) + C

' C ' 是任何常数

T ( n ) = O ( n )

因此，时间复杂度将是 O ( n )，因为我们进行渐近的粗略估计，即我们需要 ' n ' 时间来解决 ' n ' 个元素的问题。

方法 # 2 的空间复杂度——

为了找到空间复杂度，我们需要观察代码行并分析存储所有变量所需的空间，正如我们注意到的程序一样，不需要额外的空间来存储元素。

S ( n ) = O ( 1 )

因此，上述方法 # 2 的空间复杂度将是常数。

下一个主题自组织列表

和为给定值的子数组

示例 1

示例 2

示例 3

示例 4

如果我们得到多个这样的子数组，通过相加它们的元素得到期望的和，那么输出会是什么？

用于从给定数组中查找子数组，其元素总和与给定和匹配的方法——

方法 # 1 暴力方法，一种低效且简单的方法——

方法 # 2 线性复杂度方法，一种低效且简单的方法——

用于解决此问题的线性复杂度方法实现算法——

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

数据结构教程

DS 数组

DS 链表

DS 栈

DS 队列

DS 树

DS 图

DS 搜索

DS 排序

哈希与堆

差异

二叉树

二叉搜索树

AVL 树

单向链表

双向链表

循环链表

循环双向链表

DS 选择题

其他

和为给定值的子数组

示例 1

示例 2

示例 3

示例 4

如果我们得到多个这样的子数组，通过相加它们的元素得到期望的和，那么输出会是什么？

用于从给定数组中查找子数组，其元素总和与给定和匹配的方法——

方法 # 1 暴力方法，一种低效且简单的方法——

方法 # 2 线性复杂度方法，一种低效且简单的方法——

用于解决此问题的线性复杂度方法实现算法——

相关帖子

如何检查给定数组是否代表堆

使用循环数组实现双端队列

将表示数字的数组加一

根据军衔查找士兵完成的任务

两个链表的并集和交集

最大的全为 1 的子正方形

k 路归并排序

二叉搜索树中的最低公共祖先

使用 RMQ 在二叉树中查找 LCA

结构化数据与非结构化数据

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器