Given an array arr[0..n-1] of positive element. The task is to print remaining elements of arr[] after repeated deletion of LIS (of size greater than 1). If there are multiple LIS with 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 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[0]) { // 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++ program to find size of array after repeated ` ` ` `deletion of LIS */` `#include <bits/stdc++.h> ` `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 <vector<` `int` `> > L(n); ` ` ` ` ` `// L[0] is equal to arr[0] ` ` ` `L[0].push_back(arr[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[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; i<arr.size() && lis.size()>0; i++) ` ` ` `{ ` ` ` `// If first element of lis[] is found ` ` ` `if` `(arr[i] == lis[0]) ` ` ` `{ ` ` ` `// 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[0]); ` ` ` ` ` `// minimize array after deleting LIS ` ` ` `minimize(input, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

1

This article is contributed by **Shivam Pradhan (anuj_charm)**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Construction of Longest Increasing Subsequence(LIS) and printing LIS sequence
- Minimum steps to delete a string after repeated deletion of palindrome substrings
- Minimum concatenation required to get strictly LIS for array with repetitive elements | Set-2
- Variations of LIS | DP-21
- Longest Common Increasing Subsequence (LCS + LIS)
- Weighted Job Scheduling | Set 2 (Using LIS)
- LIS using Segment Tree
- Maximum subarray sum in an array created after repeated concatenation
- Insertion and Deletion in STL Set C++
- Count the number of ways to tile the floor of size n x m using 1 x m size tiles
- Maximum size of square such that all submatrices of that size have sum less than K
- Smallest length string with repeated replacement of two distinct adjacent
- Longest Repeated Subsequence
- Number of subsequences of maximum length K containing no repeated elements
- Minimum repeated addition of even divisors of N required to convert N to M
- Minimum cost to convert M to N by repeated addition of its even divisors
- Count ways to obtain given sum by repeated throws of a dice
- Maximise array sum after taking non-overlapping sub-arrays of length K
- Maximum possible array sum after performing the given operation
- Maximum possible GCD after replacing at most one element in the given array