Size of array after repeated deletion of LIS

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[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++

/* 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;
}

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<Integer> findLIS(Vector<Integer> arr,
                               int n)
{
  // L[i] - The Maximum Sum Increasing
  // Subsequence that ends with arr[i]
  Vector<Integer> []L = new Vector[n];

  for (int i = 0; i < L.length; i++)
    L[i] = new Vector<Integer>();

  // L[0] is equal to arr[0]
  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<Integer> lis = new Vector<>();

  for (Vector<Integer> 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<Integer> arr = new Vector<>();
  for(int i = 0; i < n; i++)
    arr.add(input[i]);

  while (arr.size() != 0)
  {
    // Find LIS of current array
    Vector<Integer> 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[0] is equal to arr[0]
    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

C#

using System;
using System.Collections.Generic;

class GFG
{

  // Function to construct Maximum Sum LIS
  static List<int> findLIS(List<int> arr, int n)
  {

    // L[i] - The Maximum Sum Increasing
    // Subsequence that ends with arr[i]
    List<List<int> > L = new List<List<int> >();
    for (int i = 0; i < n; i++) {
      L.Add(new List<int>());
    }

    // L[0] is equal to arr[0]
    L[0].Add(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].Count < L[j].Count))
          L[i] = new List<int>(L[j]);
      }

      // L[i] ends with arr[i]
      L[i].Add(arr[i]);
    }

    // set lis =  LIS

    // whose size is max among all
    int maxSize = 1;
    List<int> lis = new List<int>();
    foreach (List<int> x in L)
    {

      // The > sign makes sure that the LIS
      // ending first is chose.
      if (x.Count > maxSize) {
        lis = x;
        maxSize = x.Count;
      }
    }
    return lis;
  }

  // Function to minimize array
  static void minimize(int[] input, int n)
  {
    List<int> arr = new List<int>(input);

    while (arr.Count > 0)
    {

      // Find LIS of current array
      List<int> lis = findLIS(arr, arr.Count);

      // If all elements are in decreasing order
      if (lis.Count < 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.Count; i++) {
        if (lis.Contains(arr[i])) {
          arr.RemoveAt(i);
          i--;
        }
      }
    }
    int j = 0;

    // print remaining element of array
    for (j = 0; j < arr.Count; j++)
      Console.Write(arr[j] + " ");

    // print -1 for empty array
    if (j == 0)
      Console.Write("-1");
  }

  // Driver function
  static void Main()
  {
    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 agrawalpoojaa976.

Javascript

// JavaScript program to find size of array after repeated
// deletion of LIS

// Function to construct Maximum Sum LIS
function findLIS(arr) {
    let n = arr.length;

    // L[i] - The Maximum Sum Increasing
    // Subsequence that ends with arr[i]
    let L = Array(n).fill().map(() => []);

    // L[0] is equal to arr[0]
    L[0].push(arr[0]);

    // start from index 1
    for (let i = 1; i < n; i++) {
        // for every j less than i
        for (let 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].length < L[j].length))
                L[i] = L[j];
        }

        // L[i] ends with arr[i]
        L[i].push(arr[i]);
    }

    // set lis =  LIS
    // whose size is max among all
    let maxSize = 1;
    let lis = [];
    for (let x of L) {
        // The > sign makes sure that the LIS
        // ending first is chose.
        if (x.length > maxSize) {
            lis = x;
            maxSize = x.length;
        }
    }

    return lis;
}

// Function to minimize array
function minimize(input) {
    let arr = input.slice();

    while (arr.length) {
        // Find LIS of current array
        let lis = findLIS(arr);

        // If all elements are in decreasing order
        if (lis.length < 2)
            break;

        // Remove lis elements from current array. Note
        // that both lis[] and arr[] are sorted in
        // increasing order.
        for (let i = 0; i < arr.length && lis.length > 0; i++) {
            // If first element of lis[] is found
            if (arr[i] === lis[0]) {
                // Remove lis element from arr[]
                arr.splice(i, 1);
                i--;

                // Erase first element of lis[]
                lis.shift();
            }
        }
    }

    // print remaining element of array
    if (arr.length) {
        console.log(arr[1]);
    } else {
        console.log(-1);
    }
}

// Driver function
let input = [3, 2, 6, 4, 5, 1];

// minimize array after deleting LIS
minimize(input);

// This code is contributed by lokeshpotta20.

Output: 

1

Time Complexity:O(n^2)

Space Complexity:O(n)