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:
// 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;
} |
/*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);
}
} |
# 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. |
<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> |
3
Time complexity: O(N * log N)
Space complexity: O(N)