Problem:
鐘 (Bell)
問題文
JOI 市には
1
本の十分に長い道路がある．この道路は数直線とみなすことができ，各地点は
1
個の実数による座標で表される．
また，JOI 市にはこの道路に沿って
N
個の鐘があり，座標の小さい順に
1
から
N
までの番号が付けられている．鐘
i
(
1 ≦ i ≦ N
) は座標
A
i
にある．
JOI 市では，
1
年の終わりにこれらの鐘を一斉に鳴らすのが一大イベントとなっている．
どの鐘も，鳴らすとその鐘と同じ地点では強さ
K
の音で聞こえるが，距離が
1
離れるごとに聞こえる音の強さは
1
小さくなり，距離が
K
以上離れると
0
になる．すなわち，鐘
i
を鳴らしたとき，座標
x
で聞こえる鐘
i
の音の強さは
max\{ K - |x - A
i
|, 0 \}
である．ただし，
|t|
は
t
の絶対値を表す．
すべての鐘を鳴らしたとき，座標
x
で聞こえる鐘の音の強さは，座標
x
で聞こえるそれぞれの鐘の音の強さの最大値である．
JOI 市にはこの道路に沿って
M
個の家があり，古い方から順に
1
から
M
までの番号が付けられている．家
j
(
1 ≦ j ≦ M
) は座標
B
j
にある．
JOI 市の市長であるあなたは，すべての鐘を鳴らしたとき，それぞれの家で聞こえる鐘の音の強さを知りたい．
JOI 市の鐘と家の情報が与えられたとき，すべての鐘を鳴らしたときに座標
B
1
, B
2
, …, B
M
で聞こえる鐘の音の強さを求めるプログラムを作成せよ．
制約
1 ≦ N ≦ 250000
．
1 ≦ M ≦ 250000
．
1 ≦ K ≦ 10
9
．
0 ≦ A
i
≦ 10
9
(
1 ≦ i ≦ N
)．
A
i
＜ A
i+1
(
1 ≦ i ≦ N - 1
)．
0 ≦ B
j
≦ 10
9
(
1 ≦ j ≦ M
)．
B
j
≠ B
k
(
1 ≦ j ＜ k ≦ M
)．
入力される値はすべて整数である．
入力
入力は以下の形式で与えられる．
N
M
K
A
1
A
2
…
A
N
B
1
B
2
…
B
M
出力
M
行出力せよ．
j
行目 (
1 ≦ j ≦ M
) には，すべての鐘を鳴らしたときに座標
B
j
で聞こえる鐘の音の強さを出力せよ．
入出力例
入力例 1
1 5 10
20
20 15 28 10 32
出力例 1
10
5
2
0
0
この入力例では，座標
20
に鐘
1
がある．
鐘
1
を鳴らしたとき，座標
20
で聞こえる鐘
1
の音の強さは
max\{ 10 - |20 - 20|, 0 \} = 10
である．したがって，
1
行目には
10
を出力する．
鐘
1
を鳴らしたとき，座標
15
で聞こえる鐘
1
の音の強さは
max\{10 - |15 - 20|, 0 \} = 5
である．したがって，
2
行目には
5
を出力する．
鐘
1
を鳴らしたとき，座標
28
で聞こえる鐘
1
の音の強さは
max\{10 - |28 - 20|, 0 \} = 2
である．したがって，
3
行目には
2
を出力する．
鐘
1
を鳴らしたとき，座標
10
で聞こえる鐘
1
の音の強さは
max\{10 - |10 - 20|, 0 \} = 0
である．したがって，
4
行目には
0
を出力する．
鐘
1
を鳴らしたとき，座標
32
で聞こえる鐘
1
の音の強さは
max\{10 - |32 - 20|, 0 \} = 0
である．したがって，
5
行目には
0
を出力する．
入力例 2
3 4 100
116 194 258
57 155 222 360
出力例 2
41
61
72
0
鐘
1,2,3
を鳴らしたとき，座標
57
で聞こえる音の強さはそれぞれ
41,0,0
である．したがって，すべての鐘を鳴らしたときに座標
57
で聞こえる音の強さはこれらの最大値である
41
である．そのため，
1
行目には
41
を出力する．
鐘
1,2,3
を鳴らしたとき，座標
155
で聞こえる音の強さはそれぞれ
61,61,0
である．したがって，すべての鐘を鳴らしたときに座標
155
で聞こえる音の強さはこれらの最大値である
61
である．そのため，
2
行目には
61
を出力する．
鐘
1,2,3
を鳴らしたとき，座標
222
で聞こえる音の強さはそれぞれ
0,72,64
である．したがって，すべての鐘を鳴らしたときに座標
222
で聞こえる音の強さはこれらの最大値である
72
である．そのため，
3
行目には
72
を出力する．
鐘
1,2,3
を鳴らしたとき，座標
360
で聞こえる音の強さはそれぞれ
0,0,0
である．したがって，すべての鐘を鳴らしたときに座標
360
で聞こえる音の強さはこれらの最大値である
0
である．そのため，
4
行目には
0
を出力する．
入力例 3
10 10 10000
589 2398 6567 28817 29177 31636 45468 66751 82282 97509
2196 54498 80474 61644 18007 38759 85590 72172 79533 69959
出力例 3
9798
970
8192
4893
0
3291
6692
4579
7251
6792
情報オリンピック日本委員会
作 『日本情報オリンピック第3回女性部門 本選 競技課題』

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

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

    int N, M;
    long long K;
    cin >> N >> M >> K;

    vector<long long> A(N);
    for(int i = 0; i < N; i++) cin >> A[i];

    vector<pair<long long,int>> B(M);
    for(int i = 0; i < M; i++){
        cin >> B[i].first;
        B[i].second = i;
    }

    // 出力用配列
    vector<long long> ans(M);

    // Aは昇順なので、家の座標ごとに近い鐘の場所を二分探索
    for (auto& [pos, idx] : B) {
        // 下限検索でpos以上の最小の鐘の位置を探す
        int p = (int)(lower_bound(A.begin(), A.end(), pos) - A.begin());

        long long res = 0;
        // 鐘pが存在すれば音の強さ計算
        if (p < N) {
            long long dist = abs(A[p] - pos);
            if (dist < K) res = max(res, K - dist);
        }
        // 鐘p-1も音の強さ計算
        if (p - 1 >= 0) {
            long long dist = abs(A[p - 1] - pos);
            if (dist < K) res = max(res, K - dist);
        }

        ans[idx] = res;
    }

    // 順番に出力
    for(int i = 0; i < M; i++){
        cout << ans[i] << "\n";
    }

    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 10828
