转换为以最小的变化严格增加的整数数组

给定一个由n个整数组成的数组。编写程序以查找数组中的最小更改数，以便数组严格增加整数。在严格增加的数组A [i]

例子：

Input : arr[] = { 1, 2, 6, 5, 4}
Output : 2
We can change a[2] to any value 
between 2 and 5.
and a[4] to any value greater then 5. 

Input : arr[] = { 1, 2, 3, 5, 7, 11 }
Output : 0
Array is already strictly increasing.

问题是最长增加子序列的变化。已经是LIS一部分的数字无需更改。因此，要更改的最小元素是LIS中数组大小和元素数量的差。请注意，我们还需要确保数字是整数。因此，在制作LIS时，我们不会将那些不能通过在中间插入元素而不能严格增加的元素视为LIS的一部分。

在示例{1，2，5，3，4}中，我们认为LIS的长度为三个{1,2,5}，而不是{1,2,3,4}，因为我们不能使用这个LIS。

C++

// CPP program to find min elements to
// change so array is strictly increasing
#include 
using namespace std;
  
// To find min elements to remove from array
// to make it strictly increasing
int minRemove(int arr[], int n)
{
    int LIS[n], len = 0;
  
    // Mark all elements of LIS as 1
    for (int i = 0; i < n; i++)
        LIS[i] = 1;
  
    // Find LIS of array
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (arr[i] > arr[j] && (i-j)<=(arr[i]-arr[j])){
                LIS[i] = max(LIS[i], LIS[j] + 1);
            }
        }
        len = max(len, LIS[i]);
    }
  
    // Return min changes for array
    // to strictly increasing
    return n - len;
}
  
// Driver program to test minRemove()
int main()
{
    int arr[] = { 1, 2, 6, 5, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << minRemove(arr, n);
  
    return 0;
}

Java

// Java program to find min elements to
// change so array is strictly increasing
public class Main {
  
    // To find min elements to remove from array
    // to make it strictly increasing
    static int minRemove(int arr[], int n)
    {
        int LIS[] = new int[n];
        int len = 0;
  
        // Mark all elements of LIS as 1
        for (int i = 0; i < n; i++)
            LIS[i] = 1;
  
        // Find LIS of array
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i] > arr[j] && (i-j)<=(arr[i]-arr[j]))
                    LIS[i] = Math.max(LIS[i], 
                                 LIS[j] + 1);
            }
            len = Math.max(len, LIS[i]);
        }
  
        // Return min changes for array
        // to strictly increasing
        return n - len;
    }
  
    // Driver program to test minRemove()
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 6, 5, 4 };
        int n = arr.length;
  
        System.out.println(minRemove(arr, n));
    }
}

Python3

# Python3 program to find min elements to
# change so array is strictly increasing
  
# Find min elements to remove from array
# to make it strictly increasing
def minRemove(arr, n):
    LIS = [0 for i in range(n)]
    len = 0
  
    # Mark all elements of LIS as 1
    for i in range(n):
        LIS[i] = 1
  
    # Find LIS of array
    for i in range(1, n):
          
        for j in range(i):
            if (arr[i] > arr[j] and (i-j)<=(arr[i]-arr[j]) ):
                LIS[i] = max(LIS[i], LIS[j] + 1)
                  
        len = max(len, LIS[i])
  
    # Return min changes for array
    # to strictly increasing
    return (n - len)
  
# Driver Code
arr = [ 1, 2, 6, 5, 4 ]
n = len(arr)
print(minRemove(arr, n))
  
# This code is contributed by Azkia Anam.

C#

// C# program to find min elements to change so 
// array is strictly increasing
using System;
  
class GFG 
{
  
    // To find min elements to remove from array to 
    // make it strictly increasing
    static int minRemove(int []arr, 
                        int n)
    {
        int []LIS = new int[n];
        int len = 0;
  
        // Mark all elements
        // of LIS as 1
        for (int i = 0; i < n; i++)
            LIS[i] = 1;
  
        // Find LIS of array
        for (int i = 1; i < n; i++) 
        {
            for (int j = 0; j < i; j++) 
            {
                if (arr[i] > arr[j] && (i-j)<=(arr[i]-arr[j]))
                    LIS[i] = Math.Max(LIS[i], 
                                LIS[j] + 1);
            }
            len = Math.Max(len, LIS[i]);
        }
  
        // Return min changes for array  
        // to strictly increasing
        return n - len;
    }
  
    // Driver Code
    public static void Main()
    {
        int []arr = {1, 2, 6, 5, 4};
        int n = arr.Length;
  
        Console.WriteLine(minRemove(arr, n));
    }
}
  
// This code is contributed
// by anuj_67.

PHP

 $arr[$j])
                $LIS[$i] = max($LIS[$i], 
                            $LIS[$j] + 1);
        }
        $len = max($len, $LIS[$i]);
    }
  
    // Return min changes for array to strictly 
    // increasing
    return $n - $len;
}
  
// Driver Code
$arr = array(1, 2, 6, 5, 4);
$n = count($arr);
  
echo minRemove($arr, $n);
  
// This code is contributed
// by anuj_6
?>

输出：

2