Minimum concatenation required to get strictly LIS for the given array

Given an array A[] of size n where there are only unique elements in the array. We have to find the minimum concatenation required for sequence A to get strictly Longest Increasing Subsequence. For array A[] we follow 1 based indexing.

Examples:

Input: A = {1, 3, 2}
Output: 2
Explanation:
We can concatenate A two times as [1, 3, 2, 1, 3, 2] and then output for index 1, 3, 5 which gives sub-sequence as 1->2->3.
Input: A = {2, 1, 4, 3, 5}
Output: 3
Explanation:
The given array has to be concatenated 3 times to generate the Longest Increasing Subsequence.

Approach:
To solve the problem mentioned above the very first observation is that a strictly increasing sub-sequence will always have its length equal to the number of unique elements present in sequence A[]. Hence, we have to figure out a way to keep the maximum consecutive numbers in order are together. We can achieve this by taking as many strictly consecutive numbers in a sequence before opting for concatenation and handle others in the next concatenation.

Form pairs of elements and its index and store them in sorted order as per value. Initialize a variable to count the required concatenation operations.
Run a loop from index 2 to n and if index of pair[i-1] > pair[i] then increment the variable by 1 which was counting the required concatenation operations, otherwise continue the process.

Below is the implementation of the above approach:

C++

// CPP implementation to Find the minimum
// concatenation required to get strictly
// Longest Increasing Subsequence for the
// given array
#include <bits/stdc++.h>

using namespace std;
 
int increasingSubseq(int a[], int n)
{

    // Ordered map containing pairs

    // of value and index.

    map<int, int> mp;
 
    for (int i = 0; i < n; i++) {

        // Form pairs of value at index i

        // and it's index that is i.

        mp.insert(make_pair(a[i], i));

    }
 
    // Variable to insert the minimum

    // concatenations that are needed

    int ans = 1;
 
    // Iterator pointing to the

    // second pair in the map

    auto itr = ++mp.begin();
 
    // Iterator pointing to the

    // first pair in the map

    for (auto it = mp.begin(); it != mp.end(); ++it) {
 
        // Check if itr tends to end of map

        if (itr != mp.end()) {
 
            // Check if index2 is not greater than index1

            // then we have to perform a concatenation.

            if (itr->second <= it->second)

                ans += 1;
 
            ++itr;

        }

    }
 
    // Return the final answer

    cout << ans << endl;
}
 
// Driver code

int main()
{

    int a[] = { 2, 1, 4, 3, 5 };
 
    int n = sizeof(a) / sizeof(a[0]);
 
    increasingSubseq(a, n);
 
    return 0;
}

Java

/*package whatever //do not write package name here */

import java.util.*;

import java.io.*;
 
class GFG {
 
    private static void increasingSubseq(int a[], int n)

    {
 
        // Ordered map containing pairs

        // of value and index.

        TreeMap<Integer, Integer> mp

            = new TreeMap<Integer, Integer>();
 
        for (int i = 0; i < n; i++) {

            // Form pairs of value at index i

            // and it's index that is i.

            mp.put(a[i], i);

        }
 
        // Variable to insert the minimum

        // concatenations that are needed

        int ans = 1;
 
        // Iterator pointing to the

        // first entry in the map

        Map.Entry<Integer, Integer> itr

            = mp.pollFirstEntry();
 
        for (Map.Entry<Integer, Integer> it :

             mp.entrySet()) 

        {
 
            // Check if index2 is not greater than index1

            // then we have to perform a concatenation.

            if (itr.getValue() >= it.getValue())

                ans++;
 
            itr = it;

        }
 
        System.out.println(ans);

    }
 
    // Driver Code

    public static void main(String[] args)

    {

        int a[] = { 2, 1, 4, 3, 5 };
 
        int n = a.length;
 
        increasingSubseq(a, n);

    }
}

Python3

# Python 3 implementation to 
# Find the minimum concatenation 
# required to get strictly Longest 
# Increasing Subsequence for the
# given array

def increasingSubseq(a, n):

    # Ordered map containing pairs

    # of value and index.

    mp = {}
 
    for i in range(n):

        # Form pairs of value at 

        # index i and it's index 

        # that is i.

        mp[a[i]] = i
 
    # Variable to insert the 

    # minimum concatenations 

    # that are needed

    ans = 1
 
    # Iterator pointing to the

    # second pair in the map

    itr = 1

    li= list(mp.values())

    # Iterator pointing to the

    # first pair in the map

    for key, value in mp.items():

        # Check if itr tends to 

        # end of map

        if (itr < len(mp)):

            # Check if index2 is not 

            # greater than index1

            # then we have to perform 

            # a concatenation.

            if (li[itr] <= key):

                ans += 1

            itr+=1
 
    # Return the final 

    # answer

    print(ans)
 
# Driver code

if __name__ == '__main__':

    a = [2, 1, 4, 3, 5]

    n = len(a)

    increasingSubseq(a, n)
 
# This code is contributed by bgangwar59

using System;

using System.Linq;

using System.Collections.Generic;
 
public class GFG
{

  private static void increasingSubseq(int[] a, int n)

  {

    // Ordered dictionary containing pairs

    // of value and index.

    SortedDictionary<int, int> mp = new SortedDictionary<int, int>();
 
    for (int i = 0; i < n; i++)

    {

      // Form pairs of value at index i

      // and it's index that is i.

      mp[a[i]] = i;

    }
 
    // Variable to insert the minimum

    // concatenations that are needed

    int ans = 1;
 
    // Iterator pointing to the

    // first entry in the dictionary

    KeyValuePair<int, int> itr = mp.First();
 
    foreach (KeyValuePair<int, int> it in mp)

    {

      // Check if index2 is not greater than index1

      // then we have to perform a concatenation.

      if (itr.Value > it.Value)

      {

        ans++;

      }
 
      itr = it;

    }
 
    Console.WriteLine(ans);

  }
 
  // Driver Code

  public static void Main(string[] args)

  {

    int[] a = { 2, 1, 4, 3, 5 };

    int n = a.Length;
 
    increasingSubseq(a, n);

  }
}
 
// This code is contributed by phasing17.

Javascript

<script>
 
// Python 3 implementation to
// Find the minimum concatenation
// required to get strictly Longest
// Increasing Subsequence for the
// given array

function increasingSubseq(a, n){
 
    // Ordered map containing pairs

    // of value and index.

    let mp = new Map()
 
    for(let i=0;i<n;i++){

        // Form pairs of value at

        // index i and it's index

        // that is i.

        mp.set(a[i],i)

    }
 
    // Variable to insert the

    // minimum concatenations

    // that are needed

    let ans = 1
 
    // Iterator pointing to the

    // second pair in the map

    let itr = 1

    let li= Array.from(mp.values())

    // Iterator pointing to the

    // first pair in the map

    for([key, value] of mp){

        // Check if itr tends to

        // end of map

        if (itr < mp.size){

            // Check if index2 is not

            // greater than index1

            // then we have to perform

            // a concatenation.

            if (li[itr] <= key)

                ans += 1

            itr+=1

        }

    }

    // Return the final

    // answer

    document.write(ans)
 
}
 
// Driver code
let a = [2, 1, 4, 3, 5]
let n = a.length
increasingSubseq(a, n)
 
// This code is contributed by shinjanpatra
</script>

Output

Time complexity: O(N * log N)

Space complexity: O(N)

Article Tags :

Algorithms

Analysis of Algorithms

DSA

Greedy

Searching

Sorting