Count of AP (Arithmetic Progression) Subsequences in an array

Last Updated : 15 Nov, 2024

Given an array arr[] of n positive integers. The task is to count the number of Arithmetic Progression subsequences in the array.
Note: Empty sequence or single element sequence is Arithmetic Progression.

Examples:

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

Input: arr[] = [10, 20]
Output: 4
Explanation: Arithmetic Progression subsequence from the given array are: [], [10], [20], [10, 20].

Table of Content

Using Recursion – O(2^n) Time and O(n) Space

For the recursive approach, the problem involves counting arithmetic subsequences with a certain difference. At each step, the number of available elements decreases by 1. Consider the current element as part of the arithmetic subsequence. In this case, the difference between the current element and the previous element is passed to the recursive call. Alternatively, skip the current element, and the sequence continues without including it.

Base case:

if idx == n, return 1 (meaning all elements have been processed)

Mathematically, the recurrence relation looks like this:

numberOfAP(arr, n, idx, pre, count, diff) = numberOfAP(arr, n, idx + 1, idx, count + 1, arr[idx] – arr[pre]) OR
numberOfAP(arr, n, idx + 1, pre, count, diff)

C++

// C++ Code for count of AP // Subsequences using Recursion #include <bits/stdc++.h> using namespace std;  // Recursive function to count all  // arithmetic subsequences int numberOfAP(vector<int>& arr, int n, int idx,                 int pre, int count, int diff) {        int ans = 0;      // Base case: if we've processed all elements     if (idx == n) {         return 1;     }      // If we have picked one element but      // no difference set yet     if (pre != -1 && diff == INT_MIN) {                // Pick the current element and         // set the difference         ans += numberOfAP(arr, n, idx + 1, idx,                            count + 1, arr[idx] - arr[pre]);     }       // First element or continuation of      // an AP with the same difference     if (pre == -1 || diff == arr[idx] - arr[pre]) {                // Pick the current element to extend the AP         ans += numberOfAP(arr, n, idx + 1,                            idx, count + 1, diff);     }      // Skip the current element     ans += numberOfAP(arr, n, idx + 1, pre, count, diff);      return ans; }  // Wrapper function to start the recursion int count(vector<int>& arr) {     int n = arr.size();     return numberOfAP(arr, n, 0, -1, 0, INT_MIN); }  int main() {      vector<int> arr = {1, 2, 3};       cout << count(arr);     return 0; }

Java

// Java Code for count of AP // Subsequences using Recursion import java.util.*;  class GfG {      // Recursive function to count all     // arithmetic subsequences     static int numberOfAP(List<Integer> arr, int n, int idx,                             int pre, int count, int diff) {          int ans = 0;          // Base case: if we've processed all elements         if (idx == n) {             return 1;         }          // If we have picked one element but         // no difference set yet         if (pre != -1 && diff == Integer.MIN_VALUE) {              // Pick the current element and             // set the difference             ans += numberOfAP(arr, n, idx + 1, idx,                                count + 1, arr.get(idx) - arr.get(pre));         }          // First element or continuation of         // an AP with the same difference         if (pre == -1 || diff == arr.get(idx) - arr.get(pre)) {              // Pick the current element to extend the AP             ans += numberOfAP(arr, n, idx + 1,                                idx, count + 1, diff);         }          // Skip the current element         ans += numberOfAP(arr, n, idx + 1, pre, count, diff);          return ans;     }      // Wrapper function to start the recursion     static int count(List<Integer> arr) {         int n = arr.size();         return numberOfAP(arr, n, 0, -1, 0, Integer.MIN_VALUE);     }      public static void main(String[] args) {          List<Integer> arr = Arrays.asList(1, 2, 3);                System.out.println(count(arr));     } }

Python

# Python Code for count of AP # Subsequences using Recursion import sys  # Recursive function to count all  # arithmetic subsequences def number_of_AP(arr, n, idx, pre, count, diff):          ans = 0      # Base case: if we've processed all elements     if idx == n:         return 1      # If we have picked one element but      # no difference set yet     if pre != -1 and diff == float('-inf'):                  # Pick the current element and          # set the difference         ans += number_of_AP(arr, n, idx + 1, idx,                              count + 1, arr[idx] - arr[pre])      # First element or continuation of      # an AP with the same difference     if pre == -1 or diff == arr[idx] - arr[pre]:                  # Pick the current element to extend the AP         ans += number_of_AP(arr, n, idx + 1,                              idx, count + 1, diff)      # Skip the current element     ans += number_of_AP(arr, n, idx + 1, pre, count, diff)      return ans  # Wrapper function to start the recursion def count(arr):     n = len(arr)     return number_of_AP(arr, n, 0, -1, 0, float('-inf'))  if __name__ == "__main__":      arr = [1, 2, 3]      print(count(arr))

