给定两个数组arr []和operation []，它们由N和M个整数以及一个整数C组成。数组arr []代表N个盒子中的初始数据包数量，每个盒子的容量为C。从位置1开始，按数组operation []指定的顺序执行以下类型的操作：
- 类型1：移到左侧框。
- 类型2：移到右边的框。
- 类型3：从当前框中选择一个数据包。
- 类型4：从当前框中丢弃数据包。
- 类型5：在每个框中打印数据包数量并退出。
在以下情况下，任何操作都将被忽略：
- 如果当前位置为1，则将忽略向左移动操作。
- 如果当前位置为N，则忽略右移操作。
- 如果已拾取数据包但尚未丢弃数据包或当前框为空，则“选择数据包”操作将被忽略。
- 如果未选择任何数据包或当前盒中已经有C个数据包，则丢弃数据包操作将被忽略
例子：
Input: N = 3, C = 5, arr[] = {2, 5, 2}, M = 6, operations[] = {3, 2, 4, 1, 4, 5}
Output: {1, 5, 2}
Explanation:
Operations can be performed as follows starting from position 1:
Type 3: Pick a packet. Position = 1 and arr[] = {1, 5, 2}.
Type 2: Move right. Position = 2 and arr[] = {1, 5, 2}
Type 4: Drop packet. Position = 2 and arr[] = {1, 5, 2}
Type 1: Move left. Position = 1 and arr[] = {1, 5, 2}.
Type 4: Drop packet. Position = 1 and arr[] = {2, 5, 2}.
Type 5: Print array arr[] = {2, 5, 2}.
Input: N = 3, C = 1, arr[] = {1, 1, 1}, M = 4, operations[] = {3, 2, 4, 5}
Output: {0, 1, 1}
Explanation:
Operations can be performed as follows starting from position 1:
Type 3: Pick a packet. Position = 1 and arr[] = {0, 1, 1}.
Type 2: Move right. Position = 2 and arr[] = {0, 1, 1}
Type 4: Drop packet. Position = 2 and arr[] = {0, 1, 1}
Type 5: Print array arr[] = {0, 1, 1}.
方法：想法是为每个任务分配变量，以便对于当前索引，使用0初始化curr 。要检查元素是否被拾取，请使用false初始化被拾取的元素。请按照以下步骤解决问题：
- 保持一个布尔变量被选择，以跟踪是否已经选择了某些数据包。
- 如果操作类型为1并且curr不为0 ，则向左移动，将curr减1 。
- 如果操作类型为2而curr不是(N – 1) ，请向右移动，将current curr增加1 。
- 如果操作类型是3和拾取为假并且当前框不是空的，在目前的盒和标记选为真由1降低分组。
- 如果操作类型为4和采摘的真实，当前框不充分，在当前框增加包1和标记挑选为假。
- 如果操作类型为5 ，则将当前值打印在数组arr []中并退出。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
#define ll long long int
// Function to print final array after
// performing all the operations
int printFinalArray(int* a, int n,
int* operations,
int p, int capacity)
{
// Initialize variables
int i, curr = 0;
bool picked = false;
// Traverse through all operations
for (i = 0; i < p; i++) {
// Operation Type
int s = operations[i];
bool flag = false;
switch (s) {
// Move left
case 1:
if (curr != 0)
curr--;
break;
// Move right
case 2:
if (curr != n - 1)
curr++;
break;
// Pick a packet
case 3:
if (picked == false
&& a[curr] != 0) {
picked = true;
a[curr]--;
}
break;
// Drop a packet
case 4:
if (picked == true
&& a[curr] != capacity) {
picked = false;
a[curr]++;
}
break;
// Exit
default:
flag = true;
}
if (flag == true)
break;
}
// Print final array
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
// Driver Code
int main()
{
// Given capacity
int capacity = 5;
// Given array with initial values
int a[] = { 2, 5, 2 };
// Array size
int N = sizeof(a) / sizeof(a[0]);
// Operations
int operations[] = { 3, 2, 4, 1, 4, 5 };
// Number of operations
int M = sizeof(operations)
/ sizeof(operations[0]);
// Function call
printFinalArray(a, N, operations,
M, capacity);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG{
// Function to print final array after
// performing aint the operations
static void printFinalArray(int []a, int n,
int []operations,
int p, int capacity)
{
// Initialize variables
int i, curr = 0;
boolean picked = false;
// Traverse through aint operations
for(i = 0; i < p; i++)
{
// Operation Type
int s = operations[i];
boolean flag = false;
switch(s)
{
// Move left
case 1:
if (curr != 0)
curr--;
break;
// Move right
case 2:
if (curr != n - 1)
curr++;
break;
// Pick a packet
case 3:
if (picked == false &&
a[curr] != 0)
{
picked = true;
a[curr]--;
}
break;
// Drop a packet
case 4:
if (picked == true &&
a[curr] != capacity)
{
picked = false;
a[curr]++;
}
break;
// Exit
default:
flag = true;
}
if (flag == true)
break;
}
// Print final array
for(i = 0; i < n; i++)
{
System.out.print(a[i] + " ");
}
}
// Driver Code
public static void main(String[] args)
{
// Given capacity
int capacity = 5;
// Given array with initial values
int a[] = { 2, 5, 2 };
// Array size
int N = a.length;
// Operations
int operations[] = { 3, 2, 4, 1, 4, 5 };
// Number of operations
int M = operations.length;
// Function call
printFinalArray(a, N, operations,
M, capacity);
}
}
// This code is contributed by Rajput-JiPython3
# Python3 program for the above approach
# Function to print final array after
# performing all the operations
def printFinalArray(a, n,
operations, p, capacity):
# Initialize variables
curr = 0
picked = False
# Traverse through all operations
for i in range(p):
# Operation Type
s = operations[i]
flag = False
# Move left
if (curr != 0):
curr -= 1
break
# Move right
if (curr != n - 1):
curr += 1
break
# Pick a packet
if (picked == False
and a[curr] != 0):
picked = True
a[curr] -= 1
break
# Drop a packet
if (picked == True
and a[curr] != capacity):
picked = False
a[curr] += 1
break
# Exit
else:
flag = True
if (flag == True):
break
# Print final array
for i in range(n):
print(a[i], end=" ")
# Driver Code
if __name__ == "__main__":
# Given capacity
capacity = 5
# Given array with initial values
a = [2, 5, 2]
# Array size
N = len(a)
# Operations
operations = [3, 2, 4, 1, 4, 5]
# Number of operations
M = len(operations)
# Function call
printFinalArray(a, N, operations,
M, capacity)
# This code is contributed by chitranayalC#
// C# program for the above approach
using System;
class GFG{
// Function to print final array after
// performing aint the operations
static void printFinalArray(int []a, int n,
int []operations,
int p, int capacity)
{
// Initialize variables
int i, curr = 0;
bool picked = false;
// Traverse through aint operations
for(i = 0; i < p; i++)
{
// Operation Type
int s = operations[i];
bool flag = false;
switch(s)
{
// Move left
case 1:
if (curr != 0)
curr--;
break;
// Move right
case 2:
if (curr != n - 1)
curr++;
break;
// Pick a packet
case 3:
if (picked == false &&
a[curr] != 0)
{
picked = true;
a[curr]--;
}
break;
// Drop a packet
case 4:
if (picked == true &&
a[curr] != capacity)
{
picked = false;
a[curr]++;
}
break;
// Exit
default:
flag = true;
break;
}
if (flag == true)
break;
}
// Print final array
for(i = 0; i < n; i++)
{
Console.Write(a[i] + " ");
}
}
// Driver Code
public static void Main()
{
// Given capacity
int capacity = 5;
// Given array with initial values
int[] a = { 2, 5, 2 };
// Array size
int N = a.Length;
// Operations
int[] operations = { 3, 2, 4, 1, 4, 5 };
// Number of operations
int M = operations.Length;
// Function call
printFinalArray(a, N, operations,
M, capacity);
}
}
// This code is contributed by sanjoy_62输出：
2 5 2时间复杂度： O(M + N)
辅助空间： O(M + N)