L2-3 锦标赛（C++转载）

有 2k 名选手将要参加一场锦标赛。锦标赛共有 k 轮，其中第 i 轮的比赛共有 2k−i 场，每场比赛恰有两名选手参加并从中产生一名胜者。每场比赛的安排如下：

• 对于第 1 轮的第 j 场比赛，由第 (2j−1) 名选手对抗第 2j 名选手。
• 对于第 i 轮的第 j 场比赛（i>1），由第 (i−1) 轮第 (2j−1) 场比赛的胜者对抗第 (i−1) 轮第 2j 场比赛的胜者。

第 k 轮唯一一场比赛的胜者就是整个锦标赛的最终胜者。
举个例子，假如共有 8 名选手参加锦标赛，则比赛的安排如下：

• 第 1 轮共 4 场比赛：选手 1 vs 选手 2，选手 3 vs 选手 4，选手 5 vs 选手 6，选手 7 vs 选手 8。
• 第 2 轮共 2 场比赛：第 1 轮第 1 场的胜者 vs 第 1 轮第 2 场的胜者，第 1 轮第 3 场的胜者 vs 第 1 轮第 4 场的胜者。
• 第 3 轮共 1 场比赛：第 2 轮第 1 场的胜者 vs 第 2 轮第 2 场的胜者。

已知每一名选手都有一个能力值，其中第 i 名选手的能力值为 ai​。在一场比赛中，若两名选手的能力值不同，则能力值较大的选手一定会打败能力值较小的选手；若两名选手的能力值相同，则两名选手都有可能成为胜者。

令 li,j​ 表示第 i 轮第 j 场比赛 败者 的能力值，令 w 表示整个锦标赛最终胜者的能力值。给定所有满足 1≤i≤k 且 1≤j≤2k−i 的 li,j​ 以及 w，请还原出 a1​,a2​,⋯,an​。

输入格式:

第一行输入一个整数 k（1≤k≤18）表示锦标赛的轮数。
对于接下来 k 行，第 i 行输入 2k−i 个整数 li,1​,li,2​,⋯,li,2k−i​（1≤li,j​≤109），其中 li,j​ 表示第 i 轮第 j 场比赛 败者 的能力值。
接下来一行输入一个整数 w（1≤w≤109）表示锦标赛最终胜者的能力值。

输出格式:

输出一行 n 个由单个空格分隔的整数 a1​,a2​,⋯,an​，其中 ai​ 表示第 i 名选手的能力值。如果有多种合法答案，请输出任意一种。如果无法还原出能够满足输入数据的答案，输出一行 No Solution。
请勿在行末输出多余空格。

输入样例1:

3
4 5 8 5
7 6
8
9

输出样例1:

7 4 8 5 9 8 6 5

输入样例2:

2
5 8
3
9

输出样例2:

No Solution

提示:

本题返回结果若为格式错误均可视为答案错误。

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

#define N (3e5)
#define MAX(a, b) ((a) > (b) ? (a) : (b))

struct tree {
    int l, r, mx;
    bool have; // 下面的点有没有全填过
};

struct tree tr[N << 2];

int a[N]; // 答案数组
bool flag = false, st; // flag判是否可行，st判是否在某轮填了数字

void up(int rt) {
    // 更新最大值和有没有填过
    tr[rt].mx = MAX(tr[rt << 1].mx, tr[rt << 1 | 1].mx);
    tr[rt].have = tr[rt << 1].have && tr[rt << 1 | 1].have;
}

void build(int rt, int l, int r) {
    // 建树
    tr[rt] = (struct tree){l, r};
    if (l == r) {
        tr[rt].mx = a[l];
        if (a[l] > 0)
            tr[rt].have = true;
        return;
    }
    int mid = (l + r) / 2;
    build(rt << 1, l, mid);
    build(rt << 1 | 1, mid + 1, r);
    up(rt);
}

void modify(int rt, int l, int r, int pos) {
    if (!st)
        return; // 塞过了
    if (tr[rt].have)
        return; // 这个区间下面的点全部填过了
    if (tr[rt].l > r || tr[rt].r < l)
        return; // 不是要改的区间

    if (tr[rt].l == l && tr[rt].r == r && tr[rt].mx > pos)
        return; // 这个区间要的最大值给不起

    // 不合法的全去掉了
    if (tr[rt].l == tr[rt].r) { // 到达底端
        a[tr[rt].l] = pos; // 直接改掉，输出的时候方便；
        tr[rt].mx = pos;
        tr[rt].have = true;
        st = false;
        return;
    }

    modify(rt << 1, l, r, pos);
    modify(rt << 1 | 1, l, r, pos);
    up(rt);
}

int main() {
    int n;
    scanf("%d", &n);

    for (int i = 1; i <= (1 << n); i += 2) { // 第一轮直接放进去
        scanf("%d", &a[i]);
    }

    build(1, 1, (1 << n));

    int add = 4; //

    for (int i = n - 2; i >= 0; i--) { // 差几轮
        for (int j = 1; j <= (1 << n); j += add) { // 每轮填的数
            int pos;
            scanf("%d", &pos);

            if (flag)
                continue; // 已经不可能了

            int l = j, r = j + add - 1;
            int mid = (l + r) / 2;
            st = true; // 表示还没塞
            modify(1, l, mid, pos);
            if (st)
                modify(1, mid + 1, r, pos); // 前面不行
            if (st)
                flag = true; // 都不行
        }
        add *= 2; // 区间间隔增加
    }

    int pos;
    scanf("%d", &pos); // 最后看胜者是不是最大
    if (pos <= tr[1].mx)
        flag = true;
    if (flag)
        printf("No Solution");
    else {
        for (int i = 1; i <= (1 << n); i++) {
            if (a[i])
                printf("%d ", a[i]);
            else
                printf("%d ", pos);
        }
    }
    return 0;
}