给定一个数组nums []和一个整数X ，任务是通过删除最左边或最右边的数组元素并从X减去其值(最小次数)来将X减小为0 。如果可以将X减小为0 ，则打印所需的操作计数。否则，返回-1。
例子：
Input: nums[] = {3,2,20,1,1,3}, X = 10
Output: 5
Explanation: X (= 10) – 3 – 1 – 1 – 3 – 2 = 0. Therefore, the number of operations required is 5.
Input: nums[] = {1, 1, 4, 2, 3}, X = 5
Output: 2
Explanation: X (= 5) – 3 – 2 = 0. Therefore, the number of operations required is 2.
方法：可以使用两个指针技术解决给定的问题。请按照以下步骤解决问题。
- 保持左右两个指针，指向从X排除的左右子数组的末端。
- 初始化左侧以考虑整个数组，并初始化右侧以不包含任何内容。
- 因此，将X减去数组的总和。
- 现在，迭代直到左边到达数组的前面。
- 如果左右子阵列之和超过X(即，X <0)，偏移由索引左到左和增加X该元素。
- 如果左右子阵列之和小于X(即，X> 0)，用指数右移指针向左和由该元素减少X。
- 如果在任何时候发现X为0，请更新所需的最小操作数。
- 打印所需的最少操作数。
- 下面是上述方法的实现：
C++14
// C++ program to implement
// the above approach
#include
using namespace std;
// Function to count the minimum
// number of operations required
// to reduce x to 0
static int minOperations(int nums[], int N,
int x)
{
// If sum of the array
// is less than x
int sum = 0;
for(int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
// Stores the count
// of operations
int ans = INT_MAX;
// Two pointers to traverse the array
int l = N - 1, r = N;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0)
{
// If sum of elements from
// the front exceeds x
if (x <= 0)
{
// Shift towards left
x += nums[l];
l -= 1;
}
// If sum exceeds 0
if (x > 0)
{
// Reduce x by elements
// from the right
r -= 1;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0)
{
// Update the minimum count
// of operations required
ans = min(ans,
(l + 1) + (N - r));
}
}
if (ans < INT_MAX)
return ans;
else
return -1;
}
// Driver Code
int main()
{
int nums[] = { 1, 1, 4, 2, 3 };
// Size of the array
int N = sizeof(nums) / sizeof(nums[0]);
int x = 5;
cout << minOperations(nums, N, x);
return 0;
}
// This code is contributed by code_hunt Java
// Java program to implement
// the above approach
import java.util.*;
class GFG
{
// Function to count the minimum
// number of operations required
// to reduce x to 0
static int minOperations(int nums[], int x)
{
// If sum of the array
// is less than x
int sum = 0;
for (int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
// Stores the count
// of operations
int ans = Integer.MAX_VALUE;
// Two pointers to traverse the array
int l = nums.length - 1, r = nums.length;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0) {
// If sum of elements from
// the front exceeds x
if (x <= 0) {
// Shift towards left
x += nums[l];
l -= 1;
}
// If sum exceeds 0
if (x > 0) {
// Reduce x by elements
// from the right
r -= 1;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0) {
// Update the minimum count
// of operations required
ans = Math.min(ans,
(l + 1) + (nums.length - r));
}
}
if (ans < Integer.MAX_VALUE)
return ans;
else
return -1;
}
// Driver Code
public static void main(String[] args)
{
int[] nums = { 1, 1, 4, 2, 3 };
int x = 5;
System.out.println(minOperations(nums, x));
}
}
// This code is contributed by shubhamsingh10Python3
# Python3 Program to implement
# the above approach
import math
# Function to count the minimum
# number of operations required
# to reduce x to 0
def minOperations(nums, x):
# If sum of the array
# is less than x
if sum(nums) < x:
return -1
# Stores the count
# of operations
ans = math.inf
# Two pointers to traverse the array
l, r = len(nums)-1, len(nums)
# Reduce x by the sum
# of the entire array
x -= sum(nums)
# Iterate until l reaches
# the front of the array
while l >= 0:
# If sum of elements from
# the front exceeds x
if x <= 0:
# Shift towards left
x += nums[l]
l -= 1
# If sum exceeds 0
if x > 0:
# Reduce x by elements
# from the right
r -= 1
x -= nums[r]
# If x is reduced to 0
if x == 0:
# Update the minimum count
# of operations required
ans = min(ans, (l+1) + (len(nums)-r))
return ans if ans < math.inf else -1
# Driver Code
nums = [1, 1, 4, 2, 3]
x = 5
print(minOperations(nums, x))C#
// C# Program to implement
// the above approach
using System;
class GFG {
// Function to count the minimum
// number of operations required
// to reduce x to 0
static int minOperations(int[] nums, int x)
{
// If sum of the array
// is less than x
int sum = 0;
for (int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
// Stores the count
// of operations
int ans = Int32.MaxValue;
// Two pointers to traverse the array
int l = nums.Length - 1, r = nums.Length;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0) {
// If sum of elements from
// the front exceeds x
if (x <= 0) {
// Shift towards left
x += nums[l];
l -= 1;
}
// If sum exceeds 0
if (x > 0) {
// Reduce x by elements
// from the right
r -= 1;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0) {
// Update the minimum count
// of operations required
ans = Math.Min(ans,
(l + 1) + (nums.Length - r));
}
}
if (ans < Int32.MaxValue)
return ans;
else
return -1;
}
// Driver Code
public static void Main()
{
int[] nums = { 1, 1, 4, 2, 3 };
int x = 5;
Console.Write(minOperations(nums, x));
}
}
// This code is contributed by ukasp.输出：
2时间复杂度： O(N)
辅助空间： O(1)