📜  最长递增索引划分子序列的长度

📅  最后修改于: 2021-05-14 00:52:42             🧑  作者: Mango

给定大小为N的数组arr [] ,任务是找到最长的递增子序列,以使任何元素的索引都可以被前一元素的索引(LIIDS)整除。以下是LIIDS的必要条件:
如果i,j是给定数组中的两个索引。然后:

  • j%i = 0
  • arr [i]

例子:

方法:想法是使用动态编程的概念来解决此问题。

  • 首先创建一个dp []数组,并用1初始化该数组。这是因为,除法子序列的最小长度为1。
  • 现在,对于数组中的每个索引“ i”,以其所有倍数递增索引处的值计数。
  • 最后,当对所有值执行上述步骤时,数组中存在的最大值就是所需的答案。

下面是上述方法的实现:

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 element
int 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 code
int 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 element
import 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 element
static 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 code
public 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 element
def 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 code
arr = [ 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 element
using 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 element
static 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 code
public 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


输出:
3

时间复杂度: O(N log(N)) ,其中N是数组的长度。