# Minimum concatenation required to get strictly LIS for array with repetitive elements | Set-2

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

**Examples:**

Input:A = {2, 1, 2, 4, 3, 5}

Output:2

Explanation:

We can concatenate A two times as [2, 1, 2, 4, 3, 5, 2, 1, 2, 4, 3, 5] and then output for index 2, 3, 5, 10, 12 which gives sub-sequence as 1 -> 2 -> 3 -> 4 -> 5.

Input:A = {1, 3, 2, 1, 2}

Output:2

Explanation:

We can concatenate A two times as [1, 3, 2, 1, 2, 1, 3, 2, 1, 2] and then output for index 1, 3, 7 which gives sub-sequence as 1 -> 2 -> 3.

**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, the maximum length of the subsequence is equal to the count of the distinct elements. To solve the problem follow the steps given below:

- Initialise a variable lets say
*ans*to 1 and partition the sequence in two halves the left subsequence and the right one. Initialise the leftSeq to NULL and copy the original sequence in the rightSeq. - Traverse in the right subsequence to
**find the minimum element**, represented by variable*CurrElement*and store its index. - Now
**update the left and right subsequence**, where the leftSeq is updated with the given sequence up to the index which stores the minimum element in the right subsequence. And the rightSeq to given sequence from the minimum index value until the end. - Traverse the array to get the next minimum element and update the value for CurrElement. If no such minimum value is there in rightSeq then it has to be in leftSeq. Find the index of that element in the left subsequence and store its index.
- Now
**again update the value for left and right subsequence**where leftSeq = given sequence up to kth index and rightSeq = given sequence from kth index to end. Repeat the process until the array limit is reached. - Increment the value for
**ans**by 1 and stop when CurrElement is equal to highest element.

Below is the implementation of the above approach:

`// CPP implementation to Find the minimum ` `// concatenation required to get strictly ` `// Longest Increasing Subsequence for the ` `// given array with repetitive elements ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `int` `LIS(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// ordered map containing value and ` ` ` `// a vector containing index of ` ` ` `// it's occurrences ` ` ` `map<` `int` `, vector<` `int` `> > m; ` ` ` ` ` `// Mapping index with their values ` ` ` `// in ordered map ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `m[arr[i]].push_back(i); ` ` ` ` ` `// k refers to present minimum index ` ` ` `int` `k = n; ` ` ` ` ` `// Stores the number of concatenation ` ` ` `// required ` ` ` `int` `ans = 0; ` ` ` ` ` `// Iterate over map m ` ` ` `for` `(` `auto` `it = m.begin(); it != m.end(); ` ` ` `it++) { ` ` ` `// it.second refers to the vector ` ` ` `// containing all corresponding ` ` ` `// indexes ` ` ` ` ` `// it.second.back refers to the ` ` ` `// last element of corresponding vector ` ` ` ` ` `if` `(it->second.back() < k) { ` ` ` `k = it->second[0]; ` ` ` `ans += 1; ` ` ` `} ` ` ` `else` ` ` ` ` `// find the index of next minimum ` ` ` `// element in the sequence ` ` ` `k = *lower_bound(it->second.begin(), ` ` ` `it->second.end(), k); ` ` ` `} ` ` ` ` ` `// Return the final answer ` ` ` `cout << ans << endl; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 3, 2, 1, 2 }; ` ` ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `LIS(arr, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

2

**Time complexity:** O(n * log n)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Minimum concatenation required to get strictly LIS for the given array
- Minimum sub-array such that number of 1's in concatenation of binary representation of its elements is at least K
- Minimum steps required to reduce all the elements of the array to zero
- Find minimum changes required in an array for it to contain k distinct elements
- Minimum operations required to make all Array elements divisible by K
- Minimum number of operations required to delete all elements of the array
- Convert to Strictly increasing integer array with minimum changes
- Split the array elements into strictly increasing and decreasing sequence
- Minimum number of segments required such that each segment has distinct elements
- Flip minimum signs of array elements to get minimum sum of positive elements possible
- Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
- Minimum operations required to change the array such that |arr[i] - M| <= 1
- Minimum number of changes required to make the given array an AP
- Minimum time required to cover a Binary Array
- Minimum number of swaps required to sort an array
- Minimum deletions required to make GCD of the array equal to 1
- Minimum changes required to make all element in an array equal
- Minimum number of colors required to color a Circular Array
- Minimum number of given operations required to reduce the array to 0 element
- Count minimum factor jumps required to reach the end of an Array

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.