final_rank: 4

code_snippet: #include <iostream>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <cstdlib>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

int main(){
  int n,m,k;
  cin >> n >> m >> k;
  vector<int> a(n);
  rep(i,n){
    cin >> a[i];
  }
  vector<int> b(m);
  rep(i,m){
    cin >> b[i];
  }

  rep(i,m){
    auto it=lower_bound(a.begin(),a.end(),b[i]);
    int j=it-a.begin();
    
    int res=k;
    if(j==0){
      res -= a[0]-b[i];
    }
    else if(j<n){
      res -= min(a[j]-b[i],b[i]-a[j-1]);
    }
    else{
      res -= b[i]-a[n-1];
    }
    res = max(res,0);
    cout << res << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 300
memory_kb: 4924
final_rank: 11

code_snippet: #include <iostream>
#include <map>

using namespace std;

int main()
{
    std::map<int, int> A;
    int N, M, K;
    int a, B;
    int bell;

    cin >> N >> M >> K;
    for (int i = 0; i < N; i++){
        cin >> a;
        A.insert(make_pair(a, a));
    }

    for (int i = 0; i < M; i++){
        cin >> B;
        decltype(A)::iterator it = A.lower_bound(B);
        if (it == A.begin()){
            // cout << "begin" << endl;
            bell = it->first - B;
            //  cout << "1:" << it->first << endl;
        }
        else if (it == A.end()){
            // cout << "end" << endl;    
            bell = B - (--it)->first;
            //  cout << "2:" << it->first << endl;
        }
        else {
            int k1 = it->first;
            int k2 = (--it)->first;
            // cout << "k " << k1 << "," << k2 << endl;
            if (k1 - B < B - k2){
                bell = k1 - B;
                // cout << "3:" << it->first << endl;
            }
            else {
                bell = B - k2;
                // cout << "4:" << it->first << endl;
            }
        }
        if (K - bell <= 0){
            cout << 0 << endl;
        }
        else {
            cout << K - bell << endl;
        }
    }

    return (0);
}
accuracy: 1
time_ms: 380
memory_kb: 15136
final_rank: 17

code_snippet: #include <vector>
#include <string>
#include <deque>
#include <tuple>
#include <climits>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <random>
#include <cfloat>
#include <set>
#include <queue>
#include <cmath>
#include <algorithm>
#include <variant>
#include <bitset>
#include <unordered_map>
#include <array>
#include <cmath>
#include <map>
#include <optional>
#include <cassert>
#include <filesystem>
#include <mutex>
#include <thread>
#include <functional>
#include <fstream>
#include <chrono>
#include <stack>
#include <array>


int main() {
	int n, m, k; std::cin >> n >> m >> k;
	std::vector<int> bellPosition(n);
	for (auto& a : bellPosition) {
		std::cin >> a;
	}
	std::vector<int> housePosition(m);
	for (auto& b : housePosition) {
		std::cin >> b;
	}
	for (const auto b : housePosition) {
		const auto next{ std::lower_bound(bellPosition.begin(), bellPosition.end(), b) };
		int max{ 0 };
		if (next != bellPosition.end()) {
			max = std::max(max, k - *next + b);
		}
		if (next != bellPosition.begin()) {
			max = std::max(max, k - b + *std::prev(next));
		}
		std::cout << max << '\n';
	}
}
accuracy: 1
time_ms: 140
memory_kb: 4788
final_rank: 5

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
#define FOR(i,l,r) for(ll i=l;i<r;i++)
#define REP(i,n) FOR(i,0,n)
#define sz(A) ((ll)A.size())
#define ALL(A) A.begin(),A.end()
int main(){
    int N,M,K;cin>>N>>M>>K;
    vector<int>A(N);
    REP(i,N)cin>>A[i];
    while(M--){
        int x;cin>>x;
        int t=lower_bound(ALL(A),x)-A.begin();
        int d=1e9;
        if(t<N)d=min(d,A[t]-x);
        if(t)d=min(d,x-A[t-1]);
        cout<<max(0,K-d)<<endl;
    }
    return 0;
}
accuracy: 1
time_ms: 300
memory_kb: 4136
final_rank: 9

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

int main() {
    int N, M, K;
    
    // 入力を受け取る
    cin >> N >> M >> K;
    
    vector<int> A(N), B(M);
    
    for (int i = 0; i < N; ++i) {
        cin >> A[i];
    }
    
    for (int i = 0; i < M; ++i) {
        cin >> B[i];
    }
    
    // 各家の座標について計算
    for (int j = 0; j < M; ++j) {
        int bj = B[j];
        
        // 二分探索で鐘の座標Aの中で最も近い鐘を探す
        auto it = lower_bound(A.begin(), A.end(), bj);
        
        int max_sound = 0;
        
        // 現在の家の座標から近い鐘を確認し、音の強さを計算する
        if (it != A.end()) {
            max_sound = max(max_sound, K - abs(*it - bj));
        }
        
        if (it != A.begin()) {
            --it;
            max_sound = max(max_sound, K - abs(*it - bj));
        }
        
        cout << max_sound << endl;
    }
    
    return 0;
}
accuracy: 1
time_ms: 290
memory_kb: 4908
final_rank: 8

code_snippet: #include <bits/stdc++.h>

using namespace std;


int main(void)
{
	int N, M, K; cin >> N >> M >> K;
	vector<int> A(N), B(M);
	for (auto& x: A) cin >> x;
	for (auto& x: B) cin >> x;

	// For lower_bound() prev() - need at least 1e9 away due to constraints
	A.insert(A.begin(), -1e9 - 1);
	A.insert(A.end(), 2e9 + 1);

	for (int i = 0; i < M; i++) {
		auto p = lower_bound(A.begin(), A.end(), B[i]);
		// Check against 2 closest values
		int d = min(*p - B[i], B[i] - *prev(p));

		cout << max(K - d, 0) << endl;
	}
}
accuracy: 1
time_ms: 290
memory_kb: 5896
final_rank: 10

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

using namespace std;

int main() {
    int N, M;
    long long K;
    cin >> N >> M >> K;

    vector<long long> A(N);
    for (int i = 0; i < N; ++i) {
        cin >> A[i];
    }

    vector<long long> B(M);
    for (int i = 0; i < M; ++i) {
        cin >> B[i];
    }

    // 結果を格納するベクトル
    vector<long long> result(M);

    // 各家の座標について計算
    for (int i = 0; i < M; ++i) {
        long long x = B[i];

        // 二分探索で最も近い鐘を見つける
        auto it = lower_bound(A.begin(), A.end(), x);

        long long max_strength = 0;

        if (it != A.end()) {
            // 右側の鐘
            max_strength = max(max_strength, K - abs(*it - x));
        }

        if (it != A.begin()) {
            // 左側の鐘
            --it;
            max_strength = max(max_strength, K - abs(*it - x));
        }

        result[i] = max_strength;
    }

    // 結果を出力
    for (int i = 0; i < M; ++i) {
        cout << result[i] << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 300
memory_kb: 8892
final_rank: 15

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	unsigned int N, M, K, i, B, dist;
	cin >> N >> M >> K;
	vector<unsigned int> A(N);
	for (i = 0; i != N; ++i) cin >> A[i];
	stable_sort(A.begin(), A.end());

	for (i = 0; i != M; ++i)
	{
		cin >> B;
		auto itr = lower_bound(A.begin(), A.end(), B);

		if (itr == A.begin()) dist = *itr - B;
		else if (itr == A.end()) dist = B - *prev(itr);
		else dist = min(*itr - B, B - *prev(itr));

		if (dist >= K) cout << "0\n";
		else cout << K - dist << '\n';
	}

	return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 4664
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;

using ll = long long;
using i64 = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using f128 = __float128;

template <class T>
constexpr T infty = 0;
template <>
constexpr int infty<int> = 1'000'001'000;
template <>
constexpr ll infty<ll> = ll(infty<int>) * infty<int> * 2;
template <>
constexpr u32 infty<u32> = infty<int>;
template <>
constexpr u64 infty<u64> = infty<ll>;
template <>
constexpr i128 infty<i128> = i128(infty<ll>) * infty<ll>;
template <>
constexpr double infty<double> = infty<ll>;
template <>
constexpr long double infty<long double> = infty<ll>;
#define inf infty<ll>

using pi = pair<ll, ll>;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vector<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <class T>
using vvvvvc = vector<vvvvc<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;

#define vv(type, name, h, ...) \
  vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define vvv(type, name, h, w, ...)   \
  vector<vector<vector<type>>> name( \
      h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)       \
  vector<vector<vector<vector<type>>>> name( \
      a, vector<vector<vector<type>>>(       \
             b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))

#define rep1(a) for (ll _ = 0; _ < (ll)(a); ++_)
#define rep2(i, a) for (ll i = 0; i < (ll)(a); ++i)
#define rep3(i, a, b) for (ll i = a; i < (ll)(b); ++i)
#define rep4(i, a, b, c) for (ll i = a; i < (ll)(b); i += (c))
#define rrep1(a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep2(i, a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep3(i, a, b) for (ll i = (b)-1; i >= (ll)(a); --i)
#define rrep4(i, a, b, c) for (ll i = (b)-1; i >= (ll)(a); i -= (c))
#define overload4(a, b, c, d, e, ...) e
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)

#define all(x) (x).begin(),(x).end()
#define len(x) (ll)(x.size())
#define elif else if
#define bit(x, i) (((x)>>(i))&1)

#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second

#define stoi stoll
#define abs llabs

#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define LB(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define UB(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define UNIQUE(x) \
  sort(all(x)), x.erase(unique(all(x)), x.end()), x.shrink_to_fit()

ll popcnt(ll x) { return __builtin_popcountll(x); }
ll popcnt(u64 x) { return __builtin_popcountll(x); }
ll popcnt_mod_2(ll x) { return __builtin_parityll(x); }
ll popcnt_mod_2(u64 x) { return __builtin_parityll(x); }
ll topbit(ll x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll topbit(u64 x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll lowbit(ll x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }
ll lowbit(u64 x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }

template<typename T> T SUM(const vector<T> &A) {
  T s = 0; for (auto &&a: A) s += a;
  return s;
}

template<typename T> inline bool chmax(T &a, T b) {return ((a<b)?(a=b,true):(false));}
template<typename T> inline bool chmin(T &a, T b) {return ((a>b)?(a=b,true):(false));}

#define endl '\n'
#define _onez(s) ((s)? 1 : 0)
#define _Yes(s) ((_onez(s)==1)? "Yes" : "No")
#define _YES(s) ((_onez(s)==1)? "YES" : "NO")
#define onez(s) {cout << _onez(s) << '\n';}
#define Yes(s) {cout << _Yes(s) << '\n';}
#define YES(s) {cout << _YES(s) << '\n';}

int solve();
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  while (!solve()) {break;}
  return 0;
}

int solve() {
  ll N, M, K;
  cin >> N >> M >> K;
  vi A(N), B(M);
  set<ll> Bs;
  rep(i, N) cin >> A[i];
  rep(i, M) {
    cin >> B[i];
    Bs.insert(B[i]);
  }
  vi v_inc, v_dec, v_fin;
  rep(i, N) {
    v_inc.eb(A[i]-K+1);
    v_dec.eb(A[i]+1);
  }
  ll i=0, j=0, i1=0, j1=0;
  map<ll, ll> ans;
  vi q_inc, q_dec;
  for (auto l : Bs) {
    while ((i < len(v_inc)) and (v_inc[i] <= l)) {
      q_inc.eb(i);
      i++;
    }
    while ((j < len(v_dec)) and (v_dec[j] <= l)) {
      q_dec.eb(j);
      j++;
      chmax(i1, j);
    }
    ans[l] = 0;
    if (!q_inc.empty()) {
      while ((i1+1 < len(q_inc)) and (A[i1]-l > A[i1+1]-l)) {
        i1++;
      }
      if ((i1 < len(q_inc)) and (A[i1]-l >= 0)) {
        chmax(ans[l], K-(A[i1]-l));
      }
    }
    if (!q_dec.empty()) {
      while ((j1+1 < len(q_dec)) and (l-A[j1] > l-A[j1+1])) {
        j1++;
      }
      chmax(ans[l], K-(l-A[j1]));
    }
  }
  rep(i, M) {
    cout << ans[B[i]] << '\n';
  }
  return 0;
}
accuracy: 1
time_ms: 290
memory_kb: 42224
final_rank: 18

code_snippet: #include <iostream>
using namespace std;

int get_index(int bell_x[], int left, int right, int x) {
    int mid = (right + left) / 2;
    if (right == left) return right;
    
    if (x < bell_x[mid]) {
        return get_index(bell_x, left, mid, x);
    }
    else if (x > bell_x[mid]) {
        return get_index(bell_x, mid + 1, right, x);
    }
    else {
        return mid;
    }
}


int main(void){
    // Your code here!
   int n, m, k;
   cin >> n >> m >> k;
   int bell_x[250000];
   int house_x[250000];
   for (int i = 0; i < n; i++) {
       cin >> bell_x[i];
   }
   for (int i = 0; i < m; i++) {
       cin >> house_x[i];
   }
   
   for (int i = 0; i < m; i++ ){
       int index = get_index(bell_x, 0, n, house_x[i]);
       int d = abs(house_x[i] - bell_x[index]);
       if (index != 0) {
           d = min(d, abs(house_x[i] - bell_x[index - 1]));
       }
       if (index != n - 1) {
           d = min(d, abs(house_x[i] - bell_x[index + 1]));
       }
       
       cout << max(k - d, 0) << endl;
   }
    
}
accuracy: 1
time_ms: 300
memory_kb: 5384
final_rank: 12

code_snippet: #include "bits/stdc++.h"

#define REP(i,num) for(ll i=0;i<(num);++i)
#define FOR(i,c,num) for(ll (i)=(c);(i)<(num);++(i))
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}

using namespace std;
using ll = long long;
using ull = unsigned long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;

constexpr ll atcoder_mod = 1e9+7;

template<typename T=ll>
T in(){ T x; cin >> x; return (x); }
template<typename T=ll,typename C=vector<T>>
C vecin(int N){ C x(N);REP(i,N){ x[i]=in<T>(); }return x; }
template<typename T=ll,size_t N>
array<T,N> arrin(){array<T,N> x;REP(i,N){ x[i]=in<T>(); }return x;}

void vout(){ cout << endl; }
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){ cout << ' ' << h;vout(forward<Tail>(t)...); }
void out(){ cout << endl; }
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){ cout << h;vout(forward<Tail>(t)...); }

template<typename T>
bool chmax(T& a,T b){ if(a<b){ a=b;return true; }return false; }
template<typename T>
bool chmin(T& a,T b){ if(a>b){ a=b;return true; }return false; }

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);

	auto N=in(),M=in(),K=in();
	auto A=vecin(N),B=vecin(M);
		
	REP(i,M){
		auto res = lower_bound(ALL(A),B[i]);
		ll L=-1,R=-1;
		if(res!=A.begin()) L = distance(A.begin(),res-1);
		if(res!=A.end()) R = distance(A.begin(),res);
		ll C=0;
		if(L>=0) chmax(C,K-abs(B[i]-A[L]));
		if(R>=0) chmax(C,K-abs(B[i]-A[R]));
		out(C);
	}
	return 0;
}
accuracy: 1
time_ms: 220
memory_kb: 6928
final_rank: 7

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;

