結果

問題 No.3284 Picnic with Friends
ユーザー lif4635
提出日時 2025-09-26 22:14:39
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 6,763 ms / 7,000 ms
コード長 6,181 bytes
コンパイル時間 1,344 ms
コンパイル使用メモリ 130,736 KB
実行使用メモリ 16,644 KB
最終ジャッジ日時 2025-09-26 22:16:08
合計ジャッジ時間 85,843 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 25
権限があれば一括ダウンロードができます

ソースコード

diff # 

// # input

// import sys

// input = sys.stdin.readline

// II = lambda : int(input())

// MI = lambda : map(int, input().split())

// LI = lambda : [int(a) for a in input().split()]

// SI = lambda : input().rstrip()

// LLI = lambda n : [[int(a) for a in input().split()] for _ in range(n)]

// LSI = lambda n : [input().rstrip() for _ in range(n)]

// MI_1 = lambda : map(lambda x:int(x)-1, input().split())

// LI_1 = lambda : [int(a)-1 for a in input().split()]



// mod = 998244353

// inf = 1001001001001001001

// ordalp = lambda s : ord(s)-65 if s.isupper() else ord(s)-97

// ordallalp = lambda s : ord(s)-39 if s.isupper() else ord(s)-97

// yes = lambda : print("Yes")

// no = lambda : print("No")

// yn = lambda flag : print("Yes" if flag else "No")



// prinf = lambda ans : print(ans if ans < 1000001001001001001 else -1)

// alplow = "abcdefghijklmnopqrstuvwxyz"

// alpup = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

// alpall = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// URDL = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}

// DIR_4 = [[-1,0],[0,1],[1,0],[0,-1]]

// DIR_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]

// DIR_BISHOP = [[-1,1],[1,1],[1,-1],[-1,-1]]

// prime60 = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59]

// sys.set_int_max_str_digits(0)

// # sys.setrecursionlimit(10**6)

// # import pypyjit

// # pypyjit.set_param('max_unroll_recursion=-1')



// from collections import defaultdict,deque

// from heapq import heappop,heappush

// from bisect import bisect_left,bisect_right

// DD = defaultdict

// BSL = bisect_left

// BSR = bisect_right





// n = II()

// s = LI()



// now = []

// q = II()

// for i in range(q):

//     t, f = MI()

//     if now and t <= now[-1][0]:

//         now[-1][0] += f

//         now[-1][1] += f

//     else:

//         now.append([t+f, f])



// ss = sorted(s)

// qry = [0] * (n + 1)

// for t, x in now:

//     r = x

//     while r:

//         q = x // r

//         l = x // (q + 1)

//         qry[BSR(ss, l)] += q

//         qry[BSR(ss, r)] -= q

//         r = l



// for i in range(n):

//     qry[i+1] += qry[i]



// for x in s:

//     print(qry[BSR(ss, x) - 1])


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

using namespace std;

// Custom input functions (similar to the Python ones for convenience)
long long II() {
    long long n;
    cin >> n;
    return n;
}

vector<long long> LI() {
    long long n;
    // Assuming the user will provide 'n' items to read
    // This function will read until a newline or non-integer
    vector<long long> v;
    while (cin.peek() != '\n' && cin.peek() != EOF) {
        if (!(cin >> n)) break;
        v.push_back(n);
    }
    return v;
}

// Function to find the index of the first element in v that is greater than val.
// This is equivalent to Python's bisect_right (BSR).
long long bisect_right(const vector<long long>& v, long long val) {
    return upper_bound(v.begin(), v.end(), val) - v.begin();
}

void solve() {
    // Read n
    long long n = II();

    // Read array s
    // In competitive programming, input reading usually needs to be fast.
    // If the LI() implementation is problematic, the standard loop is safer.
    // Let's use a standard read for s since the number of elements is n.
    vector<long long> s(n);
    for (long long i = 0; i < n; ++i) {
        cin >> s[i];
    }

    // Read q
    long long q = II();

    // The 'now' list/vector stores pairs [t+f, f]
    vector<pair<long long, long long>> now;

    for (long long i = 0; i < q; ++i) {
        long long t, f;
        if (!(cin >> t >> f)) break; // Read t and f

        if (!now.empty() && t <= now.back().first) {
            // Update the last element
            now.back().first += f;
            now.back().second += f;
        } else {
            // Append a new element
            now.push_back({t + f, f});
        }
    }

    // Create a sorted copy of s
    vector<long long> ss = s;
    sort(ss.begin(), ss.end());

    // qry is a difference array, initialized to 0, size n+1
    // The size n+1 is for boundary conditions.
    vector<long long> qry(n + 1, 0);

    // Process the 'now' queries
    for (const auto& p : now) {
        long long t = p.first; // Not directly used in the C++ logic equivalent
        long long x = p.second;

        long long r = x;
        while (r > 0) {
            // Equivalent to: q = x // r
            long long q_val = x / r;

            // Equivalent to: l = x // (q + 1)
            long long l_val = x / (q_val + 1);

            // Update the difference array qry using bisect_right (upper_bound)
            // qry[BSR(ss, l)] += q
            long long l_index = bisect_right(ss, l_val);
            if (l_index < n + 1) { // Check for bounds (should be safe with n+1 size)
                 qry[l_index] += q_val;
            }


            // qry[BSR(ss, r)] -= q
            long long r_index = bisect_right(ss, r);
            if (r_index < n + 1) {
                qry[r_index] -= q_val;
            }

            // r = l
            r = l_val;
        }
    }

    // Convert the difference array to a prefix sum array (cumulative sum)
    for (long long i = 0; i < n; ++i) {
        qry[i + 1] += qry[i];
    }

    // Output the result for each element in the original array s
    for (long long x : s) {
        // BSR(ss, x) returns the index of the first element > x, or n if all are <= x.
        // The index needed for the result is BSR(ss, x) - 1, which corresponds
        // to the cumulative effect up to the position *before* x in the sorted array.
        long long index = bisect_right(ss, x);
        if (index > 0) {
            cout << qry[index - 1] << endl;
        } else {
            // This case should ideally not happen for valid inputs, as the index
            // will be at least 1 for any element in s.
            cout << 0 << endl; 
        }
    }
}

int main() {
    // Optimization for faster I/O operations
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    solve();

    return 0;
}
0