Submission #1308762

#	Time	Username	Problem	Language	Result	Execution time	Memory
1308762		orzorzorz	Gift Exchange (JOI24_ho_t4)	C++20	10 / 100	51 ms	32864 KiB

Main

/**
 * Problem: Gift Exchange (JOI 2024 Spring Camp / JOI24_ho_t4)
 * Solution: Sparse Table + Hall's Theorem
 * Complexity: O(N log N) Precomputation, O(1) per Query
 */

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;

// 数据规模最大值
const int MAXN = 500005;
const int LOGN = 20; // 2^19 > 500,000

int N, Q;
int A[MAXN], B[MAXN];
int lg[MAXN]; // 预处理 log2 值，加速查询

// 定义 ST 表
// st_max_b_idx[i][j]: 从 i 开始长度为 2^j 的区间内，B 值最大的下标
// st_min_b_idx[i][j]: 从 i 开始长度为 2^j 的区间内，B 值最小的下标
// st_max_a_val[i][j]: 从 i 开始长度为 2^j 的区间内，A 值的最大值
// st_min_b_val[i][j]: 从 i 开始长度为 2^j 的区间内，B 值的最小值
int st_max_b_idx[MAXN][LOGN];
int st_min_b_idx[MAXN][LOGN];
int st_max_a_val[MAXN][LOGN];
int st_min_b_val[MAXN][LOGN];

// 辅助函数：返回两个下标中 B 值较大的那个
int get_max_b_idx(int i, int j) {
    return (B[i] >= B[j]) ? i : j;
}

// 辅助函数：返回两个下标中 B 值较小的那个
int get_min_b_idx(int i, int j) {
    return (B[i] <= B[j]) ? i : j;
}

// 预处理 ST 表
void build_st() {
    lg[1] = 0;
    for (int i = 2; i <= N; i++)
        lg[i] = lg[i / 2] + 1;

    for (int i = 1; i <= N; i++) {
        st_max_b_idx[i][0] = i;
        st_min_b_idx[i][0] = i;
        st_max_a_val[i][0] = A[i];
        st_min_b_val[i][0] = B[i];
    }

    for (int j = 1; j < LOGN; j++) {
        for (int i = 1; i + (1 << j) - 1 <= N; i++) {
            int right = i + (1 << (j - 1));
            
            // 维护下标
            st_max_b_idx[i][j] = get_max_b_idx(st_max_b_idx[i][j - 1], st_max_b_idx[right][j - 1]);
            st_min_b_idx[i][j] = get_min_b_idx(st_min_b_idx[i][j - 1], st_min_b_idx[right][j - 1]);
            
            // 维护数值
            st_max_a_val[i][j] = max(st_max_a_val[i][j - 1], st_max_a_val[right][j - 1]);
            st_min_b_val[i][j] = min(st_min_b_val[i][j - 1], st_min_b_val[right][j - 1]);
        }
    }
}

// 查询区间 [L, R] 中 B 最大值的下标
int query_max_b_idx(int L, int R) {
    int k = lg[R - L + 1];
    return get_max_b_idx(st_max_b_idx[L][k], st_max_b_idx[R - (1 << k) + 1][k]);
}

// 查询区间 [L, R] 中 B 最小值的下标
int query_min_b_idx(int L, int R) {
    int k = lg[R - L + 1];
    return get_min_b_idx(st_min_b_idx[L][k], st_min_b_idx[R - (1 << k) + 1][k]);
}

// 查询区间 [L, R] 中 A 的最大值
int query_max_a_val(int L, int R) {
    if (L > R) return -1; // 非法区间处理
    int k = lg[R - L + 1];
    return max(st_max_a_val[L][k], st_max_a_val[R - (1 << k) + 1][k]);
}

// 查询区间 [L, R] 中 B 的最小值
int query_min_b_val(int L, int R) {
    if (L > R) return 2e9; // 非法区间处理
    int k = lg[R - L + 1];
    return min(st_min_b_val[L][k], st_min_b_val[R - (1 << k) + 1][k]);
}

int main() {
    // 优化 I/O 速度
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    if (!(cin >> N)) return 0;

    for (int i = 1; i <= N; ++i) cin >> A[i];
    for (int i = 1; i <= N; ++i) cin >> B[i];

    build_st();

    cin >> Q;
    while (Q--) {
        int L, R;
        cin >> L >> R;

        // 1. 检查接收方瓶颈 (Receiver Bottleneck)
        // 找出最挑剔的人 (B 最大)
        int idx_max_b = query_max_b_idx(L, R);
        int val_max_b = B[idx_max_b];
        
        // 在除了这个人的群体中，找最大的礼物价值 A
        // 查询范围是 [L, idx-1] 和 [idx+1, R]
        int max_a_others = max(query_max_a_val(L, idx_max_b - 1), query_max_a_val(idx_max_b + 1, R));

        // 如果其他人最大的 A 都小于这个人的 B，那他收不到满意的礼物
        if (max_a_others < val_max_b) {
            cout << "No\n";
            continue;
        }

        // 2. 检查发送方瓶颈 (Sender Bottleneck)
        // 找出需求最低的人 (B 最小，这通常意味着他的 A 也不高)
        int idx_min_b = query_min_b_idx(L, R);
        int val_a_source = A[idx_min_b]; // 这个人持有的礼物
        
        // 找出除了这个人以外，需求最低的人 (即区间内第二小的 B)
        int min_b_others = min(query_min_b_val(L, idx_min_b - 1), query_min_b_val(idx_min_b + 1, R));
        
        // 如果这个人的 A 连第二小的 B 都满足不了，那他只能满足自己 (被禁止)，导致送不出去
        if (val_a_source < min_b_others) {
            cout << "No\n";
            continue;
        }

        // 两个检查都通过，则可行
        cout << "Yes\n";
    }

    return 0;
}

• Subtask 1: 0 / 4
• Subtask 2: 0 / 5
• Subtask 3: 10 / 10
• Subtask 4: 0 / 31
• Subtask 5: 0 / 8
• Subtask 6: 0 / 12
• Subtask 7: 0 / 18
• Subtask 8: 0 / 12