struct Bell{
    int p;
    int e;
};

struct House{
    int p;
    int o;
};

bool operator<(const House& a, const House& b) {
  return a.p < b.p;
}

bool compare(const House& a, const House& b) {
  return a.o < b.o;
}


int main(){
    int n, m, k;
    cin>>n; cin>>m; cin>>k;
    Bell a[n];
    House b[m];
    for (int i=0; i<n; ++i){
        cin>>a[i].p;
    }
    for(int i=0; i<n-1; ++i){
        a[i].e=(a[i].p + a[i+1].p + 1)/2;
    }
    a[n-1].e=a[n-1].p+k;
    
    for (int i=0; i<m; ++i){
        cin>>b[i].p;
        b[i].o=i;
    }
    sort(b, b+m);
    
    int ct=0;
    
    for (const Bell &elm: a){
        for(;b[ct].p<elm.e && ct<m;++ct){
            int tmp=k-abs(elm.p-b[ct].p);
            b[ct].p=(tmp<0?0:tmp);
        }
    }
    while(ct<m){
        b[ct].p = 0;
        ct++;
    }
    sort(b, b+m, compare);
    for(int i=0; i<m; ++i){
        cout<<b[i].p<<endl;
    }
}
accuracy: 1
time_ms: 300
memory_kb: 7276
final_rank: 14

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;

