将 K 大小子数组的所有元素从给定的三元数组转换为 0 的最小成本，子数组总和为成本
给定一个包含N个整数的数组arr[] ，其中每个数组元素是0、1或2以及一个整数K ，任务是通过选择打印将数组的所有元素转换为0所需的最小成本一个大小为K的子数组，并在一次操作中将子数组的任何数组元素转换为0 ，其成本等于子数组元素的总和。
例子：
Input: arr[] = {2, 0, 1, 1, 0, 2}, K = 3
Output: 3
Explanation:
Perform the following steps:
- Select the subarray over the range [1, 3], and then flip the arr[2](= 1) to 0 at a cost of 2. The array modifies to arr[] = {2, 0, 0, 1, 0, 2}.
- Select the subarray over the range [1, 3], and then flip the arr[3](= 1) to 0 at a cost of 1. The array modifies to arr[] = {2, 0, 0, 0, 0, 2}.
- Select the subarray over the range [0, 2], and then flip the arr[0](= 2) to 0 at a cost of 2. The array modifies to arr[] = {0, 0, 0, 0, 0, 2}.
- Select the subarray over the range [3, 5], and then flip the arr[5](= 2) to 0 at a cost of 2. The array modifies to arr[] = {0, 0, 0, 0, 0, 0}.
Therefore, the total cost needed is (2+1+2+2 = 7). And it is also the minimum cost needed.
Input: arr[] = {1, 0, 2, 1}, K = 4
Output: 7
方法：可以根据以下观察解决给定的问题：
- It is optimal to first convert all the elements of the subarray of size K having the minimum cost and the maximum number of 2s to 0.
- Suppose X is the count of 1s, and Y is the count of 2s in the subarray with minimum cost. Then converting all 2s to 0 first and then all 1s to 0 will give the minimum cost to convert the subarray to 0.
- The cost of converting all 2s to 0 is:
- (X+2*Y)+(X+2*Y-2) +(X+2*Y-4)+ … +(X+2*Y-2*(Y-1))
= Y*(X+2*Y) – Y*(0+2*(Y-1))/2
= Y*(X+2*Y) – Y*(Y-1)
= X*Y+2*Y2-Y2+Y = Y2 + X*Y + Y
- (X+2*Y)+(X+2*Y-2) +(X+2*Y-4)+ … +(X+2*Y-2*(Y-1))
- The cost of converting all remaining 1s to 0 is:
- X+ (X-1)+(X-2)+ … + 1
= (X*(X+1))/2
- X+ (X-1)+(X-2)+ … + 1
- Therefore, the cost of converting all elements of a subarray with X 1s and Y 2s is equal to:
- Y2+X*Y+Y+(X*(X+1))/2
- Now, the remaining elements can be converted to 0s by taking a subarray with K-1 0s and the element, which will be of cost equal to the element itself.
- Therefore, if the sum is the total sum of the array, then, the minimum cost will be equal to:
- sum-(X+2*Y) + Y2+X*Y+Y+(X*(X+1))/2
请按照以下步骤解决问题：
- 初始化两个数组，例如pcount1[]和pcount2[]为{0} ，其中pcount1[i]和pcount2[i]将1 s 和2 s 的计数存储在[0, i] 范围内的前缀中。
- 使用变量i遍历数组arr[]并执行以下操作：
- 将pcount1[i]分配给pcount1[i+1]并将pcount2[i]分配给pcount2[i+1] 。
- 如果arr[i]为1 ，则增加pcount1[i+1] 。否则，如果arr[i]为2 ，则pcount2[i+1]的增量计数。
- 找到数组的总和并将其存储在一个变量中，比如sum。
- 初始化两个变量，比如X和Y ，以将1 s 和2 s 的计数存储在子数组中，并且大小总和为K 。
- 使用变量i迭代范围[K, N]并执行以下步骤：
- 初始化两个变量，比如A和B ，以在[iK, K-1]范围内的子数组中存储1 s 和2 s 的计数。
- 将pcount1[i]-pcount1[iK]分配给A ，将pcount2[i]-pcount2[iK]分配给B 。
- 如果A+2*B小于X+2*Y ，则将X更新为A并将Y更新为B 。
- 最后，完成上述步骤后，将总成本打印为sum-(X+2*Y) + Y 2 +X*Y+Y+(X*(X+1))/2。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Function to find the min cost
int minCost(int arr[], int N, int K)
{
// Stores the prefix count of 1s
int pcount1[N + 1] = { 0 };
// Stores the prefix count of 2s
int pcount2[N + 1] = { 0 };
// Traverse the array arr[]
for (int i = 1; i <= N; i++) {
pcount1[i] = pcount1[i - 1] + (arr[i - 1] == 1);
pcount2[i] = pcount2[i - 1] + (arr[i - 1] == 2);
}
// Stores total sum of the array arr[]
int sum = pcount1[N] + 2 * pcount2[N];
// Stores the count of 1s in a subarray
int X = N;
// Stores the count of 2s in a subarray
int Y = N;
// Iterate over the range [K, N]
for (int i = K; i <= N; i++) {
int A = pcount1[i] - pcount1[i - K];
int B = pcount2[i] - pcount2[i - K];
// If current subarray sum is less
// than X+2*Y
if (A + 2 * B < X + 2 * Y) {
X = A;
Y = B;
}
}
// Stores the total cost
int total = sum - (X + 2 * Y) + Y * Y + X * Y + Y
+ (X * (X + 1)) / 2;
// Return total
return total;
}
// Driver Code
int main()
{
// Input
int arr[] = { 2, 0, 1, 1, 0, 2 };
int N = sizeof(arr) / sizeof(arr[0]);
int K = 3;
// Function call
cout << minCost(arr, N, K);
return 0;
} Java
// Java Program for the above approach
import java.io.*;
import java.util.Arrays;
class GFG
{
// Function to find the min cost
static int minCost(int arr[], int N, int K)
{
// Stores the prefix count of 1s
int pcount1[] = new int[N + 1];
// Stores the prefix count of 2s
int pcount2[] = new int[N + 1];
Arrays.fill(pcount1, 0);
Arrays.fill(pcount2, 0);
// Traverse the array arr[]
for (int i = 1; i <= N; i++) {
int k = 0;
int l = 0;
if (arr[i - 1] == 1)
k = 1;
if (arr[i - 1] == 2)
l = 1;
pcount1[i] = pcount1[i - 1] + k;
pcount2[i] = pcount2[i - 1] + l;
}
// Stores total sum of the array arr[]
int sum = pcount1[N] + 2 * pcount2[N];
// Stores the count of 1s in a subarray
int X = N;
// Stores the count of 2s in a subarray
int Y = N;
// Iterate over the range [K, N]
for (int i = K; i <= N; i++) {
int A = pcount1[i] - pcount1[i - K];
int B = pcount2[i] - pcount2[i - K];
// If current subarray sum is less
// than X+2*Y
if (A + 2 * B < X + 2 * Y) {
X = A;
Y = B;
}
}
// Stores the total cost
int total = sum - (X + 2 * Y) + Y * Y + X * Y + Y
+ (X * (X + 1)) / 2;
// Return total
return total;
}
// Driver Code
public static void main(String[] args)
{
// Input
int arr[] = { 2, 0, 1, 1, 0, 2 };
int N = arr.length;
int K = 3;
// Function call
System.out.println(minCost(arr, N, K));
}
}
// This code is contributed by Potta LokeshPython3
# Py program for the above approach
# Function to find the min cost
def minCost(arr, N, K):
# Stores the prefix count of 1s
pcount1 = [0] * (N + 1)
# Stores the prefix count of 2s
pcount2 = [0] * (N+1)
# Traverse the array arr[]
for i in range(1,N+1):
pcount1[i] = pcount1[i - 1] + (arr[i - 1] == 1)
pcount2[i] = pcount2[i - 1] + (arr[i - 1] == 2)
# Stores total sum of the array arr[]
sum = pcount1[N] + 2 * pcount2[N]
# Stores the count of 1s in a subarray
X = N
# Stores the count of 2s in a subarray
Y = N
# Iterate over the range [K, N]
for i in range(K, N + 1):
A = pcount1[i] - pcount1[i - K]
B = pcount2[i] - pcount2[i - K]
# If current subarray sum is less
# than X+2*Y
if (A + 2 * B < X + 2 * Y):
X = A
Y = B
# Stores the total cost
total = sum - (X + 2 * Y) + Y * Y + X * Y + Y + (X * (X + 1)) // 2
# Return total
return total
# Driver Code
if __name__ == '__main__':
# Input
arr= [2, 0, 1, 1, 0, 2]
N = len(arr)
K = 3
# Function call
print (minCost(arr, N, K))
# This code is contributed by mohit kumar 29.C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
// Function to find the min cost
static int minCost(int []arr, int N, int K)
{
// Stores the prefix count of 1s
int []pcount1 = new int[N + 1];
Array.Clear(pcount1, 0, N + 1);
// Stores the prefix count of 2s
int []pcount2 = new int[N + 1];
Array.Clear(pcount2, 0, N + 1);
// Traverse the array arr[]
for (int i = 1; i <= N; i++) {
if(arr[i - 1] == 1){
pcount1[i] = pcount1[i - 1] + 1;
}
else
pcount1[i] = pcount1[i - 1];
if(arr[i - 1] == 2){
pcount2[i] = pcount2[i - 1] + 1;
}
else
pcount2[i] = pcount2[i - 1];
}
// Stores total sum of the array arr[]
int sum = pcount1[N] + 2 * pcount2[N];
// Stores the count of 1s in a subarray
int X = N;
// Stores the count of 2s in a subarray
int Y = N;
// Iterate over the range [K, N]
for (int i = K; i <= N; i++) {
int A = pcount1[i] - pcount1[i - K];
int B = pcount2[i] - pcount2[i - K];
// If current subarray sum is less
// than X+2*Y
if (A + 2 * B < X + 2 * Y) {
X = A;
Y = B;
}
}
// Stores the total cost
int total = sum - (X + 2 * Y) + Y * Y + X * Y + Y
+ (X * (X + 1)) / 2;
// Return total
return total;
}
// Driver Code
public static void Main()
{
// Input
int []arr = { 2, 0, 1, 1, 0, 2 };
int N = arr.Length;
int K = 3;
// Function call
Console.Write(minCost(arr, N, K));
}
}
// This code is contributed by SURENDRA_GANGWAR.Javascript
// Javascript program for the above approach
// Function to find the min cost
function minCost(arr, N, K)
{
// Stores the prefix count of 1s
let pcount1 = new Array(N + 1).fill(0);
// Stores the prefix count of 2s
let pcount2 = new Array(N + 1).fill(0);
// Traverse the array arr[]
for (let i = 1; i <= N; i++) {
pcount1[i] = pcount1[i - 1] + (arr[i - 1] == 1);
pcount2[i] = pcount2[i - 1] + (arr[i - 1] == 2);
}
// Stores total sum of the array arr[]
let sum = pcount1[N] + 2 * pcount2[N];
// Stores the count of 1s in a subarray
let X = N;
// Stores the count of 2s in a subarray
let Y = N;
// Iterate over the range [K, N]
for (let i = K; i <= N; i++) {
let A = pcount1[i] - pcount1[i - K];
let B = pcount2[i] - pcount2[i - K];
// If current subarray sum is less
// than X+2*Y
if (A + 2 * B < X + 2 * Y) {
X = A;
Y = B;
}
}
// Stores the total cost
let total = sum - (X + 2 * Y) + Y * Y + X * Y + Y
+ (X * (X + 1)) / 2;
// Return total
return total;
}
// Driver Code
// Input
let arr = [2, 0, 1, 1, 0, 2];
let N = arr.length;
let K = 3;
// Function call
document.write(minCost(arr, N, K));
// This code is contributed by gfgking.输出
7时间复杂度： O(N)
辅助空间： O(N)