leetcode 446. Arithmetic Slices II - Subsequence

最新推荐文章于 2024-11-04 07:15:00 发布

景行cmy

最新推荐文章于 2024-11-04 07:15:00 发布

阅读量153

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 动态规划哈希表文章标签： leetcode 动态规划 hashmap

本文链接：https://blog.youkuaiyun.com/cmy203/article/details/99603419

leetcode 同时被 3 个专栏收录

155 篇文章

订阅专栏

动态规划

25 篇文章

订阅专栏

哈希表

9 篇文章

订阅专栏

本文探讨了在给定整数数组中寻找等差子序列的算法，通过动态规划方法，详细介绍了如何有效地计算所有可能的等差子序列数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A sequence of numbers is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.

For example, these are arithmetic sequences:

1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9

The following sequence is not arithmetic.

1, 1, 2, 5, 7

A zero-indexed array A consisting of N numbers is given. A subsequence slice of that array is any sequence of integers (P0, P1, ..., Pk) such that 0 ≤ P0< P1 < ... < Pk < N.

A subsequence slice (P0, P1, ..., Pk) of array A is called arithmetic if the sequence A[P0], A[P1], ..., A[Pk-1], A[Pk] is arithmetic. In particular, this means that k ≥ 2.

The function should return the number of arithmetic subsequence slices in the array A.

The input contains N integers. Every integer is in the range of -231 and 231-1 and 0 ≤ N ≤ 1000. The output is guaranteed to be less than 231-1.

Example:

Input: [2, 4, 6, 8, 10]

Output: 7

Explanation:
All arithmetic subsequence slices are:
[2,4,6]
[4,6,8]
[6,8,10]
[2,4,6,8]
[4,6,8,10]
[2,4,6,8,10]
[2,6,10]

这道题我想的太复杂了。

解法1.0：

这里set中装的是等差数列首元素的序号和末元素的序号，因为用了set所以可以避免重复序列，但是只能避免首尾元素重复，不能避免中间元素重复；

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) 
    {
        if(A.size() < 3) return 0 ;
        int res = 0 ;
        map<long , set<pair<int,int>>> m ;
        for(int i = 2 ; i < A.size() ; ++i)
        {
            map<long, set<pair<int, int>>> tmp ;
            for(int j = 0 ; j < i - 1 ; ++j)
                for(int k = j + 1 ; k < i ; ++k)
                {
                    if( A[j] <= A[k] && A[k] <= A[i] && (long)A[j] + (long)A[i] == 2 * (long)A[k]) tmp[(long)A[k] - (long)A[j]].insert({j , i}) ;
                    else if(A[i] <= A[j] && A[j] <= A[k] && (long)A[i] + (long)A[k] == 2 * (long)A[j]) tmp[(long)A[j] - (long)A[i]].insert({i , k}) ;
                    else if(A[k] <= A[j] && A[j] <= A[i] && (long)A[i] + (long)A[k] == 2 * (long)A[j]) tmp[(long)A[j] - (long)A[k]].insert({k , i}) ;
                    else if(A[i] <= A[k] && A[k] <= A[j] && (long)A[i] + (long)A[j] == 2 * (long)A[k]) tmp[(long)A[k] - (long)A[i]].insert({i , j}) ;
                    else if(A[j] <= A[i] && A[i] <= A[k] && (long)A[j] + (long)A[k] == 2 * (long)A[i]) tmp[(long)A[i] - (long)A[j]].insert({j , k}) ;
                    else if(A[k] <= A[i] && A[i] <= A[j] && (long)A[k] + (long)A[j] == 2 * (long)A[i]) tmp[(long)A[i] - (long)A[k]].insert({k , j}) ;
                } 
            
            for(auto itbm = m.begin() ; itbm != m.end() ; itbm++)
            {
                int diff = itbm->first ;
                for(auto itbs = itbm->second.begin() ; itbs != itbm->second.end() ; itbs++)
                {
                    tmp[diff].insert(*itbs) ;
                    if((long)A[i] - (long)A[itbs->second] == diff ) 
                    {
                        tmp[diff].insert({itbs->first , i}) ;
                    }
                    else if((long)A[itbs->first] - (long)A[i] == diff) 
                    {                       
                        tmp[diff].insert({i , itbs->second}) ;
                    }
                }
            }
            
            m = tmp ;
        }
        
        for(auto itbm = m.begin() ; itbm != m.end() ; itbm++)
        {
            res += itbm->second.size() ;
        }
        
        return res ;
    }
};

