Codeforces Round 1019 div2 个人题解（2103D）_codeforces1019div2-优快云博客

本文链接：https://blog.youkuaiyun.com/Lazy_ChessPlayer/article/details/147405715

Codeforces Round 1019 (Div. 2)个人题解（2103D ）

题目翻译

数组 $b_1, b_2, \ldots, b_m$ 中的元素 $b_i$ ( $1\le i\le m$ ) 是局部最小值，如果以下条件至少有一个成立：

$2\le i\le m - 1$ 和 $b_i \lt b_{i - 1}$ 和 $b_i \lt b_{i + 1}$ ，或
$i = 1$ 和 $b_1 \lt b_2$ ，或
$i = m$ 和 $b_m \lt b_{m - 1}$ 。

同样地，如果以下条件至少有一个成立，那么数组 $b_1, b_2, \ldots, b_m$ 中的元素 $b_i$ ( $1\le i\le m$ )就是局部最大值：

$2\le i\le m - 1$ 、 $b_i \gt b_{i - 1}$ 和 $b_i \gt b_{i + 1}$ ，或
$i = 1$ 和 $b_1 \gt b_2$ ，或
$i = m$ 和 $b_m \gt b_{m - 1}$ 。

请注意，只有一个元素的数组不定义局部最小值和最大值。

有一个隐藏的 ${排列}^{\text{∗}}$ $p$ 长度为 $n$ 。从操作 1 开始，交替对排列 $p$ 进行以下两次操作，直到 $p$ 中只剩下一个元素：

操作 1 - 删除 $p$ 中所有不是局部最小值的元素。
操作 2 - 删除 $p$ 中所有不是局部最大值的元素。

更具体地说，操作 1 在每次奇数迭代中执行，操作 2 在每次偶数迭代中执行，直到 $p$ 中只剩下一个元素。

对于每个索引 $i$ ( $1\le i\le n$ )，设 $a_i$ 为元素 $p_i$ 被删除的迭代次数，如果从未删除，则为 $- 1$ 。

可以证明， $p$ 中最多经过 $\lceil \log_2 n\rceil$ 次迭代(换句话说， $a_i \le \lceil \log_2 n\rceil$ 次迭代)就只剩下一个元素。

给你一个数组 $a_1, a_2, \ldots, a_n$ 。你的任务是构造出满足数组 $a$ 的 $n$ 元素的任意排列 $p$ 。

$^{\text{∗}}$ 长度为 $n$ 的排列是由 $n$ 个不同的整数组成的数组，这些整数从 $1$ 到 $n$ 按任意顺序排列。例如， $[2, 3, 1, 5, 4]$ 是一个排列，但 $[1, 2, 2]$ 不是一个排列( $2$ 在数组中出现了两次)， $[1, 3, 4]$ 也不是一个排列( $n = 3$ ，但数组中有 $4$ )。

输入

每个测试包含多个测试用例。第一行包含测试用例的数量 $t$ ( $\le t \le 10^4$ )。测试用例说明如下。

每个测试用例的第一行都包含一个整数 $n$ ( $\le n \le 2 \cdot 10^5$ )–排列 $p$ 中的元素个数。

每个测试用例的第二行包含 $n$ 个整数 $a_1, a_2, \ldots, a_n$ ( $\le a_i \le \lceil\log_2 n\rceil$ 或 $a_i = -1$ )–元素 $p_i$ 被移除的迭代次数。

保证所有测试用例中 $n$ 的总和不超过 $\cdot 10^5$ 。

保证至少有一种排列 $p$ 满足数组 $a$ 。

输出

对于每个测试用例，输出 $n$ 个整数，这些整数代表满足排列数组 $a$ 的元素。

如果有多个解决方案，可以输出其中任何一个。

样例

输入

7
3
1 1 -1
5
1 -1 1 2 1
8
3 1 2 1 -1 1 1 2
7
1 1 1 -1 1 1 1
5
1 1 1 1 -1
5
-1 1 1 1 1
5
-1 1 2 1 2

输出

3 2 1
4 3 5 1 2
6 7 2 4 3 8 5 1
6 5 2 1 3 4 7
5 4 3 2 1
1 2 3 4 5
4 5 2 3 1

注

在第一个测试用例中，将对排列 $[3, 2, 1]$ 进行如下操作：

