P1420 最长连号

最长连号问题解析与解法

原创已于 2025-09-12 01:25:56 修改 · 353 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #数据结构 #洛谷

于 2025-09-06 00:07:04 首次发布

记录6

#include <bits/stdc++.h>
using namespace std;
int main() {
	int n,a[10010]={},cnt=1,max=0;
	cin>>n;
	for(int i=1;i<=n;i++)	cin>>a[i];
	for(int i=2;i<=n;i++){
		if(a[i-1]+1==a[i]) cnt++;
		else cnt=1;
		if(max<cnt) max=cnt;
	}
	cout<<max;
    return 0;
}

突破点

从小到大的连续自然数

思路

输入后，从第二个开始跟前一个对比，连续就统计，不连续就重新统计
创建max变量，来存储统计的最大数量

代码简析

        if(a[i-1]+1==a[i]) cnt++;
		else cnt=1;
		if(max<cnt) max=cnt;

因为数组从下标1开始存储，对于a[i-1]+1==a[i]中的i从下标2开始，可以直接访问前一个数据

else cnt=1;每一次for循环都会进行判断，如果连续就记录，不然就重置为1（从不一样的这个开始判断连续，开始的第一个自然数计数为1）

注意点

max目的是存放最大值，一开始初始化就要按照小的初始化，这样就能从第一个数据开始记录

例如：

数据：6 6 7 8 2 3 3 3

初始化 max=9，没有意义，最多连续是 6 7 8 三个

初始化 max=0或者-1，有连续的时候就会记录，从一记录到三

同理，min要存放个极大值

补充

在C++算法中，计算连续序列的问题非常常见。这类问题通常涉及查找最长的连续子序列、连续子序列的和、连续子序列的乘积等。以下是一些常见的方法和示例。

1. 最长连续子序列

1.1 问题描述

给定一个整数数组，找到最长的连续子序列的长度。

1.2 方法1：排序 + 遍历

步骤：

对数组进行排序。

遍历排序后的数组，计算最长的连续子序列。

代码示例：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int longestConsecutive(vector<int>& nums) {
    if (nums.empty()) return 0;
    sort(nums.begin(), nums.end());
    int longest = 1, current = 1;
    for (int i = 1; i < nums.size(); i++) {
        if (nums[i] != nums[i - 1]) {
            if (nums[i] == nums[i - 1] + 1) {
                current++;
            } else {
                longest = max(longest, current);
                current = 1;
            }
        }
    }
    return max(longest, current);
}

int main() {
    vector<int> nums = {100, 4, 200, 1, 3, 2};
    cout << "Longest consecutive sequence length: " << longestConsecutive(nums) << endl; // 输出：4
    return 0;
}
1.3 方法2：哈希表

步骤：

使用哈希表存储数组中的所有元素。

遍历数组，对于每个元素，检查其是否是某个连续子序列的起始点。

如果是起始点，计算该连续子序列的长度。

代码示例：
#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;

int longestConsecutive(vector<int>& nums) {
    unordered_set<int> numSet(nums.begin(), nums.end());
    int longest = 0;
    for (int num : nums) {
        if (numSet.find(num - 1) == numSet.end()) { // 当前数是连续子序列的起始点
            int currentNum = num;
            int currentLength = 1;
            while (numSet.find(currentNum + 1) != numSet.end()) {
                currentNum += 1;
                currentLength += 1;
            }
            longest = max(longest, currentLength);
        }
    }
    return longest;
}

int main() {
    vector<int> nums = {100, 4, 200, 1, 3, 2};
    cout << "Longest consecutive sequence length: " << longestConsecutive(nums) << endl; // 输出：4
    return 0;
}
2. 连续子序列的和

2.1 问题描述

给定一个整数数组，找到一个连续子序列，使其和最大。

2.2 方法1：Kadane算法

步骤：

初始化两个变量：maxSoFar 和 maxEndingHere。

遍历数组，更新 maxEndingHere 和 maxSoFar。

代码示例：
#include <iostream>
#include <vector>
using namespace std;

int maxSubArraySum(vector<int>& nums) {
    int maxSoFar = nums[0];
    int maxEndingHere = nums[0];
    for (int i = 1; i < nums.size(); i++) {
        maxEndingHere = max(nums[i], maxEndingHere + nums[i]);
        maxSoFar = max(maxSoFar, maxEndingHere);
    }
    return maxSoFar;
}

int main() {
    vector<int> nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
    cout << "Maximum subarray sum: " << maxSubArraySum(nums) << endl; // 输出：6
    return 0;
}
3. 连续子序列的乘积

3.1 问题描述

给定一个整数数组，找到一个连续子序列，使其乘积最大。

3.2 方法1：动态规划

步骤：

初始化两个变量：maxProduct 和 minProduct。

遍历数组，更新 maxProduct 和 minProduct。

代码示例：
#include <iostream>
#include <vector>
using namespace std;

int maxProductSubarray(vector<int>& nums) {
    int maxProduct = nums[0];
    int minProduct = nums[0];
    int result = nums[0];
    for (int i = 1; i < nums.size(); i++) {
        if (nums[i] < 0) {
            swap(maxProduct, minProduct);
        }
        maxProduct = max(nums[i], maxProduct * nums[i]);
        minProduct = min(nums[i], minProduct * nums[i]);
        result = max(result, maxProduct);
    }
    return result;
}

int main() {
    vector<int> nums = {2, 3, -2, 4};
    cout << "Maximum product subarray: " << maxProductSubarray(nums) << endl; // 输出：6
    return 0;
}
4. 连续子序列的和等于目标值

4.1 问题描述

给定一个整数数组和一个目标值，找到一个连续子序列，使其和等于目标值。

4.2 方法1：前缀和 + 哈希表

步骤：

使用哈希表存储前缀和及其索引。

遍历数组，计算当前前缀和。

检查是否存在一个前缀和等于当前前缀和减去目标值。

代码示例：
#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

vector<int> subarraySum(vector<int>& nums, int target) {
    unordered_map<int, int> prefixSumMap;
    prefixSumMap[0] = -1; // 初始化前缀和为0的索引为-1
    int currentSum = 0;
    for (int i = 0; i < nums.size(); i++) {
        currentSum += nums[i];
        if (prefixSumMap.find(currentSum - target) != prefixSumMap.end()) {
            return {prefixSumMap[currentSum - target] + 1, i};
        }
        prefixSumMap[currentSum] = i;
    }
    return {};
}

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    int target = 9;
    vector<int> result = subarraySum(nums, target);
    if (!result.empty()) {
        cout << "Subarray found from index " << result[0] << " to " << result[1] << endl; // 输出：Subarray found from index 1 to 3
    } else {
        cout << "No subarray found." << endl;
    }
    return 0;
}
总结

最长连续子序列：可以通过排序和遍历或使用哈希表来解决。

连续子序列的和：可以使用Kadane算法来解决。

连续子序列的乘积：可以使用动态规划来解决。

连续子序列的和等于目标值：可以使用前缀和和哈希表来解决。

这些方法在处理连续序列问题时非常有效。