Related Articles

# Size of array after repeated deletion of LIS

• Difficulty Level : Hard
• Last Updated : 01 Dec, 2020

Given an array arr[0..n-1] of the positive element. The task is to print the remaining elements of arr[] after repeated deletion of LIS (of size greater than 1). If there are multiple LIS with the same length, we need to choose the LIS that ends first.
Examples:

```Input : arr[] = {1, 2, 5, 3, 6, 4, 1}
Output : 1
Explanation :
{1, 2, 5, 3, 6, 4, 1} - {1, 2, 5, 6} = {3, 4, 1}
{3, 4, 1} - {3, 4} = {1}

Input : arr[] = {1, 2, 3, 1, 5, 2}
Output : -1
Explanation :
{1, 2, 3, 1, 5, 2} - {1, 2, 3, 5} = {1, 2}
{1, 2} - {1, 2} = {}

Input : arr[] = {5, 3, 2}
Output : 3```

We repeatedly find LIS and remove its elements from an array.

```// input vector array = arr[]
// max-sum LIS vector array = maxArray[]
while (arr.size())
{
// find LIS
lis = findLIS(arr, arr.size());
if (lis.size() < 2)
break;

// Remove lis elements from current array. Note
// that both lis[] and arr[] are sorted in
// increasing order.
for (i=0; i<arr.size() && lis.size()>0; i++)
{
if (arr[i] == lis)
{
// Remove lis element from arr[]
arr.erase(arr.begin()+i) ;
i--;

// erase the element from lis[]. This is
// needed to make sure that next element
// to be removed is first element of lis[]
lis.erase(lis.begin()) ;
}
}
}
// print remaining element of array
for (i=0; i<arr.size(); i++)
cout  << arr[i] << " ";
if (i == 0)
cout << "-1";```

## C++

 `/* C++ program to find size of array after repeated``  ``deletion of LIS */``#include ``using` `namespace` `std;` `// Function to construct Maximum Sum LIS``vector<``int``> findLIS(vector<``int``> arr, ``int` `n)``{``    ``// L[i] - The Maximum Sum Increasing``    ``// Subsequence that ends with arr[i]``    ``vector > L(n);` `    ``// L is equal to arr``    ``L.push_back(arr);` `    ``// start from index 1``    ``for` `(``int` `i = 1; i < n; i++)``    ``{``        ``// for every j less than i``        ``for` `(``int` `j = 0; j < i; j++)``        ``{``            ``/* L[i] = {MaxSum(L[j])} + arr[i]``            ``where j < i and arr[j] < arr[i] */``            ``if` `(arr[i] > arr[j] && (L[i].size() < L[j].size()))``                ``L[i] = L[j];``        ``}` `        ``// L[i] ends with arr[i]``        ``L[i].push_back(arr[i]);``    ``}` `    ``// set lis =  LIS``    ``// whose size is max among all``    ``int` `maxSize = 1;``    ``vector<``int``> lis;``    ``for` `(vector<``int``> x : L)``    ``{``        ``// The > sign makes sure that the LIS``        ``// ending first is chose.   ``        ``if` `(x.size() > maxSize)``        ``{``            ``lis = x;``            ``maxSize = x.size();``        ``}``    ``}` `    ``return` `lis;``}` `// Function to minimize array``void` `minimize(``int` `input[], ``int` `n)``{``    ``vector<``int``> arr(input, input + n);` `    ``while` `(arr.size())``    ``{``        ``// Find LIS of current array``        ``vector<``int``> lis = findLIS(arr, arr.size());` `        ``// If all elements are in decreasing order``        ``if` `(lis.size() < 2)``            ``break``;` `        ``// Remove lis elements from current array. Note``        ``// that both lis[] and arr[] are sorted in``        ``// increasing order.``        ``for` `(``int` `i=0; i0; i++)``        ``{``            ``// If first element of lis[] is found``            ``if` `(arr[i] == lis)``            ``{``                ``// Remove lis element from arr[]``                ``arr.erase(arr.begin()+i) ;``                ``i--;` `                ``// Erase first element of lis[]``                ``lis.erase(lis.begin()) ;``            ``}``        ``}``    ``}` `    ``// print remaining element of array``    ``int` `i;``    ``for` `(i=0; i < arr.size(); i++)``        ``cout  << arr[i] << ``" "``;` `    ``// print -1 for empty array``    ``if` `(i == 0)``        ``cout << ``"-1"``;``}` `// Driver function``int` `main()``{``    ``int` `input[] = { 3, 2, 6, 4, 5, 1 };``    ``int` `n = ``sizeof``(input) / ``sizeof``(input);` `    ``// minimize array after deleting LIS``    ``minimize(input, n);` `    ``return` `0;``}`