$[3, 2, 1]$ 中唯一的局部最小值是 $1$ 。因此，移除元素 $3$ 和 $2$ 。只剩下一个元素，因此过程结束。

这满足数组 $a = [1, 1, - 1]$ 的要求，因为 $p_1$ 和 $p_2$ 都在迭代次数 $1$ 中被删除，而 $p_3$ 没有被删除。

在第二个测试案例中，将对排列 $p = [4, 3, 5, 1, 2]$ 进行如下操作：

$[4, 3, 5, 1, 2]$ 中的局部最小值是 $3$ 和 $1$ 。因此，删除元素 $4$ 、 $5$ 和 $2$ 。
$[3, 1]$ 中唯一的局部最大值是 $3$ 。因此， $1$ 元素被删除。只剩下一个元素，因此过程结束。

由于元素 $p_1 = 4$ 、 $p_3 = 5$ 和 $p_5 = 2$ 在迭代 $1$ 中被删除，元素 $p_4 = 1$ 在迭代 $2$ 中被删除，元素 $p_2 = 3$ 没有被删除，因此满足数组 $a = [1, - 1, 1, 2, 1]$ 的要求。

在第三个测试案例中，将对排列 $[6, 7, 2, 4, 3, 8, 5, 1]$ 进行如下操作：

$[6, 7, 2, 4, 3, 8, 5, 1]$ 中的局部最小值是 $6$ 、 $2$ 、 $3$ 和 $1$ 。因此，删除元素 $7$ 、 $4$ 、 $8$ 和 $5$ 。
$[6, 2, 3, 1]$ 中的局部最大值是 $6$ 和 $3$ 。因此，元素 $2$ 和 $1$ 被删除。
$[6, 3]$ 中唯一的局部最小值是 $3$ 。因此， $6$ 元素被删除。只剩下一个元素，因此过程结束。

在第四个测试用例中，一个满足约束条件的排列是：[ $6$ , $5$ , $2$ , $1$ , $3$ , $4$ , $7$ }。 $1$ 是唯一的局部最小值，因此只有它能在第一次迭代后保持不变。请注意，还有其他有效的排列；例如，[ $6$ , $4$ , $3$ , $1$ , $2$ , $5$ , $7$ ] 也会被认为是正确的。

解题思路

读取题意后可知，在删除数字前，剩下的数字如果次序为奇数，一定会小于相邻的数字；如果次序为偶数，一定会大于相邻的数字。因此，我们可以倒着模拟删除的操作，从最后一次操作开始向对更高层和当前层的关系进行建边，每建完一层的边就将这两层进行合并。

写完之后发现，过不去样例一，因此进行打表，打表发现，由于边界的特殊性，同层之间存在根据次序奇偶性进行改变的大小关系，因此，还需要对同层之间进行建边。

建边关系为小向大，这样，得到的图的拓扑序即为题目索取排列。

解题代码

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL

bool check(const vi &p, const vi &a)
{
    int n = p.size() - 1;
    // order 存储当前未移除的下标序列，removed_round 记录每个下标被移除的轮次
    vi order(n);
    iota(order.begin(), order.end(), 1);
    vi removed_round(n + 1);
    int round = 1;
    // 每轮交替保留局部极值
    while (order.size() > 1)
    {
        vi nxt;
        bool isOdd = (round & 1);
        // 遍历当前序列，判断是否保留
        for (int idx = 0; idx < (int)order.size(); ++idx)
        {
            int i = order[idx];
            int val = p[i];
            // 求左右邻居值，边界处将自身加减 1，确保边界元素也能被正确判断
            int prev = (idx > 0 ? p[order[idx - 1]] : val + (isOdd ? 1 : -1));
            int next = (idx + 1 < (int)order.size() ? p[order[idx + 1]] : val + (isOdd ? -1 : 1));
            // 奇数轮保留局部最小值，偶数轮保留局部最大值
            bool keep = isOdd ? (val < prev && val < next)
                              : (val > prev && val > next);
            if (keep)
                nxt.push_back(i);
            else
                removed_round[i] = round;
        }
        order.swap(nxt);
        ++round;
    }
    // 最后一轮剩余的元素标记为 -1
    removed_round[order[0]] = -1;
    // 与目标轮次数组 a 对比
    for (int i = 1; i <= n; ++i)
    {
        if (removed_round[i] != a[i])
            return false;
    }
    return true;
}

