题目思路

对于人员，需要能够支持从一端出去，从另一端入。所以我们采用双端队列的形式存储人员数据。

对于物品，需要支持从一端弹出的操作，所以采用栈的形式存储。

接下来就按着题目的思路来模拟即可。

由于可能存在一直循环的可能，所以我们用cnt记录当前已经连续失配了多少次。超过n的最大值就break。

代码

Java代码

public static int GetNumWithoutPrize (int[] persons , int[] prizes){
    // 双端队列存人员
    Deque<Integer> a = new LinkedList<Integer>();
    for (int x : persons){
        a.addLast(x);
    }
    // 栈存礼物
    Stack<Integer> b = new Stack<Integer>();
    for (int i = prizes.length - 1; i >= 0 ; i--){
        b.push(prizes[i]);
    }
    // 循环模拟
    int cnt = 0;
    while (a.size() != 0 && b.size() != 0 && cnt <= 200){
       	// 匹配就都删掉一个
        if (b.peek() == a.getFirst()){
            b.pop();
            a.removeFirst();
            cnt = 0;
        // 适配就把人放到最后一个
        }else {
            int g = a.getFirst();
            a.removeFirst();
            a.addLast(g);
            cnt += 1;
        }
    }
    return a.size();
}

Python代码

def GetNumWithoutPrize(persons,prizes):
	a=[] 	#双端队列存人员
	for x in persons:
		a.append(x)
	b=[]	#栈存礼物
	for i in range(len(prizes)-1,-1,-1):
		b.append(prizes[i])
	cnt=0
	while(len(a)!=0 and len(b)!=0 and cnt<=200):	#循环模拟
		if (b[len(b)-1]==a[0]):	#匹配就都删掉一个
			b.pop()
			a.pop(0)
			cnt=0
            #适配就把人放到最后一个
		else:
			g=a[0]
			a.pop(0)
			a.append(g)
			cnt=cnt+1
	return len(a)

C++代码

int GetNumWithoutPrize (int persons[] , int prizes[],int n){
    // 双端队列存人员
    deque<int> a(persons,persons+n);
    // 栈存礼物
    stack<int>b;
    for (int i = n - 1; i >= 0 ; i--){
        b.push(prizes[i]);
    }
    // 循环模拟
    int cnt = 0;
    while (a.size() != 0 && b.size() != 0 && cnt <= 200){
       	// 匹配就都删掉一个
        if (b.top() == a.front()){
            b.pop();
            a.pop_front();
            cnt = 0;
        // 适配就把人放到最后一个
        }else {
            int g = a.front();
            a.pop_front();
            a.push_back(g);
            cnt += 1;
        }
    }
    return a.size();
}

Js代码

function GetNumWithoutPrize(persons,prizes)
{
		var a=[],b=[];//数组分别模拟双端队列和栈
		var front=0,back=-1,top=-1;
		for (let i=0;i<persons.length;i++){// 双端队列存人员
            a[++back]=persons[i];
		}
		for (let i=prizes.length-1;i>=0;i--){ // 栈存礼物
            b[++top]=prizes[i];
		}
		var cnt=0;
    	// 循环模拟
		while (front<=back&&top>-1&&cnt<=200){
            // 匹配就都删掉一个
            if (b[top] == a[front]){
                top--;
                front++;
                cnt = 0;
                // 适配就把人放到最后一个
            }else {
                var g = a[front];
                front++;
                a[++back]=g;
                cnt += 1;
            }
		}
		return back-front+1;
}

题目内容

小红是一家知名企业的HR主管，为了提高员工的工作积极性，他经常会组织各种活动来丰富员工的业余生活。最近，他举办了一场员工抽奖活动，奖品分别是儿童绘本和雨伞。在活动中，每位员工都需要填写自己喜欢的奖品，并抽取一个获奖号码。活动进行得非常成功，员工们都参与热情高涨，最终产生了一批获奖者。

现在，小红需要让获奖员工领取奖品。但是，他发现每个员工都有自己喜欢的奖品，只会领取自己想要的那个奖品，因此他需要根据员工填写的喜好，分别提供儿童绘本和雨伞两种奖品，分别用数字 $0$ 和 $1$ 表示，每个员工都有自己喜欢的奖品(儿童绘本或雨伞)，且只会领取自己喜欢的奖品。。

小红把奖品自下往上一件一件堆叠在一起，同时让员工站成一个队列，领取规则为：

• 每轮：只能队首的员工进行领取，如果最顶上的奖品是自己喜欢的，那么会拿走它并离开队列；否则就回到队尾，等待下次机会。
• 这个过程会一直持续到队列没有员工，或所有剩余员工都不喜欢最顶上的奖品为止。

现在给你两个长度相等的整数数组 $persons$ 和 $prizes$ ,其中 $persons[i]$ 是初始队列里第 $i$ 名员工喜欢的奖品( $i=0$ 是队首位置)， $prizes[j]$ 是第 $j$ 个奖品的类型( $0$ 表示最顶上)。

请返回无法取到自己喜欢的奖品的员工数量。

输入描述

输入三行，第一行输入一个整数 $n$ ，代表员工数量（奖品数量）

第二行n个整数,$persons[i]$ 是初始队列里第 $i$ 名员工喜欢的奖品( $i=0$ 是队首位置)

第三行n个整数，$prizes[j]$ 是第 $j$ 个奖品的类型( $0$ 表示最顶上)。

数据范围：

• $1\le n\le 100$
• $persons.length == prizes.length$

输出描述

输出无法取到自己喜欢的奖品的员工数量。

样例

输入

5
0 1 1 0 1
1 0 0 1 0

输出

1

样例解释

队首的员工放弃最顶上的奖品，并回到队列的末尾，队列变为 $persons =[1,1,0,1,0]$ 。

队首的员工拿走最顶上的奖品，并离开队列，队列变为 $persons = [1,0,1,0]$ ，奖品为 $prizes=[0,0,1,0]$ 。

队首的员工放弃最顶上的奖品，并回到队列的末尾，队列变为 $persons=[0,1,0,1]$ 。

队首的员工拿走最顶上的奖品，并离开队列，队列变为 $persons= [1,0,1]$ ，奖品为 $prizes= [0,1,0]$ 。

队首的员工放弃最顶上的奖品，并回到队列的末尾，队列变为 $persons = [0,1,1]$ 。

队首的员工拿走最顶上的奖品，并离开队列，队列变为 $persons= [1,1]$ , 奖品为 $prizes=[1,0]$ 。

队首的员工拿走最顶上的奖品，并离开队列，队列变为 $persons= [1]$ ，奖品为 $prizes=[0]$ 。

最后剩余的 $1$ 名员工不喜欢最顶上的奖品，因此返回 $1$ 。