# Length of longest increasing index dividing subsequence

• Difficulty Level : Expert
• Last Updated : 16 Apr, 2021

Given an array arr[] of size N, the task is to find the longest increasing sub-sequence such that index of any element is divisible by index of previous element (LIIDS). The following are the necessary conditions for the LIIDS:
If i, j are two indices in the given array. Then:

• i < j
• j % i = 0
• arr[i] < arr[j]

Examples:

Input: arr[] = {1, 2, 3, 7, 9, 10}
Output:
Explanation:
The subsequence = {1, 2, 7}
Indices of the elements of sub-sequence = {1, 2, 4}
Indices condition:
2 is divisible by 1
4 is divisible by 2
OR
Another possible sub-sequence = {1, 3, 10}
Indices of elements of sub-sequence = {1, 3, 6}
Indices condition:
3 is divisible by 1
6 is divisible by 3
Input: arr[] = {7, 1, 3, 4, 6}
Output:
Explanation:
The sub-sequence = {1, 4}
Indices of elements of sub-sequence = {2, 4}
Indices condition:
4 is divisible by 2

Approach: The idea is to use the concept of Dynamic programming to solve this problem.

• Create a dp[] array first and initialize the array with 1. This is because, the minimum length of the dividing subsequence is 1.
• Now, for every index ‘i’ in the array, increment the count of the values at the indices at all its multiples.
• Finally, when the above step is performed for all the values, the maximum value present in the array is the required answer.

Below is the implementation of the above approach:

## C++

 // C++ program to find the length of// the longest increasing sub-sequence// such that the index of the element is// divisible by index of previous element #include using namespace std; // Function to find the length of// the longest increasing sub-sequence// such that the index of the element is// divisible by index of previous elementint LIIDS(int arr[], int N){    // Initialize the dp[] array with 1 as a    // single element will be of 1 length    int dp[N + 1];     int ans = 0;    for (int i = 1; i <= N; i++) {        dp[i] = 1;    }     // Traverse the given array    for (int i = 1; i <= N; i++) {         // If the index is divisible by        // the previous index        for (int j = i + i; j <= N; j += i) {             // if increasing            // subsequence identified            if (arr[j] > arr[i]) {                dp[j] = max(dp[j], dp[i] + 1);            }        }         // Longest length is stored        ans = max(ans, dp[i]);    }    return ans;} // Driver codeint main(){     int arr[] = { 1, 2, 3, 7, 9, 10 };    int N = sizeof(arr) / sizeof(arr[0]);     cout << LIIDS(arr, N);    return 0;}

## Java

 // Java program to find the length of// the longest increasing sub-sequence// such that the index of the element is// divisible by index of previous elementimport java.util.*; class GFG{ // Function to find the length of// the longest increasing sub-sequence// such that the index of the element is// divisible by index of previous elementstatic int LIIDS(int arr[], int N){     // Initialize the dp[] array with 1 as a    // single element will be of 1 length    int[] dp = new int[N + 1];    int ans = 0;         for(int i = 1; i <= N; i++)    {       dp[i] = 1;    }     // Traverse the given array    for(int i = 1; i <= N; i++)    {                // If the index is divisible by       // the previous index       for(int j = i + i; j <= N; j += i)       {                      // If increasing          // subsequence identified          if (j < arr.length && arr[j] > arr[i])          {              dp[j] = Math.max(dp[j], dp[i] + 1);          }       }               // Longest length is stored       ans = Math.max(ans, dp[i]);    }    return ans;} // Driver codepublic static void main(String args[]){    int arr[] = { 1, 2, 3, 7, 9, 10 };    int N = arr.length;     System.out.println(LIIDS(arr, N));}} // This code is contributed by AbhiThakur

## Python3

 # Python3 program to find the length of# the longest increasing sub-sequence# such that the index of the element is# divisible by index of previous element # Function to find the length of# the longest increasing sub-sequence# such that the index of the element is# divisible by index of previous elementdef LIIDS(arr, N):         # Initialize the dp[] array with 1 as a    # single element will be of 1 length    dp = []    for i in range(1, N + 1):        dp.append(1)         ans = 0         # Traverse the given array    for i in range(1, N + 1):                 # If the index is divisible by        # the previous index        j = i + i        while j <= N:                         # If increasing            # subsequence identified            if j < N and i < N and arr[j] > arr[i]:                dp[j] = max(dp[j], dp[i] + 1)                         j += i                     # Longest length is stored        if i < N:            ans = max(ans, dp[i])             return ans # Driver codearr = [ 1, 2, 3, 7, 9, 10 ] N = len(arr) print(LIIDS(arr, N)) # This code is contributed by ishayadav181

## C#

 // C# program to find the length of// the longest increasing sub-sequence// such that the index of the element is// divisible by index of previous elementusing System; class GFG{ // Function to find the length of// the longest increasing sub-sequence// such that the index of the element is// divisible by index of previous elementstatic int LIIDS(int[] arr, int N){     // Initialize the dp[] array with 1 as a    // single element will be of 1 length    int[] dp = new int[N + 1];    int ans = 0;         for(int i = 1; i <= N; i++)    {        dp[i] = 1;    }     // Traverse the given array    for(int i = 1; i <= N; i++)    {                 // If the index is divisible by        // the previous index        for(int j = i + i; j <= N; j += i)        {                         // If increasing            // subsequence identified            if (j < arr.Length && arr[j] > arr[i])            {                dp[j] = Math.Max(dp[j], dp[i] + 1);            }        }                 // Longest length is stored        ans = Math.Max(ans, dp[i]);    }    return ans;} // Driver codepublic static void Main(){    int[] arr = new int[] { 1, 2, 3, 7, 9, 10 };    int N = arr.Length;     Console.WriteLine(LIIDS(arr, N));}} // This code is contributed by sanjoy_62

## Javascript



Output:

3

Time Complexity: O(N log(N)), where N is the length of the array.

My Personal Notes arrow_drop_up