struct Bell{
     long long p;
     long long e;
};

struct House{
     long long p;
     long long o;
    
};

bool operator<(const House& a, const House& b) {
  return a.p < b.p;
}

bool compare(const House& a, const House& b) {
  return a.o < b.o;
}


int main(){
    long long n, m, k;
    cin>>n; cin>>m; cin>>k;
    Bell a[n];
    House b[m];
    for ( long long i=0; i<n; ++i){
        cin>>a[i].p;
    }
    for( long long i=0; i<n-1; ++i){
        a[i].e=(a[i].p + a[i+1].p)/2;
    }
    a[n-1].e=a[n-1].p+k;
    
    for ( long long i=0; i<m; ++i){
        cin>>b[i].p;
        b[i].o=i;
    }
    sort(b, b+m);
    
     long long ct=0;
    
    for (const Bell &elm: a){
        for(;b[ct].p<elm.e && ct<m;++ct){
             long long tmp=k-abs(elm.p-b[ct].p);
            b[ct].p=(tmp<0?0:tmp);
        }
    }
    while(ct<m){
        b[ct].p = 0;
        ct++;
    }
    sort(b, b+m, compare);
    for( long long i=0; i<m; ++i){
        cout<<b[i].p<<endl;
    }
}
accuracy: 0.7567567567567568
time_ms: 230
memory_kb: 7428
final_rank: 20

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;