void dabiao(const vi &a)
{
    int n = a.size() - 1;
    // 初始化排列 p 为 [1, 2, ..., n]
    vi p(n + 1);
    iota(p.begin() + 1, p.end(), 1);
    // 依次生成下一个排列，直到满足条件
    do
    {
        if (check(p, a))
        {
            // 输出结果
            for (int i = 1; i <= n; ++i)
                cout << p[i] << " \n"[i == n];
            return;
        }
    } while (next_permutation(p.begin() + 1, p.end()));
}

void solve()
{
    int n;
    cin >> n;
    vi a(n + 1);
    int end = 0;
    int mx = -1;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        if (a[i] == -1)
            end = i;
        mx = max(mx, a[i]);
    }
    mx++;
    a[end] = mx;
    vector<vi> pos(mx + 1);
    for (int i = 1; i <= n; i++)
    {
        pos[a[i]].push_back(i);
    }
    vector<vi> adj(n + 1);
    vi deg(n + 1);
    auto addEdge = [&](int u, int v)
    {
        adj[u].push_back(v);
        deg[v]++;
    };
    for (int i = mx - 1; i >= 1; i--)
    {
        // 1.同层之间进行建边
        // 打表发现，同层之间存在次序关系
        // 如果比上一层的一个数所在位置x小，则奇数层为递减关系，偶数层为递增关系
        // 如果比上一层的一个数所在位置x大，则奇数层为递增关系，偶数层为递减关系
        int x = pos[i + 1][0];
        int p = upper_bound(pos[i].begin(), pos[i].end(), x) - pos[i].begin();
        // 小于 x 的区域
        for (int j = 1; j < p; j++)
        {
            int u = pos[i][j - 1];
            int v = pos[i][j];
            // 偶数层为递减、奇数层为递增
            if (i & 1)
                swap(u, v);
            addEdge(u, v);
        }
        // 大于 x 的区域
        for (int j = p + 1; j < (int)pos[i].size(); j++)
        {
            int u = pos[i][j - 1];
            int v = pos[i][j];
            // 奇数层为递减、偶数层为递增
            if (i & 1)
                swap(u, v);
            addEdge(v, u);
        }

        // 2.不同层进行合并
        // 每次遍历完一层都需要向下一层合并（合并 pos[i+1] 与 pos[i] 到 pos[i]）
        vi temp(pos[i + 1].size() + pos[i].size());
        int idx = 0, p1 = 0, p2 = 0;
        while (p1 < (int)pos[i + 1].size() && p2 < (int)pos[i].size())
        {
            if (pos[i + 1][p1] < pos[i][p2])
                temp[idx++] = pos[i + 1][p1++];
            else
                temp[idx++] = pos[i][p2++];
        }
        while (p1 < (int)pos[i + 1].size())
            temp[idx++] = pos[i + 1][p1++];
        while (p2 < (int)pos[i].size())
            temp[idx++] = pos[i][p2++];
        pos[i].swap(temp);
        temp.clear();

        // 3. 不同层建边
        // 根据新层 i+1 与 i 的奇偶性
        for (int j = 0; j < (int)pos[i + 1].size(); j++)
        {
            int u = pos[i + 1][j];
            int r = upper_bound(pos[i].begin(), pos[i].end(), u) - pos[i].begin();
            int l = lower_bound(pos[i].begin(), pos[i].end(), u) - pos[i].begin() - 1;
            if (r < (int)pos[i].size())
            {
                int v = pos[i][r];
                if (i & 1)
                    addEdge(u, v);
                else
                    addEdge(v, u);
            }
            if (l >= 0)
            {
                int v = pos[i][l];
                if (i & 1)
                    addEdge(u, v);
                else
                    addEdge(v, u);
            }
        }
        pos[i + 1].clear();
    }

    // 计算拓扑序
    queue<int> q;
    int now = 1;
    vi p(n + 1);
    for (int i = 1; i <= n; i++)
    {
        if (deg[i] == 0)
        {
            q.push(i);
            p[i] = now++;
        }
    }
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (auto v : adj[u])
        {
            deg[v]--;
            if (deg[v] == 0)
            {
                q.push(v);
                p[v] = now++;
            }
        }
    }
    for (int i = 1; i <= n; i++)
    {
        cout << p[i] << " \n"[i == n];
    }
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：