Boris and His Amazing Haircut（数据结构 + 贪心）

题目链接

题目描述：

Boris thinks that chess is a tedious game. So he left his tournament early and went to a barber shop as his hair was a bit messy.

His current hair can be described by an array $a_1,a_2,\dots ,a_n$, where $a_i$ is the height of the hair standing at position $i$. His desired haircut can be described by an array $b_1,b_2,\dots ,b_n$ in a similar fashion.

The barber has $m$ razors. Each has its own size and can be used at most once. In one operation, he chooses a razor and cuts a segment of Boris's hair. More formally, an operation is:

• Choose any razor which hasn't been used before, let its size be $x$;
• Choose a segment $[l,r](1\le l\le r\le n)$;
• Set $a_i:=min(a_i,x)$ for each $l\le i\le r$;

Notice that some razors might have equal sizes — the barber can choose some size $x$ only as many times as the number of razors with size $x$.

He may perform as many operations as he wants, as long as any razor is used at most once and $a_i=b_i$ for each $1\le i\le n$ at the end. He does not have to use all razors.

Can you determine whether the barber can give Boris his desired haircut?

输入描述：

Each test contains multiple test cases. The first line contains the number of test cases $t(1\le t\le 20000)$. The description of the test cases follows.

The first line of each test case contains a positive integer $n(3\le n\le 2\cdot {10}^5)$ — the length of arrays $a$ and $b$.

The second line of each test case contains $n$ positive integers $a_1,a_2,\dots ,a_n(1\le a_i\le {10}^9)$ — Boris's current hair.

The third line of each test case contains $n$ positive integers $b_1,b_2,\dots ,b_n(1\le b_i\le {10}^9)$ — Boris's desired hair.

The fourth line of each test case contains a positive integer $m(1\le m\le 2\cdot {10}^5)$ — the number of razors.

The fifth line of each test case contains $m$ positive integers $x_1,x_2,\dots ,x_m(1\le x_i\le {10}^9)$ — the sizes of the razors.

It is guaranteed that the sum of $n$ and the sum of $m$ over all test cases do not exceed $2\cdot {10}^5$.

输出描述：

For each test case, print "YES" if the barber can cut Boris's hair as desired. Otherwise, print "NO".

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

样例：

input：

7
3
3 3 3
2 1 2
2
1 2
6
3 4 4 6 3 4
3 1 2 3 2 3
3
3 2 3
10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
10
1 2 3 4 5 6 7 8 9 10
3
1 1 1
1 1 2
12
4 2 4 3 1 5 6 3 5 6 2 1
13
7 9 4 5 3 3 3 6 8 10 3 2 5
5 3 1 5 3 2 2 5 8 5 1 1 5
8
1 5 3 5 4 2 3 1
13
7 9 4 5 3 3 3 6 8 10 3 2 5
5 3 1 5 3 2 2 5 8 5 1 1 5
7
1 5 3 4 2 3 1
3
19747843 2736467 938578397
2039844 2039844 2039844
1
2039844

output：

YES
NO
YES
NO
YES
NO
YES

Note:

In the first test case, Boris's hair is initially $[3,3,3]$. Let us describe a sequence of $2$ operations the barber can perform:

• The barber uses the razor with size $1$ on the segment $[2,2]$; hence Boris's hair becomes $[3,1,3]$.
• The barber uses the razor with size $2$ on the segment $[1,3]$; hence Boris's hair becomes $[2,1,2]$ which is the desired haircut.

In the third test case, no operation has to be done since Boris's hair is already as desired.

In the fourth test case, no cuts will be able to increase the third element in $[1,1,1]$ in a way that the array becomes $[1,1,2]$.

AC代码：

#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 2e5 + 10;
 
int T = 1;
int n, m;
int a[N];
int b[N];
 
// 要使a数组全部变成b数组，贪心的想，要用尽可能少的剃刀剃尽可能多的头发
// 这就需要将b数组看成多个区间，区间中相同的数只需要用一次剃刀就可以
// 区间中的数可以都一样，也可以有大有小，但是大的数必须在区间两边
// 否则区间中大的数会被小的数代替掉，就永远也达不到目标
void solve()
{
    scanf("%d", &n);
 
    for(int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
 
    for(int i = 1; i <= n; i ++)
        scanf("%d", &b[i]);
 
    scanf("%d", &m);
 
    map<int, int> x; // 用来存剃刀的数量，大小相同的放在一起
 
    for(int i = 1; i <= m; i ++)
    {
        int s;
        scanf("%d", &s);
 
        x[s] ++;
    }
 
    stack<int> q; // 单调栈，非严格单调递减地存储区间
 
    bool f = 1;
 
    for(int i = 1; i <= n; i ++)
    {
        if(a[i] < b[i]) // 剃过之后的头发比不可能比原来大，这种情况直接舍弃
        {
            printf("NO\n");
            return;
        }
 
        // 只要新的数小于等于栈顶的数，则可以存入这个区间
        // 如：2 1 1 2
        // 如：5 3 5
        while(q.size() && q.top() < b[i])
            q.pop();
 
        // a[i] == b[i]这种情况是不需要用任何剃刀的
        // 在a[i] != b[i]时，若栈顶的数等于新的数，就说明栈顶和新的数是同一区间的，就不需要用任何剃刀
        // 如上面两例中2 1 1 2 变成2 2，5 3 5 变成 5 5
        if((!q.size() || (q.size() && q.top() != b[i])) && a[i] != b[i])
        {
            q.push(b[i]);
 
            // 如果需要用剃刀但是剃刀已经被全使用过，则无法达到目的
            if(x[b[i]] <= 0)
            {
                printf("NO\n");
                return;
            }
 
            // 使用过一次后剃刀数量减一
            x[b[i]] --;
        }
    }
 
    printf("YES\n");
}
 
int main()
{
    scanf("%d", &T);
 
    while(T --)
        solve();
 
    return 0;
}