struct Bell{
    int p;
    int e;
};

struct House{
    int p;
    int o;
    
};

bool operator<(const House& a, const House& b) {
  return a.p < b.p;
}

bool compare(const House& a, const House& b) {
  return a.o < b.o;
}


int main(){
    int n, m, k;
    cin>>n; cin>>m; cin>>k;
    Bell a[n];
    House b[m];
    for (int i=0; i<n; ++i){
        cin>>a[i].p;
    }
    for(int i=0; i<n-1; ++i){
        a[i].e=(a[i].p + a[i+1].p)/2;
    }
    a[n-1].e=a[n-1].p+k;
    
    for (int i=0; i<m; ++i){
        cin>>b[i].p;
        b[i].o=i;
    }
    sort(b, b+m);
    
    int ct=0;
    
    for (const Bell &elm: a){
        for(;b[ct].p<elm.e && ct<m;++ct){
            int tmp=k-abs(elm.p-b[ct].p);
            b[ct].p=(tmp<0?0:tmp);
        }
    }
    while(ct<m){
        b[ct].p = 0;
        ct++;
    }
    sort(b, b+m, compare);
    for(int i=0; i<m; ++i){
        cout<<b[i].p<<endl;
    }
}
accuracy: 0.7567567567567568
time_ms: 230
memory_kb: 5348
final_rank: 19

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

