等差数列划分--关于子串的数量规律

最新推荐文章于 2024-09-02 20:24:07 发布

C+G

最新推荐文章于 2024-09-02 20:24:07 发布

阅读量130

点赞数

分类专栏： Leetcode中级算法文章标签： leetcode dfs 算法动态规划

本文链接：https://blog.csdn.net/m0_50945504/article/details/119567655

版权

Leetcode中级算法专栏收录该内容

119 篇文章 1 订阅

订阅专栏

本文介绍了两种解决等差数列子序列问题的方法。第一种是深度优先搜索（DFS）的暴力解法，虽然时间复杂度较高为O(N^2)。第二种方法利用子串数量规律，通过一次遍历实现O(N)的时间复杂度，显著提高了效率。这两种解法针对数组中寻找等差序列的子序列提供了不同的思路。

摘要由CSDN通过智能技术生成

文章目录

题目

解法一：dfs暴力解法 O(N^2)

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n = nums.size();
        if(n<3)return 0;
        int gap[n];
        memset(gap,0,sizeof gap);
        int index = 1;
        //把数组的所有相邻差值记录下来
        for(int i=0;i<n-1;i++){
            gap[index++] = nums[i+1]-nums[i];
        }
        int cnt = 0;
        //dfs爆搜
        function<void(int ,int)> dfs = [&](int k,int pos){
            if(k>=1)
                cnt++;
            if(pos>n-1)
                return;
            if(gap[pos]==gap[pos-1])
                dfs(k+1,pos+1);
        };
        for(int i=2;i<n;i++){
            dfs(0,i);
        }
        return cnt;
    }
};

解法二：利用子串数量规律实现O(N)

手写解析

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n = nums.size();
        if (n == 1) {
            return 0;
        }

        int d = nums[0] - nums[1], t = 0;
        int ans = 0;
        // 因为等差数列的长度至少为 3，所以可以从 i=2 开始枚举
        for (int i = 2; i < n; ++i) {
            if (nums[i - 1] - nums[i] == d) {
                ++t;
            }
            else {
                d = nums[i - 1] - nums[i];
                t = 0;
            }
            ans += t;
        }
        return ans;
    }
};