📌  相关文章
📜  形成算术级数(AP)的最长子序列

📅  最后修改于: 2021-05-06 20:40:32             🧑  作者: Mango

给定一个由N个整数组成的数组arr [] ，任务是查找最长子序列的长度，而不是形成算术级数。

例子：

天真的方法：解决问题的最简单方法是生成给定数组的所有可能子序列，并打印相邻元素对之间具有相同差异的最长子序列的长度。时间

复杂度： O(N * 2 N )
辅助空间： O(1)

高效方法：可以使用动态编程来优化上述方法。步骤如下：

  1. 初始化辅助矩阵dp [] [] ，其中dp [i] [j]表示子序列的长度，从i开始，并具有与j相同的差。
  2. 迭代使用嵌套循环我选自N阵列– 1 0，直到和j从i + 1到N。
    • 假设arr [i]和arr [j]是序列的前两个元素，并让它们的差为d 。
    • 现在，出现两种情况：
      1. dp [j] [d] = 0 ：不存在以arr [j]开头且与d的差为序列的序列。在这种情况下， dp [i] [d] = 2 ，因为我们只能有arr [i]和arr [j]的顺序。
      2. dp [j] [d]> 0 ：存在一个序列，该序列以arr [j]开头，并且相邻元素之间的差异为d 。在这种情况下，关系为dp [i] [d] = 1 + dp [j] [d] 。
  3. 最后，打印形成的所有子序列的最大长度。

下面是上述方法的实现：

C++
// C++ program for the above approach
 
#include 
using namespace std;
 
// Function that finds the longest
// arithmetic subsequence having the
// same absolute difference
int lenghtOfLongestAP(int A[], int n)
{
 
    // Stores the length of sequences
    // having same difference
    unordered_map >
        dp;
 
    // Stores the resultant length
    int res = 2;
 
    // Iterate over the array
    for (int i = 0; i < n; ++i) {
 
        for (int j = i + 1; j < n; ++j) {
 
            int d = A[j] - A[i];
 
            // Update length of subsequence
            dp[d][j] = dp[d].count(i)
                           ? dp[d][i] + 1
                           : 2;
 
            res = max(res, dp[d][j]);
        }
    }
 
    // Return res
    return res;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 20, 1, 15, 3, 10, 5, 8 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << lenghtOfLongestAP(arr, N);
    return 0;
}

Java
// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function that finds the longest
// arithmetic subsequence having the
// same absolute difference
static int lenghtOfLongestAP(int A[], int n)
{
     
    // Stores the length of sequences
    // having same difference
    Map> dp = new HashMap>();
   
    // Stores the resultant length
    int res = 2;
 
    // Iterate over the array
    for(int i = 0; i < n; ++i)
    {
        for(int j = i + 1; j < n; ++j)
        {
            int d = A[j] - A[i];
            Map temp;
 
            // Update length of subsequence
            if (dp.containsKey(d))
            {
                temp = dp.get(d);
 
                if (temp.containsKey(i))
                    temp.put(j, temp.get(i) + 1);
                else
                    temp.put(j, 2);
            }
            else
            {
                temp = new HashMap();
                temp.put(j, 2);
            }
            dp.put(d, temp);
            res = Math.max(res, temp.get(j));
        }
    }
     
    // Return res
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array arr[]
    int arr[] = { 20, 1, 15, 3, 10, 5, 8 };
 
    int N = arr.length;
 
    // Function Call
    System.out.println(lenghtOfLongestAP(arr, N));
}
}
 
// This code is contributed by jithin

Python3
# Python3 program for the above approach
 
# Function that finds the longest
# arithmetic subsequence having the
# same absolute difference
def lenghtOfLongestAP(A, n) :
 
    # Stores the length of sequences
    # having same difference
    dp = {}
 
    # Stores the resultant length
    res = 2
 
    # Iterate over the array
    for i in range(n) :
 
        for j in range(i + 1, n) :
 
            d = A[j] - A[i]
 
            # Update length of subsequence
            if d in dp :
                if i in dp[d] :
                    dp[d][j] = dp[d][i] + 1
                else :
                    dp[d][j] = 2
            else :
                dp[d] = {}
                dp[d][j] = 2
 
            if d in dp :
                if j in dp[d] :
                    res = max(res, dp[d][j])
 
    # Return res
    return res
 
# Given array arr[]
arr = [ 20, 1, 15, 3, 10, 5, 8 ]
 
N = len(arr)
 
# Function Call
print(lenghtOfLongestAP(arr, N))
 
# This code is contributed by divyeshrabadiya07

C#
// C# program for the above approach
using System;
using System.Collections.Generic; 
 
class GFG{
   
// Function that finds the longest
// arithmetic subsequence having the
// same absolute difference
static int lenghtOfLongestAP(int []A, int n)
{
   
    // Stores the length of sequences
    // having same difference
    Dictionary> dp = new Dictionary>();
   
    // Stores the resultant length
    int res = 2;
  
    // Iterate over the array
    for(int i = 0; i < n; ++i)
    {
        for(int j = i + 1; j < n; ++j)
        {
            int d = A[j] - A[i];
  
            // Update length of subsequence
            if (dp.ContainsKey(d))
            {
                 if (dp[d].ContainsKey(i))
                {
                    dp[d][j] = dp[d][i] + 1;   
                }
                else
                {
                    dp[d][j] = 2;
                }
            }
            else
            {
                dp[d] = new Dictionary();
                dp[d][j] = 2;
            }
            res = Math.Max(res, dp[d][j]);
        }
    }
  
    // Return res
    return res;
}
   
// Driver Code
public static void Main(string[] args)
{
   
    // Given array arr[]
    int []arr = { 20, 1, 15, 3, 10, 5, 8 };
  
    int N = arr.Length;
  
    // Function call
    Console.Write(lenghtOfLongestAP(arr, N));
}
}
 
// This code is contributed by rutvik_56

输出： 
4

时间复杂度： O(N 2 )
辅助空间： O(N 2 )