using namespace std;
int main(void){
    // Your code here!
   int N,M,K;
   cin >> N >> M >> K;

   vector<int> As;
   As.reserve(N);
   
   int Bs[M];

   int pos;
   for (int i=0;i<N;i++){
       cin >> pos;
       As.push_back(pos);
   }
   for(int j=0;j<M;j++){
       cin >>Bs[j];
   }
    int amp1,amp2;
    int delta;
    for(int j=0;j<M;j++){
        pos=Bs[j];
        vector<int>::iterator itA=lower_bound(As.begin(),As.end(),pos);
        if(itA!=As.begin()){
            amp1=max(K-(pos-*(itA-1)),0);
        }else{
            amp1=0;
        }
        if(itA!=As.end()){
            amp2=max(K-(*itA-pos),0);
        }else{
            amp2=0;
        }
        cout << max(amp1,amp2) << endl;
    }   
    
}
accuracy: 1
time_ms: 380
memory_kb: 4592
final_rank: 16

code_snippet: #define rep(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(v) v.begin(),v.end()
typedef long long ll;
 
#include<bits/stdc++.h>
using namespace std;
 
int main(){
  ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  
  int n,m,k;
  cin>>n>>m>>k;
  vector<int> A(n),B(m);
  rep(i,n) cin>>A[i];
  rep(i,m) cin>>B[i];
  rep(i,m){
    auto t=lower_bound(ALL(A),B[i])-A.begin();
    if(t==0) cout<<max(0,k-(A[t]-B[i]))<<endl;
    else if(t==n) cout<<max(0,k-(B[i]-A[n-1]))<<endl;
    else cout<<max(max(0,k-(A[t]-B[i])),max(0,k-(B[i]-A[t-1])))<<endl;
  }
   
  return 0;
}
accuracy: 1
time_ms: 220
memory_kb: 5032
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
#define all(A) A.begin(),A.end()
#define rep(i, n) for (ll i = 0; i < (ll) (n); i++)
int main() {
    ll N,M,K;
    cin>>N>>M>>K;
    vll A(N+2);
    rep(i,N)cin>>A[i+1];
    A[0]=-1e18;
    A[N+1]=1e18;
    rep(i,M){
        ll B;
        cin>>B;
        auto p=lower_bound(all(A),B);
        auto q=lower_bound(all(A),B);
        p--;
        ll d=min(B-*p,*q-B);
        cout<<max(0ll,K-d)<<endl;
    }
}
accuracy: 1
time_ms: 310
memory_kb: 4960
final_rank: 13

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n,m,k; cin >> n >> m >> k;
    vector<ll> vec;
    vec.push_back(-1e18);
    for (int i = 0; i < n; i++) {
        ll a; cin >> a;
        vec.push_back(a);
    }
    vec.push_back(1e18);
    while (m--) {
        ll b; cin >> b;
        auto it = lower_bound(vec.begin(), vec.end(), b) - vec.begin();
        ll res = 0;
        res = max(res, k-abs(b-vec[it]));
        it--;
        res = max(res, k-abs(b-vec[it]));
        cout << res << "\n";
    }
}
accuracy: 1
time_ms: 70
memory_kb: 5208
final_rank: 3

