数组中的AP(算术级数)子序列的计数

给定n个正整数数组。任务是计算数组中算术级数子序列的数量。注意：空序列或单元素序列为算术级数。 1 <= arr [i] <=1000000。例如：

Input : arr[] = { 1, 2, 3 }
Output : 8
Arithmetic Progression subsequence from the 
given array are: {}, { 1 }, { 2 }, { 3 }, { 1, 2 },
{ 2, 3 }, { 1, 3 }, { 1, 2, 3 }.

Input : arr[] = { 10, 20, 30, 45 }
Output : 12

Input : arr[] = { 1, 2, 3, 4, 5 }
Output : 23

由于空序列和单元素序列也是算术级数，因此我们用n(数组中元素的数量)+ 1来初始化答案。
现在，我们需要找到长度大于或等于2的算术级数子序列。令数组的最小值和最大值分别为minarr和maxarr。请注意，在所有算术级数子序列中，共同差异的范围是(minarr-maxarr)至(maxarr-minarr)。现在，对于每个共同的差异，例如d，使用动态编程计算长度大于或等于2的子序列。
令dp [i]为以arr [i]结尾并具有d的共同差的子序列数。所以，

长度等于或大于2且具有共同差d的子序列数为dp [i] – 1的总和，0 <= i = 2且具有差d。为了加快速度，将dp [j]的总和存储为arr [j] + d = arr [i]且j

C++

// C++ program to find number of AP
// subsequences in the given array
#include
#define MAX 1000001
using namespace std;
  
int numofAP(int a[], int n)
{
    // initializing the minimum value and
    // maximum value of the array.
    int minarr = INT_MAX, maxarr = INT_MIN;
  
    // Finding the minimum and maximum
    // value of the array.
    for (int i = 0; i < n; i++)
    {
        minarr = min(minarr, a[i]);
        maxarr = max(maxarr, a[i]);
    }
  
    // dp[i] is going to store count of APs ending
    // with arr[i].
    // sum[j] is going to store sun of all dp[]'s
    // with j as an AP element.
    int dp[n], sum[MAX];
  
    // Initialize answer with n + 1 as single elements
    // and empty array are also DP.
    int ans = n + 1;
  
    // Traversing with all common difference.
    for (int d=(minarr-maxarr); d<=(maxarr-minarr); d++)
    {
        memset(sum, 0, sizeof sum);
  
        // Traversing all the element of the array.
        for (int i = 0; i < n; i++)
        {
            // Initialize dp[i] = 1.
            dp[i] = 1;
  
            // Adding counts of APs with given differences
            // and a[i] is last element.  
            // We consider all APs where an array element
            // is previous element of AP with a particular 
            // difference
            if (a[i] - d >= 1 && a[i] - d <= 1000000)
                dp[i] += sum[a[i] - d];
  
            ans += dp[i] - 1;
            sum[a[i]] += dp[i];
        }
    }
  
    return ans;
}
  
// Driver code
int main()
{
    int arr[] = { 1, 2, 3 };
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << numofAP(arr, n) << endl;
    return 0;
}

Java

// Java program to find number of AP
// subsequences in the given array
import java.util.Arrays;
  
class GFG {
      
    static final int MAX = 1000001;
  
    static int numofAP(int a[], int n)
    {
          
        // initializing the minimum value and
        // maximum value of the array.
        int minarr = [phone];
        int maxarr = -2147483648;
  
        // Finding the minimum and maximum
        // value of the array.
        for (int i = 0; i < n; i++) {
            minarr = Math.min(minarr, a[i]);
            maxarr = Math.max(maxarr, a[i]);
        }
  
        // dp[i] is going to store count of 
        // APs ending with arr[i].
        // sum[j] is going to store sun of 
        // all dp[]'s with j as an AP element.
        int dp[] = new int[n];
        int sum[] = new int[MAX];
  
        // Initialize answer with n + 1 as 
        // single elements and empty array 
        // are also DP.
        int ans = n + 1;
  
        // Traversing with all common 
        // difference.
        for (int d = (minarr - maxarr); 
                d <= (maxarr - minarr); d++) 
        {
            Arrays.fill(sum, 0);
  
            // Traversing all the element 
            // of the array.
            for (int i = 0; i < n; i++) {
                  
                // Initialize dp[i] = 1.
                dp[i] = 1;
  
                // Adding counts of APs with
                // given differences and a[i] 
                // is last element.
                // We consider all APs where 
                // an array element is previous 
                // element of AP with a particular
                // difference
                if (a[i] - d >= 1 && 
                             a[i] - d <= 1000000)
                    dp[i] += sum[a[i] - d];
  
                ans += dp[i] - 1;
                sum[a[i]] += dp[i];
            }
        }
  
        return ans;
    }
      
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 3 };
        int n = arr.length;
          
        System.out.println(numofAP(arr, n));
    }
}
  
