题目## 题目
题目的主要信息：
- 找出所有和为S的连续正数序列，序列至少包括两个数
- 序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：枚举（前置方法）
思路：
我们可以从数字1开始枚举连续的数字，将其累加判断其是否等于目标，如果小于目标数则继续往后累加，如果大于目标数说明会超过，跳出，继续枚举下一个数字开始的情况（比如2，比如3），这样每次都取连续的序列，只有刚好累加和等于目标数才可以记录从开始到结束这一串数字，代表是一个符合的序列。
//枚举左区间
for(int i = 1; i <= up; i++){
//从左区间往后依次连续累加
for(int j = i; ;j++){
...
而因为序列至少两个数，每次枚举区间的起始数字最多到目标数的一半向下取整即可，因为两个大于目标数一半的数相加一定大于目标数。
具体做法：
- step 1：从1到目标值一半向下取整作为枚举的左区间，即每次序列开始的位置。
- step 2：从每个区间首部开始，依次往后累加，如果大于目标值说明这一串序列找不到，换下一个起点。
- step 3：如果加到某个数字刚好等于目标值，则记录从区间首到区间尾的数字。
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
int sum1 = 0;
//因为序列至少两个数，因此枚举最多到该数字的一半向下取整
int up = (sum - 1) / 2;
//枚举左区间
for(int i = 1; i <= up; i++){
//从左区间往后依次连续累加
for(int j = i; ;j++){
sum1 += j;
//大于目标和则跳出该左区间
if(sum1 > sum){
sum1 = 0;
break;
//等于则找到
}else if(sum1 == sum){
sum1 = 0;
ArrayList<Integer> temp = new ArrayList<Integer>();
//记录线序的数字
for(int k = i; k <= j; k++)
temp.add(k);
res.add(temp);
break;
}
}
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int> > res;
vector<int> temp;
int sum1 = 0;
//因为序列至少两个数，因此枚举最多到该数字的一半向下取整
int up = (sum - 1) / 2;
//枚举左区间
for(int i = 1; i <= up; i++){
//从左区间往后依次连续累加
for(int j = i; ;j++){
sum1 += j;
//大于目标和则跳出该左区间
if(sum1 > sum){
sum1 = 0;
break;
//等于则找到
}else if(sum1 == sum){
sum1 = 0;
temp.clear();
//记录线序的数字
for(int k = i; k <= j; k++)
temp.push_back(k);
res.push_back(temp);
break;
}
}
}
return res;
}
};
Python实现代码：
class Solution:
def FindContinuousSequence(self , sum: int) -> List[List[int]]:
res = []
sum1 = 0
#因为序列至少两个数，因此枚举最多到该数字的一半向下取整
up = (sum - 1) // 2
#枚举左区间
for i in range(1, up + 1):
#从左区间往后依次连续累加
j = i
while True:
sum1 += j
#大于目标和则跳出该左区间
if sum1 > sum:
sum1 = 0
break
#等于则找到
elif sum1 == sum:
sum1 = 0
temp = []
#记录线序的数字
for k in range(i, j + 1):
temp.append(k)
res.append(temp)
break
j += 1
return res
复杂度分析：
- 时间复杂度： O ( n n ) O(n\sqrt n) O(nn)，其中 n n n为目标数字sum，外层枚举最多 ⌊ n / 2 ⌋ \lfloor n/2 \rfloor ⌊n/2⌋次，内层判断最多不会超过 O ( n ) O(\sqrt n) O(n)，因为如果从1累加到 n \sqrt n n会大于 n n n，而从1累加到 n − 1 \sqrt n -1 n−1会小于 n n n，因此最坏情况下累加 n \sqrt n n次
- 空间复杂度： O ( n ) O(\sqrt n) O(n)，其中res属于返回答案必要空间，额外空间只有temp数组，最坏情况长度为 n \sqrt n n
方法二：滑动窗口（推荐使用）
知识点：滑动窗口
滑动窗口是指在数组、字符串、链表等线性结构上的一段，类似一个窗口，而这个窗口可以依次在上述线性结构上从头到尾滑动，且窗口的首尾可以收缩。我们在处理滑动窗口的时候，常用双指针来解决，左指针维护窗口左界，右指针维护窗口右界，二者同方向不同速率移动维持窗口。
思路：
从某一个数字开始的连续序列和等于目标数如果有，只能有一个，于是我们可以用这个性质来使区间滑动。
两个指针l、r指向区间首和区间尾，公式 ( l + r ) ∗ ( r − l + 1 ) / 2 (l + r) * (r - l + 1) / 2 (l+r)∗(r−l+1)/2计算区间内部的序列和，如果这个和刚好等于目标数，说明以该区间首开始的序列找到了，记录下区间内的序列，同时以左边开始的起点就没有序列了，于是左区间收缩；如果区间和大于目标数，说明该区间过长需要收缩，只能收缩左边；如果该区间和小于目标数，说明该区间过短需要扩大，只能向右扩大，移动区间尾。
具体做法：
- step 1：从区间 [ 1 , 2 ] [1,2] [1,2]开始找连续子序列。
- step 2：每次用公式计算区间内的和，若是等于目标数，则记录下该区间的所有数字，为一种序列，同时左区间指针向右。
- step 3：若是区间内的序列和小于目标数，只能右区间扩展，若是区间内的序列和大于目标数，只能左区间收缩。
图示：
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
//从1到2的区间开始
for(int l = 1, r = 2; l < r;){
//计算区间内的连续和
int sum1 = (l + r) * (r - l + 1) / 2;
//如果区间内和等于目标数
if(sum1 == sum){
ArrayList<Integer> temp = new ArrayList<Integer>();
//记录区间序列
for(int i = l; i <= r; i++)
temp.add(i);
res.add(temp);
//左区间向右
l++;
//如果区间内的序列和小于目标数，右区间扩展
}else if(sum1 < sum)
r++;
//如果区间内的序列和大于目标数，左区间收缩
else
l++;
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int> > res;
vector<int> temp;
//从1到2的区间开始
for(int l = 1, r = 2; l < r;){
//计算区间内的连续和
int sum1 = (l + r) * (r - l + 1) / 2;
//如果区间内和等于目标数
if(sum1 == sum){
temp.clear();
//记录区间序列
for(int i = l; i <= r; i++)
temp.push_back(i);
res.push_back(temp);
//左区间向右
l++;
//如果区间内的序列和小于目标数，右区间扩展
}else if(sum1 < sum)
r++;
//如果区间内的序列和大于目标数，左区间收缩
else
l++;
}
return res;
}
};
Python实现代码：
class Solution:
def FindContinuousSequence(self , sum: int) -> List[List[int]]:
res = []
#从1到2的区间开始
l = 1
r = 2
while l < r:
#计算区间内的连续和
sum1 = (l + r) * (r - l + 1) / 2
#如果区间内和等于目标数
if sum1 == sum:
temp = []
#记录区间序列
for i in range(l, r + 1):
temp.append(i)
res.append(temp)
#左区间向右
l += 1
#如果区间内的序列和小于目标数，右区间扩展
elif sum1 < sum:
r += 1
#如果区间内的序列和大于目标数，左区间收缩
else:
l += 1
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，区间移动次数最多 ⌊ n / 2 ⌋ \lfloor n/2 \rfloor ⌊n/2⌋次
- 空间复杂度： O ( n ) O(\sqrt n) O(n)，其中res属于返回答案必要空间，额外空间只有temp数组，最坏情况长度为 n \sqrt n n
题目的主要信息：
- 升序数组中找到和为S的两个数字
- 若有多组，返回任意一组
- 无法找到则返回空数组
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：哈希表（推荐使用）
知识点：哈希表
哈希表是一种根据关键码（key）直接访问值（value）的一种数据结构。而这种直接访问意味着只要知道key就能在 O ( 1 ) O(1) O(1)时间内得到value，因此哈希表常用来统计频率、快速检验某个元素是否出现过等。
思路：
我们能想到最直观的解法，可能就是两层遍历，将数组所有的二元组合枚举一遍，看看是否是和为目标值，但是这样太费时间了，既然加法这么复杂，我们是不是可以尝试一下减法：对于数组中出现的一个数a，如果目标值减去a的值已经出现过了，那这不就是我们要找的一对元组吗？这种时候，快速找到已经出现过的某个值，可以考虑使用哈希表快速检验某个元素是否出现过这一功能。
具体做法：
- step 1：构建一个哈希表，其中key值为遍历数组过程中出现过的值，value值为其相应的下标，因为我们最终要返回的是下标。
- step 2：遍历数组每个元素，如果目标值减去该元素的结果在哈希表中存在，说明我们先前遍历的时候它出现过，根据记录的下标，就可以得到结果。
- step 3：如果相减后的结果没有在哈希表中，说明先前遍历的元素中没有它对应的另一个值，那我们将它加入哈希表，等待后续它匹配的那个值出现即可。
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> res = new ArrayList<Integer>();
//创建哈希表,两元组分别表示值、下标
HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
//在哈希表中查找target-numbers[i]
for(int i = 0; i < array.length; i++){
int temp = sum - array[i];
//若是没找到，将此信息计入哈希表
if(!mp.containsKey(temp)){
mp.put(array[i], i);
}
else{
//取出数字添加
res.add(temp);
res.add(array[i]);
break;
}
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> res;
//创建哈希表,两元组分别表示值、下标
unordered_map<int, int> mp;
//在哈希表中查找sum-array[i]
for(int i = 0; i < array.size(); i++){
int temp = sum - array[i];
//若是没找到，将此信息计入哈希表
if(mp.find(temp) == mp.end()){
mp[array[i]] = i;
}
else{
//取出数字添加
res.push_back(temp);
res.push_back(array[i]);
break;
}
}
return res;
}
};
Python实现代码：
class Solution:
def FindNumbersWithSum(self , array: List[int], sum: int) -> List[int]:
res = []
#创建哈希表,两元组分别表示值、下标
mp = dict()
#在哈希表中查找sum-array[i]
for i in range(len(array)):
temp = sum - array[i]
#若是没找到，将此信息计入哈希表
if temp not in mp:
mp[array[i]] = i
else:
#取出数字添加
res.append(temp)
res.append(array[i])
break
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为数组长度，遍历一次数组
- 空间复杂度： O ( n ) O(n) O(n)，哈希表最大空间为 n n n
方法二：双指针（扩展思路）
知识点：双指针
双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个指针（特殊情况甚至可以多个），两个指针或是同方向访问两个链表、或是同方向访问一个链表（快慢指针）、或是相反方向扫描（对撞指针），从而达到我们需要的目的。
思路：
这道题目还有一个条件是数组是升序序列，在方法一中没有用到。这个条件有什么用？既然数组是有序的，那我们肯定知道和找到一定程度就不找了，我们为什么要从最小的两个数开始相加呢？我们可以用二分法的思路，从中间开始找。
使用双指针指向数组第一个元素和最后一个元素，然后双指针对撞移动，如果两个指针下的和正好等于目标值sum，那我们肯定找到了，如果和小于sum，说明我们需要找到更大的，那只能增加左边的元素，如果和大于sum，说明我们需要找更小的，只能减小右边的元素。
具体做法：
- step 1：准备左右双指针分别指向数组首尾元素。
- step 2：如果两个指针下的和正好等于目标值sum，则找到了所求的两个元素。
- step 3：如果两个指针下的和大于目标值sum，右指针左移；如果两个指针下的和小于目标值sum，左指针右移。
- step 4：当两指针对撞时，还没有找到，就是数组没有。
图示：
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> res = new ArrayList<Integer>();
//左右双指针
int left = 0, right = array.length - 1;
//对撞双指针
while(left < right){
//相加等于sum，找到目标
if(array[left] + array[right] == sum){
res.add(array[left]);
res.add(array[right]);
break;
//和太大，缩小右边
}else if(array[left] + array[right] > sum)
right--;
//和太小，扩大左边
else
left++;
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> res;
//左右双指针
int left = 0, right = array.size() - 1;
//对撞双指针
while(left < right){
//相加等于sum，找到目标
if(array[left] + array[right] == sum){
res.push_back(array[left]);
res.push_back(array[right]);
break;
//和太大，缩小右边
}else if(array[left] + array[right] > sum)
right--;
//和太小，扩大左边
else
left++;
}
return res;
}
};
Python实现代码：
class Solution:
def FindNumbersWithSum(self , array: List[int], sum: int) -> List[int]:
res = []
#左右双指针
left = 0
right = len(array) - 1
#对撞双指针
while left < right:
#相加等于sum，找到目标
if array[left] + array[right] == sum:
res.append(array[left])
res.append(array[right])
break
#和太大，缩小右边
elif array[left] + array[right] > sum:
right -= 1
#和太小，扩大左边
else:
left += 1
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为数组长度，左右指针共同遍历一次数组
- 空间复杂度： O ( 1 ) O(1) O(1)，常数个变量，无额外辅助空间
扫一扫
2466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