## Java

 `// Java program to find size``//  of array after repeated``// deletion of LIS``import` `java.util.*;``class` `GFG{` `// Function to conMaximum Sum LIS``static` `Vector findLIS(Vector arr,``                               ``int` `n)``{``  ``// L[i] - The Maximum Sum Increasing``  ``// Subsequence that ends with arr[i]``  ``Vector []L = ``new` `Vector[n];``  ` `  ``for` `(``int` `i = ``0``; i < L.length; i++)``    ``L[i] = ``new` `Vector();``  ` `  ``// L is equal to arr``  ``L[``0``].add(arr.elementAt(``0``));` `  ``// Start from index 1``  ``for` `(``int` `i = ``1``; i < n; i++)``  ``{``    ``// For every j less than i``    ``for` `(``int` `j = ``0``; j < i; j++)``    ``{``      ``// L[i] = {MaxSum(L[j])} + arr[i]``      ``// where j < i and arr[j] < arr[i]``      ``if` `(arr.elementAt(i) > arr.elementAt(j) &&``          ``(L[i].size() < L[j].size()))``        ``L[i] = L[j];``    ``}` `    ``// L[i] ends with arr[i]``    ``L[i].add(arr.elementAt(i));``  ``}` `  ``// Set lis =  LIS``  ``// whose size is max among all``  ``int` `maxSize = ``1``;``  ``Vector lis = ``new` `Vector<>();``  ` `  ``for` `(Vector x : L)``  ``{``    ``// The > sign makes sure that the LIS``    ``// ending first is chose.   ``    ``if` `(x.size() > maxSize)``    ``{``      ``lis = x;``      ``maxSize = x.size();``    ``}``  ``}``  ``return` `lis;``}` `// Function to minimize array``static` `void` `minimize(``int` `input[],``                     ``int` `n)``{``  ``Vector arr = ``new` `Vector<>();``  ``for``(``int` `i = ``0``; i < n; i++)``    ``arr.add(input[i]);` `  ``while` `(arr.size() != ``0``)``  ``{``    ``// Find LIS of current array``    ``Vector lis = findLIS(arr,``                                  ``arr.size());` `    ``// If all elements are``    ``// in decreasing order``    ``if` `(lis.size() < ``2``)``      ``break``;` `    ``// Remove lis elements from``    ``// current array. Note that both``    ``// lis[] and arr[] are sorted in``    ``// increasing order.``    ``for` `(``int` `i = ``0``; i < arr.size() &&``             ``lis.size() > ``0``; i++)``    ``{``      ``// If first element of lis[] is found``      ``if` `(arr.elementAt(i) == lis.elementAt(``0``))``      ``{``        ``// Remove lis element from arr[]``        ``arr.removeAll(lis);``        ``i--;` `        ``// Erase first element of lis[]``        ``lis.remove(``0``);``      ``}``    ``}``  ``}` `  ``// print remaining element of array``  ``int` `i;``  ``for` `(i = ``1``; i < arr.size(); i++)``    ``System.out.print(arr.elementAt(i) + ``" "``);` `  ``// print -1 for empty array``  ``if` `(i == ``0``)``    ``System.out.print(``"-1"``);``}` `// Driver function``public` `static` `void` `main(String[] args)``{``  ``int` `input[] = {``3``, ``2``, ``6``, ``4``, ``5``, ``1``};``  ``int` `n = input.length;` `  ``// minimize array after deleting LIS``  ``minimize(input, n);``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `''' Python program to find size of array after repeated``  ``deletion of LIS '''` `# Function to construct Maximum Sum LIS``from` `typing ``import` `List` `def` `findLIS(arr: ``List``[``int``], n: ``int``) ``-``> ``List``[``int``]:` `    ``# L[i] - The Maximum Sum Increasing``    ``# Subsequence that ends with arr[i]``    ``L ``=` `[``0``] ``*` `n``    ``for` `i ``in` `range``(n):``        ``L[i] ``=` `[]` `    ``# L is equal to arr``    ``L[``0``].append(arr[``0``])` `    ``# start from index 1``    ``for` `i ``in` `range``(``1``, n):` `        ``# for every j less than i``        ``for` `j ``in` `range``(i):``          ` `            ``''' L[i] = MaxSum(L[j]) + arr[i]``            ``where j < i and arr[j] < arr[i] '''``            ``if` `(arr[i] > arr[j] ``and``                ``(``len``(L[i]) < ``len``(L[j]))):``                ``L[i] ``=` `L[j].copy()` `        ``# L[i] ends with arr[i]``        ``L[i].append(arr[i])` `    ``# set lis =  LIS``    ``# whose size is max among all``    ``maxSize ``=` `1``    ``lis: ``List``[``int``] ``=` `[]``    ``for` `x ``in` `L:` `        ``# The > sign makes sure that the LIS``        ``# ending first is chose.``        ``if` `(``len``(x) > maxSize):` `            ``lis ``=` `x.copy()``            ``maxSize ``=` `len``(x)` `    ``return` `lis` `# Function to minimize array``def` `minimize(``input``: ``List``[``int``], n: ``int``) ``-``> ``None``:` `    ``arr ``=` `input``.copy()` `    ``while` `len``(arr):` `        ``# Find LIS of current array``        ``lis ``=` `findLIS(arr, ``len``(arr))` `        ``# If all elements are in decreasing order``        ``if` `(``len``(lis) < ``2``):``            ``break` `        ``# Remove lis elements from current array. Note``        ``# that both lis[] and arr[] are sorted in``        ``# increasing order.``        ``i ``=` `0``        ``while` `i < ``len``(arr) ``and` `len``(lis) > ``0``:` `            ``# If first element of lis[] is found``            ``if` `(arr[i] ``=``=` `lis[``0``]):` `                ``# Remove lis element from arr[]``                ``arr.remove(arr[i])``                ``i ``-``=` `1` `                ``# Erase first element of lis[]``                ``lis.remove(lis[``0``])``            ``i ``+``=` `1` `    ``# print remaining element of array``    ``i ``=` `0``    ``while` `i < ``len``(arr):``        ``print``(arr[i], end``=``" "``)``        ``i ``+``=` `1` `    ``# print -1 for empty array``    ``if` `(i ``=``=` `0``):``        ``print``(``"-1"``)` `# Driver function``if` `__name__ ``=``=` `"__main__"``:` `    ``input` `=` `[``3``, ``2``, ``6``, ``4``, ``5``, ``1``]``    ``n ``=` `len``(``input``)` `    ``# minimize array after deleting LIS``    ``minimize(``input``, n)` `# This code is contributed by sanjeev2552`

Output:

`1`