// This code is contributed by Anant Agarwal.

Python3

# Python program to find number of AP
# subsequences in the given array
  
MAX = 1000001
  
def numofAP(a, n):
  
    # initializing the minimum value and
    # maximum value of the array.
    minarr = [phone]
    maxarr = -2147483648
  
    # Finding the minimum and 
    # maximum value of the array.
    for i in range(n):
        minarr = min(minarr, a[i])
        maxarr = max(maxarr, a[i])
      
  
    # dp[i] is going to store count of APs ending
    # with arr[i].
    # sum[j] is going to store sun of all dp[]'s
    # with j as an AP element.
    dp = [0 for i in range(n + 1)]
      
  
    # Initialize answer with n + 1 as single 
    # elements and empty array are also DP.
    ans = n + 1
  
    # Traversing with all common difference.
    for d in range((minarr - maxarr), (maxarr - minarr) + 1):
        sum = [0 for i in range(MAX + 1)]
          
        # Traversing all the element of the array.
        for i in range(n):
          
            # Initialize dp[i] = 1.
            dp[i] = 1
  
            # Adding counts of APs with given differences
            # and a[i] is last element. 
            # We consider all APs where an array element
            # is previous element of AP with a particular 
            # difference
            if (a[i] - d >= 1 and a[i] - d <= 1000000):
                dp[i] += sum[a[i] - d]
  
            ans += dp[i] - 1
            sum[a[i]] += dp[i]
  
    return ans
  
# Driver code
arr = [ 1, 2, 3 ]
n = len(arr)
  
print(numofAP(arr, n))
  
# This code is contributed by Anant Agarwal.

C#

// C# program to find number of AP
// subsequences in the given array
using System;
  
class GFG {
      
    static int MAX = 1000001;
  
    // Function to find number of AP
    // subsequences in the given array
    static int numofAP(int []a, int n)
    {
          
        // initializing the minimum value and
        // maximum value of the array.
        int minarr = [phone];
        int maxarr = -2147483648;
        int i;
          
        // Finding the minimum and maximum
        // value of the array.
        for (i = 0; i < n; i++) 
        {
            minarr = Math.Min(minarr, a[i]);
            maxarr = Math.Max(maxarr, a[i]);
        }
  
        // dp[i] is going to store count of 
        // APs ending with arr[i].
        // sum[j] is going to store sun of 
        // all dp[]'s with j as an AP element.
        int []dp = new int[n];
        int []sum = new int[MAX];
  
        // Initialize answer with n + 1 as 
        // single elements and empty array 
        // are also DP.
        int ans = n + 1;
  
        // Traversing with all common 
        // difference.
        for (int d = (minarr - maxarr); 
                 d <= (maxarr - minarr); d++) 
        {
              
            for(i = 0; i < MAX; i++)
            sum[i]= 0;
          
            // Traversing all the element 
            // of the array.
            for ( i = 0; i < n; i++)
            {
                  
                // Initialize dp[i] = 1.
                dp[i] = 1;
  
                // Adding counts of APs with
                // given differences and a[i] 
                // is last element.
                // We consider all APs where 
                // an array element is previous 
                // element of AP with a particular
                // difference
                if (a[i] - d >= 1 && 
                    a[i] - d <= 1000000)
                    dp[i] += sum[a[i] - d];
  
                ans += dp[i] - 1;
                sum[a[i]] += dp[i];
            }
        }
  
        return ans;
    }
      
    // Driver code
    public static void Main()
    {
        int []arr = {1, 2, 3};
        int n = arr.Length;
          
        Console.WriteLine(numofAP(arr, n));
    }
}
  
// This code is contributed by vt_m.

输出 ：

8