题解：CodeForces 1511 C Yet Another Card Deck[暴力/模拟]

CodeForces 1511C

C. Yet Another Card Deck

Description

You have a card deck of \(n\) cards, numbered from top to bottom, i. e. the top card has index \(1\) and bottom card — index \(n\). Each card has its color: the \(i\)-th card has color \(a_i\).

You should process \(q\) queries. The \(j\)-th query is described by integer \(t_j\). For each query you should:

• find the highest card in the deck with color \(t_j\), i. e. the card with minimum index;
• print the position of the card you found;
• take the card and place it on top of the deck.

Input

The first line contains two integers \(n\) and \(q\) (\(2 \le n \le 3 \cdot 10^5\); \(1 \le q \le 3 \cdot 10^5\)) — the number of cards in the deck and the number of queries.

The second line contains \(n\) integers \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 50\)) — the colors of cards.

The third line contains \(q\) integers \(t_1, t_2, \dots, t_q\) (\(1 \le t_j \le 50\)) — the query colors. It's guaranteed that queries ask only colors that are present in the deck.

Output

Print \(q\) integers — the answers for each query.

Example

input

7 5
2 1 1 4 3 3 1
3 2 1 1 4

output

5 2 3 1 5 

Note

Description of the sample:

1. the deck is \([2, 1, 1, 4, \underline{3}, 3, 1]\) and the first card with color \(t_1 = 3\) has position \(5\);
2. the deck is \([3, \underline{2}, 1, 1, 4, 3, 1]\) and the first card with color \(t_2 = 2\) has position \(2\);
3. the deck is \([2, 3, \underline{1}, 1, 4, 3, 1]\) and the first card with color \(t_3 = 1\) has position \(3\);
4. the deck is \([\underline{1}, 2, 3, 1, 4, 3, 1]\) and the first card with color \(t_4 = 1\) has position \(1\);
5. the deck is \([1, 2, 3, 1, \underline{4}, 3, 1]\) and the first card with color \(t_5 = 4\) has position \(5\).

我的解法

我的做法是：
首先把数组反置（这样的话数组的前面就是原来的后面，现在的后面就是原来的前面）
这样做的话我就可以直接在后面放置数字（实际上是放在数组的前面）
再使用一个数据结构

std::map<int,std::priority_queue<int> >

map的first是存储一种数字，second是存储这种数字对应的下标,默认是从大到小排
应该能把优先队列优化掉的，但是这样做也行（得到下标最大）
然后再放记录一个位置是否为空的前缀和数组，每次移动都维护一次
算位置的时候就计算：移动后位置 - 移动前位置 - 移动前位置所在下标的前缀和数组的内容和末尾内容的差值
就得到这个数字移动前的位置了

我的代码

#include <iostream>
#include <queue>
#include <map>
#include <algorithm>

#define int long long

int t;
const int N = 1e7 + 10;
int a[N];
int kong[N];

void solve()
{
    std::map<int,std::priority_queue<int> > mp;

    int n,q;
    std::cin >> n >> q;

    for(int i = n ; i > 0 ; i --)
    {
        std::cin >> a[i];
        mp[a[i]].push(i);
    }

    int index = n+1;
    while(q--)
    {
        kong[index] = kong[index-1];

        int txt;
        std::cin >> txt;

        int yuan = mp[txt].top();
        mp[txt].pop();
        mp[txt].push(index);
        a[index] = txt;

        int temp = yuan;
        while(temp <= index) kong[temp]++,temp++;

        std::cout << index - yuan - (kong[index] - kong[yuan]) << " ";

        index ++;
    }
}

signed main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    t = 1;
    //std::cin >> t;
    while(t--)
    {
        solve();
    }
    return 0;
}

---

---

有什么出现纰漏的地方还请大家在评论区指出！谢谢！