code_snippet: #include <bits/extc++.h>

using namespace std;

#define rep(i,n) for(int i=0;i<(n);++i)
#define reps(i,n) for(int i=1;i<=(n);++i)
#define all(x) begin(x),end(x)
#define Fixed fixed << setprecision(12)
#define updiv(a, b) (((a) + (b) - 1) / (b))
using pii = pair<int,int>;
constexpr int32_t INF  = 0x3f3f3f3f;
constexpr int_fast64_t LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int mod1 = 1e9+7;
constexpr int mod2 = 998244353;

template <class Func>
class FixPoint : Func {
public:
    explicit constexpr FixPoint(Func&& f) noexcept : Func(forward<Func>(f)) {}

    template <class... Args>
    constexpr decltype(auto) operator()(Args&&... args) const {
        return Func::operator()(*this, std::forward<Args>(args)...);
    }
};

template <class Func>
static inline constexpr decltype(auto) makeFixPoint(Func&& f) noexcept {
    return FixPoint<Func>{forward<Func>(f)};
}

template<class T, class U> istream& operator>>(istream& is, pair<T, U>& p){ is >> p.first >> p.second; return (is); }
template<class T, class U> ostream& operator<<(ostream& os, pair<T, U>& p){ os << p.first << ' ' << p.second; return (os); }
template<class T> istream& operator>>(istream& is, vector<T>& v){ for (auto &&e : v) is >> e; return (is); }
template<class T> ostream& operator<<(ostream& os, vector<T>& v){ for (auto &&e : v) os << e << ' '; return (os); }

