📌  相关文章
📜  使相邻元素之和 <= X 的最小操作

📅  最后修改于: 2021-10-26 05:10:01             🧑  作者: Mango

给定一个由N 个元素组成的数组arr[]和一个整数X ,任务是找到使相邻元素的总和小于给定数字X所需的最小运算次数。在单个操作中,您可以选择一个元素arr[i]并将其值减少1
例子:

方法:假设数组的元素为a1, a2, …, an 。让我们假设所有a[i]都大于X 的情况
首先,我们需要使所有a[i]等于x 。我们将计算它所需的操作次数。
现在,所有元素都将是x, x, x, x…, x N 次的形式。在这里我们可以观察到最大相邻和等于2 * X
现在,从左到右遍历数组,对于每个i ,如果两个左邻居的总和为a[i] + a[i – 1] > X然后将a[i]更改为这样一个值,即它们的净总和变得等于X
下面是上述方法的实现:

C++
// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the minimum
// number of operations required
int MinOperations(int n, int x, int* arr)
{
 
    // To store total operations required
    int total = 0;
    for (int i = 0; i < n; ++i) {
 
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x) {
            int difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
 
    // Left scan the array
    for (int i = 1; i < n; ++i) {
        int LeftNeigbouringSum = arr[i] + arr[i - 1];
 
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x) {
            int current_diff = LeftNeigbouringSum - x;
            arr[i] = max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
 
// Driver code
int main()
{
    int X = 1;
    int arr[] = { 1, 6, 1, 2, 0, 4 };
    int N = sizeof(arr) / sizeof(int);
    cout << MinOperations(N, X, arr);
 
    return 0;
}


Java
// Java implementation of the approach
class GFG
{
 
// Function to return the minimum
// number of operations required
static int MinOperations(int n, int x, int[] arr)
{
 
    // To store total operations required
    int total = 0;
    for (int i = 0; i < n; ++i)
    {
 
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x)
        {
            int difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
 
    // Left scan the array
    for (int i = 1; i < n; ++i)
    {
        int LeftNeigbouringSum = arr[i] + arr[i - 1];
 
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x)
        {
            int current_diff = LeftNeigbouringSum - x;
            arr[i] = Math.max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
 
// Driver code
public static void main(String args[])
{
    int X = 1;
    int arr[] = { 1, 6, 1, 2, 0, 4 };
    int N = arr.length;
    System.out.println(MinOperations(N, X, arr));
}
}
 
// This code is contributed by 29AjayKumar


Python
# Python3 implementation of the approach
 
# Function to return the minimum
# number of operations required
def MinOperations(n, x, arr):
 
    # To store total operations required
    total = 0
    for i in range(n):
 
        # First make all elements equal to x
        # which are currenctly greater
        if (arr[i] > x):
            difference = arr[i] - x
            total = total + difference
            arr[i] = x
 
 
    # Left scan the array
    for i in range(n):
        LeftNeigbouringSum = arr[i] + arr[i - 1]
 
        # Update the current element such that
        # neighbouring sum is < x
        if (LeftNeigbouringSum > x):
            current_diff = LeftNeigbouringSum - x
            arr[i] = max(0, arr[i] - current_diff)
            total = total + current_diff
 
    return total
 
 
# Driver code
X = 1
arr=[1, 6, 1, 2, 0, 4 ]
N = len(arr)
print(MinOperations(N, X, arr))
 
# This code is contributed by mohit kumar 29


C#
// C# implementation of the approach
using System;
     
class GFG
{
 
// Function to return the minimum
// number of operations required
static int MinOperations(int n, int x, int[] arr)
{
 
    // To store total operations required
    int total = 0;
    for (int i = 0; i < n; ++i)
    {
 
        // First make all elements equal to x
        // which are currenctly greater
        if (arr[i] > x)
        {
            int difference = arr[i] - x;
            total = total + difference;
            arr[i] = x;
        }
    }
 
    // Left scan the array
    for (int i = 1; i < n; ++i)
    {
        int LeftNeigbouringSum = arr[i] + arr[i - 1];
 
        // Update the current element such that
        // neighbouring sum is < x
        if (LeftNeigbouringSum > x)
        {
            int current_diff = LeftNeigbouringSum - x;
            arr[i] = Math.Max(0, arr[i] - current_diff);
            total = total + current_diff;
        }
    }
    return total;
}
 
// Driver code
public static void Main(String []args)
{
    int X = 1;
    int []arr = { 1, 6, 1, 2, 0, 4 };
    int N = arr.Length;
    Console.WriteLine(MinOperations(N, X, arr));
}
}
 
/* This code is contributed by PrinciRaj1992 */


Javascript


输出:
11

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程