# Minimum concatenation required to get strictly LIS for the given array

• Difficulty Level : Medium
• Last Updated : 10 Mar, 2022

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:
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:
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 ``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);` `    ``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 mp``            ``= ``new` `TreeMap();` `        ``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 itr``            ``= mp.pollFirstEntry();` `        ``for` `(Map.Entry 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`

## Javascript

 ``

Output

`3`

Time complexity: O(N * log N)

My Personal Notes arrow_drop_up