// C# Code for count of AP // Subsequences using Recursion using System; using System.Collections.Generic;  class GfG {      // Recursive function to count all      // arithmetic subsequences     static int NumberOfAP(List<int> arr, int n, int idx,                                   int pre, int count, int diff) {          int ans = 0;          // Base case: if we've processed all elements         if (idx == n) {             return 1;         }          // If we have picked one element but          // no difference set yet         if (pre != -1 && diff == int.MinValue) {                          // Pick the current element and              // set the difference             ans += NumberOfAP(arr, n, idx + 1, idx,                                count + 1, arr[idx] - arr[pre]);         }          // First element or continuation of          // an AP with the same difference         if (pre == -1 || diff == arr[idx] - arr[pre]) {                          // Pick the current element to extend the AP             ans += NumberOfAP(arr, n, idx + 1, idx, count + 1, diff);         }          // Skip the current element         ans += NumberOfAP(arr, n, idx + 1, pre, count, diff);          return ans;     }      // Wrapper function to start the recursion     static int Count(List<int> arr) {         int n = arr.Count;         return NumberOfAP(arr, n, 0, -1, 0, int.MinValue);     }      static void Main(string[] args) {                  List<int> arr = new List<int> {1, 2, 3};          Console.WriteLine(Count(arr));     } }

JavaScript

// JavaScript Code for count of AP // Subsequences using Recursion  // Recursive function to count all  // arithmetic subsequences function numberOfAP(arr, n, idx, pre, count, diff) {     let ans = 0;      // Base case: if we've processed all elements     if (idx === n) {         return 1;     }      // If we have picked one element but      // no difference set yet     if (pre !== -1 && diff === Number.MIN_SAFE_INTEGER) {                  // Pick the current element and          // set the difference         ans += numberOfAP(arr, n, idx + 1, idx,                            count + 1, arr[idx] - arr[pre]);     }      // First element or continuation of      // an AP with the same difference     if (pre === -1 || diff === arr[idx] - arr[pre]) {                  // Pick the current element to extend the AP         ans += numberOfAP(arr, n, idx + 1, idx, count + 1, diff);     }      // Skip the current element     ans += numberOfAP(arr, n, idx + 1, pre, count, diff);      return ans; }  // Wrapper function to start the recursion function countAP(arr) {     const n = arr.length;     return numberOfAP(arr, n, 0, -1, 0, Number.MIN_SAFE_INTEGER); }  const arr = [1, 2, 3]; console.log(countAP(arr));

Output

Using Top-Down DP (Memoization) – O(n^2) Time and O(n^2) Space

1. Optimal Substructure:

The solution to count all arithmetic subsequences can be constructed from optimal solutions to subproblems.

If pre != -1 and diff == INT_MIN, we are setting the difference between the current element and the previous element. Once this difference is established, we continue checking if the current element extends the arithmetic progression.
If pre == -1, this means we are at the beginning of the subsequence, and we can freely start the subsequence with the current element.
If diff == arr[idx] – arr[pre], then the current element fits into the existing arithmetic progression, so we continue the progression by including the current element.
2. Overlapping Subproblems:

Recursive calls for counting AP subsequences involve recalculating the same state multiple times. To avoid recomputation, we use memoization with a unique key for each state. This approach reduces redundant calculations by storing results in memo. For instance, numberOfAP reuses previously computed results whenever it encounters the same key.

The memoization key for each state is:

key = to_string(idx) + “_” + to_string(pre) + “_” + to_string(count) + “_” + to_string(diff)

The memoization relation then becomes:

memo[key] = numberOfAP(arr, n, idx + 1, idx, count + 1, arr[idx] – arr[pre], memo
+ numberOfAP(arr, n, idx + 1, idx, count + 1, diff, memo) +
+ numberOfAP(arr, n, idx + 1, pre, count, diff, memo)

C++

// C++ Code for count of AP // Subsequences using Memoization #include <bits/stdc++.h> using namespace std;  // Recursive function to count all  // arithmetic subsequences with memoization int numberOfAP(vector<int>& arr, int n, int idx,                 int pre, int count, int diff,                 unordered_map<string, int>& memo) {      // Base case: if we've processed all elements     if (idx == n) {         return 1;     }      // Create a unique key for the current state     string key = to_string(idx) + "_" + to_string(pre) + "_" +                   to_string(count) + "_" + to_string(diff);      // Check if the result is already memoized     if (memo.find(key) != memo.end()) {         return memo[key];     }      int ans = 0;      // If we have picked one element but      // no difference set yet     if (pre != -1 && diff == INT_MIN) {                  // Pick the current element and          // set the difference         ans += numberOfAP(arr, n, idx + 1, idx,                            count + 1, arr[idx] - arr[pre], memo);     }      // First element or continuation of      // an AP with the same difference     if (pre == -1 || diff == arr[idx] - arr[pre]) {                  // Pick the current element to extend the AP         ans += numberOfAP(arr, n, idx + 1,                            idx, count + 1, diff, memo);     }      // Skip the current element     ans += numberOfAP(arr, n, idx + 1, pre, count, diff, memo);      // Store the result in the memo map     memo[key] = ans;      return ans; }  // Wrapper function to start the recursion int count(vector<int>& arr) {     int n = arr.size();     unordered_map<string, int> memo;      return numberOfAP(arr, n, 0, -1, 0, INT_MIN, memo); }  int main() {        vector<int> arr = {1, 2, 3};       cout << count(arr);     return 0; }

Java

// Java Code for count of AP // Subsequences using Memoization import java.util.ArrayList; import java.util.HashMap;  class GfG {      // Recursive function to count all      // arithmetic subsequences with memoization     static int numberOfAP(ArrayList<Integer> arr, int n, int idx,                                    int pre, int count, int diff,                                    HashMap<String, Integer> memo) {          // Base case: if we've processed all elements         if (idx == n) {             return 1;         }          // Create a unique key for the current state         String key = idx + "_" + pre + "_" + count + "_" + diff;          // Check if the result is already memoized         if (memo.containsKey(key)) {             return memo.get(key);         }          int ans = 0;          // If we have picked one element but          // no difference set yet         if (pre != -1 && diff == Integer.MIN_VALUE) {                          // Pick the current element and              // set the difference             ans += numberOfAP(arr, n, idx + 1, idx,                                count + 1, arr.get(idx) - arr.get(pre), memo);         }          // First element or continuation of          // an AP with the same difference         if (pre == -1 || diff == arr.get(idx) - arr.get(pre)) {                          // Pick the current element to extend the AP             ans += numberOfAP(arr, n, idx + 1, idx, count + 1, diff, memo);         }          // Skip the current element         ans += numberOfAP(arr, n, idx + 1, pre, count, diff, memo);          // Store the result in the memo map         memo.put(key, ans);          return ans;     }      // Wrapper function to start the recursion     static int count(ArrayList<Integer> arr) {         int n = arr.size();         HashMap<String, Integer> memo = new HashMap<>();         return numberOfAP(arr, n, 0, -1, 0, Integer.MIN_VALUE, memo);     }      public static void main(String[] args) {          ArrayList<Integer> arr = new ArrayList<>();         arr.add(1);         arr.add(2);         arr.add(3);          System.out.println(count(arr));     } }

Python

# Python Code for count of AP # Subsequences using Memoization def numberOfAP(arr, n, idx, pre, count, diff, memo):      # Base case: if we've processed all elements     if idx == n:         return 1      # Create a unique key for the current state     key = f"{idx}_{pre}_{count}_{diff}"      # Check if the result is already memoized     if key in memo:         return memo[key]      ans = 0      # If we have picked one element but      # no difference set yet     if pre != -1 and diff == float('-inf'):                  # Pick the current element and          # set the difference         ans += numberOfAP(arr, n, idx + 1, idx,                            count + 1, arr[idx] - arr[pre], memo)      # First element or continuation of      # an AP with the same difference     if pre == -1 or diff == arr[idx] - arr[pre]:                  # Pick the current element to extend the AP         ans += numberOfAP(arr, n, idx + 1,                            idx, count + 1, diff, memo)      # Skip the current element     ans += numberOfAP(arr, n, idx + 1, pre, count, diff, memo)      # Store the result in the memo map     memo[key] = ans      return ans  # Wrapper function to start the recursion def count(arr):     memo = {}      return numberOfAP(arr, len(arr), 0, -1, 0, float('-inf'), memo)  if __name__ == "__main__":      arr = [1, 2, 3]      print(count(arr))

// C# Code for count of AP // Subsequences using Memoization using System; using System.Collections.Generic;  class GfG {        // Recursive function to count all      // arithmetic subsequences with memoization     static int NumberOfAP(List<int> arr, int n, int idx,                  int pre, int count, int diff,                          Dictionary<string, int> memo) {                // Base case: if we've processed all elements         if (idx == n) {             return 1;         }          // Create a unique key for the current state         string key = idx + "_" + pre + "_" + count + "_" + diff;          // Check if the result is already memoized         if (memo.ContainsKey(key)) {             return memo[key];         }          int ans = 0;          // If we have picked one element but no        	// difference set yet         if (pre != -1 && diff == int.MinValue) {                        // Pick the current element and set the difference             ans += NumberOfAP(arr, n, idx + 1,                        idx, count + 1, arr[idx] - arr[pre], memo);         }          // First element or continuation of an          // AP with the same difference         if (pre == -1 || diff == arr[idx] - arr[pre]) {                        // Pick the current element to extend the AP             ans += NumberOfAP(arr, n, idx + 1,                         idx, count + 1, diff, memo);         }          // Skip the current element         ans += NumberOfAP(arr, n, idx + 1,                          pre, count, diff, memo);          // Store the result in the memo map         memo[key] = ans;          return ans;     }      // Wrapper function to start the recursion     static int Count(List<int> arr) {         var memo = new Dictionary<string, int>();          return NumberOfAP(arr, arr.Count, 0, -1,                             0, int.MinValue, memo);     }      static void Main() {                List<int> arr = new List<int> { 1, 2, 3 };         Console.WriteLine(Count(arr));     } }

JavaScript

// Javascript Code for count of AP // Subsequences using Memoization  // Recursive function to count all arithmetic  // subsequences with memoization function numberOfAP(arr, n, idx, pre, count, diff, memo) {      // Base case: if we've processed all elements     if (idx === n) {         return 1;     }      // Create a unique key for the current state     const key = idx + "_" + pre + "_" + count + "_" + diff;      // Check if the result is already memoized     if (memo.has(key)) {         return memo.get(key);     }      let ans = 0;      // If we have picked one element but      // no difference set yet     if (pre !== -1 && diff === Number.MIN_SAFE_INTEGER) {          // Pick the current element and set the difference         ans += numberOfAP(arr, n, idx + 1, idx,         count + 1, arr[idx] - arr[pre], memo);     }      // First element or continuation of an      // AP with the same difference     if (pre === -1 || diff === arr[idx] - arr[pre]) {              // Pick the current element to extend the AP         ans += numberOfAP(arr, n, idx + 1, idx,         count + 1, diff, memo);     }      // Skip the current element     ans += numberOfAP(arr, n, idx + 1, pre,     				  count, diff, memo);      // Store the result in the memo map     memo.set(key, ans);      return ans; }  // Wrapper function to start the recursion function count(arr) {     const memo = new Map();     return numberOfAP(arr, arr.length, 0, -1, 0,              Number.MIN_SAFE_INTEGER, memo); }  const arr = [1, 2, 3]; console.log(count(arr));

Output

Using Bottom-Up DP (Tabulation) – O(n^2) Time and O(n^2) Space

We create a 2D table dp of size(n) where each dp[i] is a map (hash table) storing the count of subsequences ending at index i for each common difference. The keys of the map are the common differences (diff), and the values are the counts of subsequences that end at arr[i] with that particular common difference (diff).

dp[i]: Represents the number of subsequences ending at index i with common difference diff.
Base Case: Each element itself is an arithmetic subsequence of length 1.
For each pair of indices (i, j) where i > j: Calculate the common difference diff = arr[i] – arr[j].

If subsequences with this diff exist at arr[j], extend them by adding arr[i].
If no such subsequences exist at arr[j], start a new subsequence with (arr[j], arr[i]).

The total number of arithmetic subsequences will be the sum of all values in all maps at all indices i, i.e., sum(dp[i]) for all i and diff.

C++

// C++ code to count the number of AP // subsequences using Tabulation #include <bits/stdc++.h> using namespace std;  // Function to count all AP subsequences using DP int count(vector<int>& arr) {     int n = arr.size();     if (n == 0) return 0;      // Total number of AP subsequences     int count = n + 1;        // DP map to store subsequences ending at      // each element with specific common differences     vector<unordered_map<int, int>> dp(n);      // Traverse through each pair to populate dp table     for (int i = 0; i < n; i++) {         for (int j = 0; j < i; j++) {                        // Calculate the common difference for           	// the current pair             int diff = arr[i] - arr[j];              // Get the count of subsequences with the              // same difference ending at j             int countj = dp[j].count(diff) ? dp[j][diff] : 0;              // Update the count of subsequences with              // this difference ending at i             dp[i][diff] += countj + 1;              // Add the count of new subsequences            	// to the total             count += countj + 1;         }     }     return count; }  int main() {        vector<int> arr = {1, 2, 3};     cout << count(arr);     return 0; }

Java

// Java code to count the number of AP // subsequences using Tabulation import java.util.HashMap; import java.util.Map; import java.util.ArrayList;  class GfG {      // Function to count all AP subsequences using DP     static int count(ArrayList<Integer> arr) {         int n = arr.size();         if (n == 0) return 0;          // Total number of AP subsequences         int count = n + 1;          // DP map to store subsequences ending at          // each element with specific common differences         Map<Integer, Integer>[] dp = new HashMap[n];         for (int i = 0; i < n; i++) {             dp[i] = new HashMap<>();         }          // Traverse through each pair to populate dp table         for (int i = 0; i < n; i++) {             for (int j = 0; j < i; j++) {                  // Calculate the common difference               	// for the current pair                 int diff = arr.get(i) - arr.get(j);                  // Get the count of subsequences with the                  // same difference ending at j                 int countj = dp[j].getOrDefault(diff, 0);                  // Update the count of subsequences with                  // this difference ending at i                 dp[i].put(diff, dp[i].getOrDefault(diff, 0) + countj + 1);                  // Add the count of new subsequences to the total                 count += countj + 1;             }         }         return count;     }      public static void main(String[] args) {          ArrayList<Integer> arr = new ArrayList<>();         arr.add(1);         arr.add(2);         arr.add(3);         System.out.println(count(arr));     } }

Python

# Python code to count the number of AP # subsequences using Tabulation from collections import defaultdict  # Function to count all AP subsequences using DP def count(arr):     n = len(arr)     if n == 0:         return 0      # Total number of AP subsequences     count = n + 1      # DP dictionary to store subsequences ending at      # each element with specific common differences     dp = [defaultdict(int) for _ in range(n)]      # Traverse through each pair to populate dp table     for i in range(n):         for j in range(i):              # Calculate the common difference              # for the current pair             diff = arr[i] - arr[j]              # Get the count of subsequences with the              # same difference ending at j             countj = dp[j][diff]              # Update the count of subsequences with              # this difference ending at i             dp[i][diff] += countj + 1              # Add the count of new subsequences             # to the total             count += countj + 1      return count  if __name__ == "__main__":        arr = [1, 2, 3]     print(count(arr))

// C# code to count the number of AP // subsequences using Tabulation using System; using System.Collections.Generic;  class GfG {      // Function to count all AP subsequences using DP     static int Count(List<int> arr) {         int n = arr.Count;         if (n == 0) return 0;          // Total number of AP subsequences         int count = n + 1;          // DP map to store subsequences ending at          // each element with specific common differences         var dp = new Dictionary<int, int>[n];         for (int i = 0; i < n; i++) {             dp[i] = new Dictionary<int, int>();         }          // Traverse through each pair to populate dp table         for (int i = 0; i < n; i++) {             for (int j = 0; j < i; j++) {                  // Calculate the common difference               	// for the current pair                 int diff = arr[i] - arr[j];                  // Get the count of subsequences with the                  // same difference ending at j                 int countj = dp[j].ContainsKey(diff) ? dp[j][diff] : 0;                  // Update the count of subsequences with                  // this difference ending at i                 if (dp[i].ContainsKey(diff))                     dp[i][diff] += countj + 1;                 else                     dp[i][diff] = countj + 1;                  // Add the count of new subsequences               	// to the total                 count += countj + 1;             }         }         return count;     }      static void Main() {                  List<int> arr = new List<int> { 1, 2, 3 };         Console.WriteLine(Count(arr));     } }

JavaScript

// Javascript code to count the number of AP // subsequences using Tabulation  // Function to count all AP subsequences using DP function count(arr) {     const n = arr.length;     if (n === 0) return 0;      // Total number of AP subsequences     let count = n + 1;      // DP map to store subsequences ending at      // each element with specific common differences     const dp = Array.from({ length: n }, () => new Map());      // Traverse through each pair to populate dp table     for (let i = 0; i < n; i++) {         for (let j = 0; j < i; j++) {              // Calculate the common difference for             // the current pair             const diff = arr[i] - arr[j];              // Get the count of subsequences with the              // same difference ending at j             const countj = dp[j].get(diff) || 0;              // Update the count of subsequences with              // this difference ending at i             dp[i].set(diff, (dp[i].get(diff) || 0) + countj + 1);              // Add the count of new subsequences to the total             count += countj + 1;         }     }     return count; }  const arr = [1, 2, 3]; console.log(count(arr));

Output

Using Space Optimized DP – **O(n*(max – min)) Time and** O(n + max) Space

Since empty sequence and single element sequence is also arithmetic progression, so we initialize the answer with n(number of element in the array) + 1.
Now, we need to find the arithmetic progression subsequence of length greater than or equal to 2. Let minimum and maximum of the array be minarr and maxarr respectively. Observe, in all the arithmetic progression subsequences, the range of common difference will be from (minarr – maxarr) to (maxarr – minarr). Now, for each common difference, say d, calculate the subsequence of length greater than or equal to 2 using dynamic programming.

The number of subsequence of length greater than or equal to 2 with common difference d is sum of dp[i] – 1, 0 <= i = 2 with difference d. To speed up, store the sum of dp[j] with arr[j] + d = arr[i] and j < i.

C++

// C++ program to find number of AP // subsequences in the given array #include <bits/stdc++.h> using namespace std;  // Function to count the number of AP subsequences int count(vector<int>& arr) {     int n = arr.size();         int minarr = INT_MAX;     int maxarr = INT_MIN;      // Finding the minimum and maximum value of the array.     for (int i = 0; i < n; i++) {         minarr = min(minarr, arr[i]);         maxarr = max(maxarr, arr[i]);     }      // dp[i] is going to store the count of     // APs ending with arr[i].     // sum[j] is going to store the sum of      // all dp[]'s with j as an AP element.     vector<int> dp(n, 0);     vector<int> sum(1000001, 0);      int ans = n + 1;      // Traversing with all common differences.     for (int d = (minarr - maxarr); d <= (maxarr - minarr); d++) {         fill(sum.begin(), sum.end(), 0);          // Traversing all the elements 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 arr[i] is the last element.             // We consider all APs where an array element              // is the previous element of the AP             // with a particular difference.             if (arr[i] - d >= 1 && arr[i] - d <= 1000000) {                 dp[i] += sum[arr[i] - d];             }              ans += dp[i] - 1;             sum[arr[i]] += dp[i];         }     }      return ans; }  int main() {        vector<int> arr = {1, 2, 3};         cout << count(arr) << endl;     return 0; }

Java

// Java program to find number of AP // subsequences in the given array import java.util.ArrayList; import java.util.Arrays;  class GfG {      static int count(ArrayList<Integer> arr) {         int n = arr.size();                  // initializing the minimum value and         // maximum value of the array.         int minarr = Integer.MAX_VALUE;         int maxarr = Integer.MIN_VALUE;          // Finding the minimum and maximum         // value of the array.         for (int i = 0; i < n; i++) {             minarr = Math.min(minarr, arr.get(i));             maxarr = Math.max(maxarr, arr.get(i));         }          // dp[i] is going to store count of          // APs ending with arr[i].         // sum[j] is going to store sum of          // all dp[]'s with j as an AP element.         int[] dp = new int[n];         int[] sum = new int[1000001];          // 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 elements              // 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 arr[i]                  // is last element.                 // We consider all APs where                  // an array element is previous                  // element of AP with a particular                 // difference                 if (arr.get(i) - d >= 1 &&                               arr.get(i) - d <= 1000000)                     dp[i] += sum[arr.get(i) - d];                  ans += dp[i] - 1;                 sum[arr.get(i)] += dp[i];             }         }          return ans;     }      public static void main(String[] args) {                ArrayList<Integer> arr            = new ArrayList<>(Arrays.asList(1, 2, 3));                  System.out.println(count(arr));     } }

Python

# Python program to find number of AP # subsequences in the given array  def count(arr):      n = len(arr)      # initializing the minimum value and     # maximum value of the array.     minarr = +2147483647     maxarr = -2147483648      # Finding the minimum and      # maximum value of the array.     for i in range(n):         minarr = min(minarr, arr[i])         maxarr = max(maxarr, arr[i])           # dp[i] is going to store count of APs ending     # with arr[i].     # sum[j] is going to store sum 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(1000001 + 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 arr[i] is last element.              # We consider all APs where an array element             # is previous element of AP with a particular              # difference             if (arr[i] - d >= 1 and arr[i] - d <= 1000000):                 dp[i] += sum[arr[i] - d]              ans += dp[i] - 1             sum[arr[i]] += dp[i]      return ans  if __name__ == "__main__":        arr = [1, 2, 3]      print(count(arr))

// C# program to find number of AP // subsequences in the given array using System; using System.Collections.Generic;  class GfG {      // Function to find number of AP     // subsequences in the given array     static int count(List<int> arr) {                  int n = arr.Count;                 // initializing the minimum value and         // maximum value of the array.         int minarr = +2147483647;         int maxarr = -2147483648;         int i;                  // Finding the minimum and maximum         // value of the array.         for (i = 0; i < n; i++)  {             minarr = Math.Min(minarr, arr[i]);             maxarr = Math.Max(maxarr, arr[i]);         }          // dp[i] is going to store count of          // APs ending with arr[i].         // sum[j] is going to store sum of          // all dp[]'s with j as an AP element.         int[] dp = new int[n];         int[] sum = new int[1000001];          // 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 < sum.Length; 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 arr[i]                  // is last element.                 // We consider all APs where                  // an array element is previous                  // element of AP with a particular                 // difference                 if (arr[i] - d >= 1 &&                      arr[i] - d <= 1000000)                     dp[i] += sum[arr[i] - d];                  ans += dp[i] - 1;                 sum[arr[i]] += dp[i];             }         }          return ans;     }          static void Main() {                List<int> arr = new List<int> {1, 2, 3};                  Console.WriteLine(count(arr));     } }

JavaScript

// JavaScript program to find the number of AP // subsequences in the given array  function count(arr) {      // Initialize the minimum and maximum      // values of the array.     let minarr = +2147483647;     let maxarr = -2147483648;      // Finding the minimum and maximum values of the array.     for (let i = 0; i < arr.length; i++) {         minarr = Math.min(minarr, arr[i]);         maxarr = Math.max(maxarr, arr[i]);     }      // dp[i] stores the count of APs ending with arr[i].     // sum[j] stores the sum of all dp[]'s with j as an AP element.     let dp = new Array(arr.length);     let sum = new Array(1000001);      // Initialize answer with arr.length + 1, as single      // elements and an empty array are also APs.     let ans = arr.length + 1;      // Traversing all possible common differences.     for (let d = minarr - maxarr; d <= maxarr - minarr; d++) {         sum.fill(0);          // Traverse each element of the array.         for (let i = 0; i < arr.length; i++) {                      // Initialize dp[i] = 1.             dp[i] = 1;              // Add counts of APs with the given difference              // and arr[i] as the last element.             // We consider all APs where a previous array              // element is part of an AP with the same difference.             if (arr[i] - d >= 1 && arr[i] - d <= 1000000) {                 dp[i] += sum[arr[i] - d];             }              ans += dp[i] - 1;             sum[arr[i]] += dp[i];         }     }      return ans; }  let arr = [1, 2, 3]; console.log(count(arr));

Output

Introduction to Dynamic Programming on Trees

Anuj Chauhan

Improve

Article Tags :

Practice Tags :

Dynamic Programming

Count of AP (Arithmetic Progression) Subsequences in an array

Using Recursion – O(2^n) Time and O(n) Space

Using Top-Down DP (Memoization) – O(n^2) Time and O(n^2) Space

Using Bottom-Up DP (Tabulation) – O(n^2) Time and O(n^2) Space

Using Space Optimized DP – O(n*(max – min)) Time and O(n + max) Space

Similar Reads

Advanced Topics

Easy problems in Dynamic programming

Medium problems on Dynamic programming

Using Space Optimized DP – **O(n*(max – min)) Time and** O(n + max) Space