Longest Subsequence where index of next element is arr[arr[i] + i]

Last Updated : 18 Jul, 2024

Given an array arr[], the task is to find the maximum length sub-sequence from the array which satisfy the following condition:
Any element can be chosen as the first element of the sub-sequence but the index of the next element will be determined by arr[arr[i] + i] where i is the index of the previous element in the sequence.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}
Output: 1 2 4
arr[0] = 1, arr[1 + 0] = arr[1] = 2, arr[2 + 1] = arr[3] = 4
Other possible sub-sequences are {2, 4}, {3}, {4} and {5}

Input: arr[] = {1, 6, 3, 1, 12, 1, 4}
Output: 3 1 4

Approach:

Make use of two arrays temp and print.
The temp array will store the array elements that are currently under consideration and the print array will store the array elements that are to be printed as the final output.
Iterate from 0 to n – 1 and consider the current element as the first element of the sequence.
Store all the elements of the current sequence into temp array.
If the size of the temp array becomes greater than print array then copy all the contents of the temp array to the print array.
When all the sequences have been considered, print the contents of the print array.

Below is the implementation of the above approach:

C++

#include <bits/stdc++.h> using namespace std;  // Function to print the maximum length sub-sequence void maxLengthSubSeq(int a[], int n) {     // Arrays to store the values to be printed     vector<int> temp, print;      for (int i = 0; i < n; i++) {         int x = i;         temp.clear();          // Iterate till index is in range of the array         while (x < n) {             temp.push_back(a[x]);             x = a[x] + x;  // Move to the next index         }          // If the length (temp) > the length (print) then         // copy the contents of the temp array into         // the print array         if (print.size() < temp.size()) {             print = temp;         }     }      // Print the contents of the array     for (int i = 0; i < print.size(); i++)         cout << print[i] << " "; }  // Driver code int main() {     int a[] = {1, 6, 3, 1, 12, 1, 4};     int n = sizeof(a) / sizeof(a[0]);     maxLengthSubSeq(a, n);     return 0; }

Java

import java.util.ArrayList;  public class MaxLengthSubSeq {     // Function to print the maximum length sub-sequence     public static void maxLengthSubSeq(int[] a, int n) {         ArrayList<Integer> temp = new ArrayList<>();  // Temp array to store current sequence         ArrayList<Integer> print = new ArrayList<>(); // Print array to store the longest sequence          for (int i = 0; i < n; i++) {             int x = i;             temp.clear();              // Build the sequence starting from index i             while (x < n) {                 temp.add(a[x]);                 x = a[x] + x;  // Move to the next index             }              // Update print array if temp has a longer sequence             if (print.size() < temp.size()) {                 print = new ArrayList<>(temp);             }         }          // Print the longest sequence         for (int num : print) {             System.out.print(num + " ");         }     }      public static void main(String[] args) {         int[] a = {1, 6, 3, 1, 12, 1, 4};         int n = a.length;         maxLengthSubSeq(a, n);     } }

Python

def max_length_subseq(a):     n = len(a)     temp = []     print_seq = []      for i in range(n):         x = i         temp = []          # Build the sequence starting from index i         while x < n:             temp.append(a[x])             x = a[x] + x  # Move to the next index          # Update print_seq if temp has a longer sequence         if len(print_seq) < len(temp):             print_seq = temp      # Print the longest sequence     for num in print_seq:         print(num, end=" ")  a = [1, 6, 3, 1, 12, 1, 4] max_length_subseq(a)

using System; using System.Collections.Generic;  class MaxLengthSubSeq {     // Function to print the maximum length sub-sequence     static void MaxLengthSubSeqMethod(int[] a, int n) {         List<int> temp = new List<int>();  // Temp list to store current sequence         List<int> print = new List<int>(); // Print list to store the longest sequence          for (int i = 0; i < n; i++) {             int x = i;             temp.Clear();              // Build the sequence starting from index i             while (x < n) {                 temp.Add(a[x]);                 x = a[x] + x;  // Move to the next index             }              // Update print list if temp has a longer sequence             if (print.Count < temp.Count) {                 print = new List<int>(temp);             }         }          // Print the longest sequence         foreach (int num in print) {             Console.Write(num + " ");         }     }      static void Main(string[] args) {         int[] a = {1, 6, 3, 1, 12, 1, 4};         int n = a.Length;         MaxLengthSubSeqMethod(a, n);     } }

JavaScript

function maxLengthSubSeq(a) {     let n = a.length;     let temp = [];   // Temp array to store current sequence     let print = [];  // Print array to store the longest sequence      for (let i = 0; i < n; i++) {         let x = i;         temp = [];          // Build the sequence starting from index i         while (x < n) {             temp.push(a[x]);             x = a[x] + x;  // Move to the next index         }          // Update print array if temp has a longer sequence         if (print.length < temp.length) {             print = [...temp];         }     }      // Print the longest sequence     for (let num of print) {         console.log(num + " ");     } }  let a = [1, 6, 3, 1, 12, 1, 4]; maxLengthSubSeq(a);

PHP

<?php function maxLengthSubSeq($a, $n) {     $temp = array();  // Temp array to store current sequence     $print = array(); // Print array to store the longest sequence      for ($i = 0; $i < $n; $i++) {         $x = $i;         $temp = array();          // Build the sequence starting from index i         while ($x < $n) {             $temp[] = $a[$x];             $x = $a[$x] + $x;  // Move to the next index         }          // Update print array if temp has a longer sequence         if (count($print) < count($temp)) {             $print = $temp;         }     }      // Print the longest sequence     foreach ($print as $num) {         echo $num . " ";     } }  $a = array(1, 6, 3, 1, 12, 1, 4); $n = count($a); maxLengthSubSeq($a, $n); ?>

Output

3 1 4

Complexity Analysis:

Time Complexity: O(n*n)
Auxiliary Space: O(n)

Longest Subsequence with at least one common digit in every element

SanjayR

Improve

Article Tags :

Practice Tags :

Arrays

Longest Subsequence where index of next element is arr[arr[i] + i]

Similar Reads