解法1.1：

所以用set装等差数列的全部序号，但是时间复杂度达到O(N^3)，TLE了，其实这种解不TLE也会MLE的；

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) 
    {
        if(A.size() < 3) return 0 ;
        int res = 0 ;
        map<long , set<vector<int>>> m ;
        for(int i = 2 ; i < A.size() ; ++i)
        {
            map<long, set<vector<int>>> tmp ;
            for(int j = 0 ; j < i - 1 ; ++j)
                for(int k = j + 1 ; k < i ; ++k)
                {
                    if( A[j] <= A[k] && A[k] <= A[i] && (long)A[j] + (long)A[i] == 2 * (long)A[k]) tmp[(long)A[k] - (long)A[j]].insert({j , k , i}) ;
                    else if(A[i] <= A[j] && A[j] <= A[k] && (long)A[i] + (long)A[k] == 2 * (long)A[j]) tmp[(long)A[j] - (long)A[i]].insert({i , j , k}) ;
                    else if(A[k] <= A[j] && A[j] <= A[i] && (long)A[i] + (long)A[k] == 2 * (long)A[j]) tmp[(long)A[j] - (long)A[k]].insert({k , j , i}) ;
                    else if(A[i] <= A[k] && A[k] <= A[j] && (long)A[i] + (long)A[j] == 2 * (long)A[k]) tmp[(long)A[k] - (long)A[i]].insert({i , k , j}) ;
                    else if(A[j] <= A[i] && A[i] <= A[k] && (long)A[j] + (long)A[k] == 2 * (long)A[i]) tmp[(long)A[i] - (long)A[j]].insert({j , i , k}) ;
                    else if(A[k] <= A[i] && A[i] <= A[j] && (long)A[k] + (long)A[j] == 2 * (long)A[i]) tmp[(long)A[i] - (long)A[k]].insert({k , i , j}) ;
                } 
            
            for(auto itbm = m.begin() ; itbm != m.end() ; itbm++)
            {
                int diff = itbm->first ;
                for(auto itbs = itbm->second.begin() ; itbs != itbm->second.end() ; itbs++)
                {
                    tmp[diff].insert(*itbs) ;
                    vector<int> v = *itbs ;
                    if((long)A[i] - (long)A[v.back()] == diff ) 
                    {
                        v.push_back(i) ;
                        tmp[diff].insert(v) ;
                    }
                    else if((long)A[v[0]] - (long)A[i] == diff) 
                    {                       
                        v.insert(v.begin() , i) ;
                        tmp[diff].insert(v) ;
                    }
                }
            }
            
            m = tmp ;
        }
        
        for(auto itbm = m.begin() ; itbm != m.end() ; itbm++)
        {
            res += itbm->second.size() ;
        }
        
        return res ;
    }
};

解法2.0:

dp[i]是一个hashmap，m[i] = j ; i 指的是以A[i]为最后一个元素的等差数列中的差值； j指的是以A[i]为最后一个元素的等差数列的个数(元素个数>=3) + 1； 1指的是以A[i]为最后一个元素的等差数列（元素个数为2），当下一个有相同差值的元素可以组成元素个数为3的等差数列；

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) 
    {
        if(A.size() < 3) return 0 ;
        int res = 0 ;
        vector<map<long,int>> dp(A.size()) ;
        for(int i = 1 ; i < A.size() ; ++i)
        {
            for(int j = 0 ; j < i ; ++j)
            {
                long diff = (long)A[i] - (long)A[j] ;
                if(diff > INT_MAX || diff < INT_MIN) continue ;
                dp[i][diff]++ ;
                if(dp[j].count(diff))
                {
                    res += dp[j][diff] ;
                    dp[i][diff] += dp[j][diff] ;
                }
            }
        }
        return res ;
    }
};