template<class T> inline const T& max(const vector<T> &v) { return *max_element(v.begin(), v.end()); }
template<class T> inline const T& min(const vector<T> &v) { return *min_element(v.begin(), v.end()); }
template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }

template <class T> using max_heap = priority_queue<T>;
template <class T> using min_heap = priority_queue<T, vector<T>, greater<T> >;
template <class A, class B> using umap = unordered_map<A, B>;
template <class T> using uset = unordered_set<T>;

template <class T> using Max_Heap = __gnu_pbds::priority_queue<T, less<T>, __gnu_pbds::rc_binomial_heap_tag>;
template <class T> using Min_Heap = __gnu_pbds::priority_queue<T, greater<T>, __gnu_pbds::rc_binomial_heap_tag>;
template <class T> using Set = __gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;
template <class K, class V> using Umap = __gnu_pbds::gp_hash_table<K, V>;
template <class T> using Rope = __gnu_cxx::rope<T>;
using Trie = __gnu_pbds::trie<string, __gnu_pbds::null_type, __gnu_pbds::trie_string_access_traits<>, __gnu_pbds::pat_trie_tag, __gnu_pbds::trie_prefix_search_node_update>;

template <class T> void bye(T x){ cout << x << '\n'; exit(0); }

constexpr int dx[] = {1,0,-1,0,1,1,-1,-1,0};
constexpr int dy[] = {0,-1,0,1,1,-1,-1,1,0};

signed main(){
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    cout.setf(ios_base::fixed);
    cout.precision(12);

    int n, m, k;
    cin >> n >> m >> k;

    vector<int> a(n), b(m);

    cin >> a >> b;

    a.insert(a.begin(), INT_MIN);
    a.emplace_back(INT_MAX);

    for (int i = 0; i < m; ++i) {
        auto r = lower_bound(all(a), b[i]);
        auto l = prev(r);
        cout << max(k - min(abs(b[i] - *l), abs(b[i] - *r)), 0) << '\n';
    }

    return (0);
}
accuracy: 1
time_ms: 60
memory_kb: 5852
final_rank: 2