p_id
stringlengths 6
6
| language
stringclasses 10
values | code
stringlengths 11
983k
|
|---|---|---|
p03158 | C++ | #include <iostream>
#include <iomanip>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;
int main(){
long long N, Q;
cin >> N >> Q;
vector<long long> A(N), X(Q);
for(int i=0; i<N; i++) cin >> A[i];
for(int i=0; i<Q; i++) cin >> X[i];
vector<long long> B(N+1);
for(int i=0; i<N; i++)
B[i+1] = B[i] + A[i];
vector<long long> C(N+1);
if(N%2==1){
for(int i=0; i<N; i++){
C[i+1] = C[i];
if(i%2==0) C[i+1] += A[i];
}
}else{
for(int i=0; i<N; i++){
C[i+1] = C[i];
if(i%2==1) C[i+1] += A[i];
}
}
for(auto x : X){
double lb = 0;
double ub = 1e9;
for(int i=0; i<100; i++){
double mid = (lb+ub)/2;
auto a = lower_bound(A.begin(), A.end(), x-mid);
auto b = lower_bound(A.begin(), A.end(), x+mid);
long long aok = b-a;
long long tak = A.end()-b;
if(aok > tak) ub = mid;
else lb = mid;
}
long long idx = lower_bound(A.begin(), A.end(), x+lb) - A.begin();
long long ans = B[N] - B[idx];
if(2*idx-N>=0)
ans += C[2*idx-N];
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <utility>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <bitset>
#include <ctime>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cassert>
#include <cstddef>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <sstream>
#include <fstream>
#include <functional>
using namespace std;
#define REP(i, n) for (int (i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int (i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for(int (i) = (a) - 1; (i) >= 0; (i)--)
#define FORR(i, a, b) for(int (i) = (a) - 1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << C << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template<typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define FIND(s, e) ((s).find(e) != (s).end())
#define EB emplace_back
template<typename T> inline bool chmax(T &a, T b){if (a < b){a = b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if (a > b){a = b;return true;}return false;}
const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;
const int MAX = 1e5 + 10;
int N, Q;
LL A[MAX];
LL X[MAX];
LL sum[MAX], odd_sum[MAX], even_sum[MAX];
// [...青木,高橋,青木,高橋][青木][高橋]
LL calc(LL x) {
int low = N / 2, high = N;
while (high - low > 1) {
const int mid = (high + low) / 2;
const int turn = N - mid + 1; // かかったターン
const int takahashi_left = mid;
const int takahashi_right = N - 1;// [l, r]
{
const int aoki_left = mid - turn;
const int aoki_right = mid - 1;
if (x < A[aoki_left]) {
high = mid;
} else if (A[aoki_left] <= x && x <= A[aoki_right]) {
if (abs(A[aoki_left] - x) <= abs(A[aoki_right] - x)) {
high = mid;
} else {
low = mid;
}
} else {
low = mid;
}
}
}
const int turn = N - low + 1;
const int takahashi_left = low;
const int takahashi_right = N - 1;
const int aoki_left = low - turn;
const int aoki_right = low - 1;
LL ans = sum[N] - sum[takahashi_left];
// DEBUG(turn)
// DEBUG(takahashi_left)
// DEBUG(aoki_left)
if (N % 2) {
ans += even_sum[aoki_left + 1];
} else {
ans += odd_sum[aoki_left + 1];
}
return ans;
}
int main(void) {
cin >> N >> Q;
REP(i, N) {
cin >> A[i];
}
sort(A, A + N);
REP(i, N) {
sum[i + 1] = A[i] + sum[i];
if (i % 2 == 0) {
even_sum[i + 1] = A[i];
} else {
odd_sum[i + 1] = A[i];
}
even_sum[i + 1] += even_sum[i];
odd_sum[i + 1] += odd_sum[i];
}
REP(i, Q) {
cin >> X[i];
}
REP(i, Q) {
printf("%lld\n", calc(X[i]));
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define REV(i,n) for(ll (i) = (n) - 1;(i) >= 0;--i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {REP(WW,n)cerr << v[WW] << ' ';cerr << endl << endl;}
#define SHOW2d(v,WW,HH) {REP(W_,WW){REP(H_,HH)cerr << v[W_][H_] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
ll ans[111111];
int main(){
ll n,q;cin >> n >> q;
vector<ll> v(n);
REP(i,n)cin >> v[i];
vector<P> que(q);
REP(i,q){
cin >> que[i].FI;
que[i].SE = i;
}
sort(ALL(que));
if(n == 2){
REP(i,q){
cout << v[1] << endl;
}
return 0;
}
int l = 0;
int r = n / 2 - 1;
bool flag = false;
if(n % 2 == 0)l++;
else flag = true;
ll now = 0;
for(int i = r + 1;i < n;i++)now += v[i];
REP(i,q){
while(l <= r && r < n - 1 && abs(que[i].FI - v[l]) > abs(que[i].FI - v[r+1])) {
if(flag){
r++;now-=v[r];
now+=v[l];l+=2;
flag = false;
}
else{
r++;now-=v[r];
now+=v[l];l+=2;
}
}
ans[que[i].SE] = now;
//cout << l << " " << r << endl;
}
REP(i,q){
cout << ans[i] << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
int n,q;
ll a[200000];
ll x[200000];
ll s1[200000],s2[200000];
int calc(ll c){
int id=upper_bound(a,a+n,c)-a;
if(id)id--;
int l=id,r=n;
while(r-l>1){
int t=(l+r)/2;
ll low=(a[t]-c);
int p=lower_bound(a,a+id+1,c-low)-a;
int cnt=t-p+1;
if(t>=n-cnt)r=t;
else l=t;
}
return l;
}
int main(){
scanf("%d%d",&n,&q);
rep(i,n){
scanf("%lld",&a[i]);
if(i%2==0)s1[i]+=a[i];
if(i%2==1)s2[i]+=a[i];
if(i){
s1[i]+=s1[i-1];
s2[i]+=s2[i-1];
}
}
rep(i,q){
scanf("%lld",&x[i]);
if(abs(x[i]-a[n-2])>abs(x[i]-a[n-1])){
printf("%lld\n",(n-1)%2==0?s1[n-1]:s2[n-1]);
}
else{
int id=calc(x[i]);
ll ans=(s1[n-1]+s2[n-1])-(s1[id]+s2[id]);
ll cnt=n-1-id;
ll e=id-cnt;
if(e>=0){
ans+=(e%2==0?s1[e]:s2[e]);
}
printf("%lld\n",ans);
}
}
} |
p03158 | C++ | #include <cassert>
#include <iostream>
#include <functional>
#include <iomanip>
#include <set>
#include <unordered_map>
#include <map>
#include <queue>
#include <vector>
#include <deque>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <random>
#pragma warning(disable: 4996)
using namespace std;
using LL = long long;
const int MAX = 210000;
const LL base = LL(1e9 + 7);
inline void mod_add(LL & a, const LL& b) { a = (a + b) % base; }
inline void mod_mul(LL & a, const LL& b) { a = (a*b) % base; }
using VI = vector<int>;
using VVI = vector< VI >;
using VL = vector<LL>;
using PII = pair<int, int>;
using VPII = vector< PII >;
template <typename T> inline void max_s(T&a, const T&b) { a = max(a, b); }
template <typename T> inline void min_s(T&a, const T&b) { a = min(a, b); }
template <typename T> void sort_v(T & x) { sort(x.begin(), x.end()); }
template <typename T> void erase_dup(T & x) { x.erase(unique(x.begin(), x.end()), x.end()); } // erase duplicate
template <typename T, typename V> int pos_l(const T & x, const V & v) { return lower_bound(x.begin(), x.end(), v) - x.begin(); }
template <typename T, typename V> int pos_u(const T & x, const V & v) { return upper_bound(x.begin(), x.end(), v) - x.begin(); }
inline unsigned rand_g() {
static mt19937 mt_rand((int)time(0));
return mt_rand();
}
struct Node {
int x, y, w;
};
bool operator < (const Node & n0, const Node & n1) {
return n0.x< n1.y;
}
void solve() {
LL result = 0;
int n, q;
cin >> n>> q;
VL za(n);
VL zpre(n + 1);
VL zfi(n+1);
for (int i = 0; i < n; ++i) {
cin >> za[i];
zpre[i + 1] = zpre[i] + za[i];
zfi[i + 1] = zfi[i];
if (i % 2 != n % 2) {
zfi[i + 1] += za[i];
}
}
LL x;
auto work = [&](int f) {
if (n < 2 * f - 1) return false;
//if (za[n - 2 * f + 1] >= x) return true;
LL d1 = abs(x - za[n - f]);
LL d2 = abs(x - za[n - 2 * f + 1]);
if (d2 <= d1) return true;
return false;
};
for (int ggg = 0; ggg < q; ++ggg) {
cin >> x;
int u0, u1;
u0 = 1;
u1 = n / 2 + 2;
while (u0 + 1 < u1) {
int mid = (u0 + u1) / 2;
auto ok = work(mid);
if (ok) {
u0 = mid;
}
else {
u1 = mid;
}
}
auto r = zpre[n] - zpre[n - u0];
r += zfi[n - u0 * 2 + 1];
cout << r << '\n';
}
}
int main() {
const int inId = 0;
const int outId = 0;
if (inId>0) {
cerr << "redirect stdin to input " << inId << endl;
string s = "input";
s += to_string(inId);
s += ".txt";
auto r = freopen(s.c_str(), "r", stdin);
if (r == nullptr) {
cerr << "invalid input file " << s;
}
}
if (outId>0) {
cerr << "redirect stdout to stdout " << outId << endl;
string s = "stdout";
s += to_string(outId);
s += ".txt";
auto r = freopen(s.c_str(), "w", stdout);
if (r == nullptr) {
cerr << "invalid output file " << s;
}
}
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); // close sync between cout and printf
cout.precision(10);
solve();
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define REP(i,m) for(int i=0; i<m; i++)
#define FOR(i,n,m) for(int i=n; i<m; i++)
#define INF 1000000007
#define INFL (1LL << 60)
#define MOD 998244353
#define ALL(v) v.begin(),v.end()
#define pb push_back
#define ll long long int
#define P pair<ll, ll>
bool check[401][401] = { };
int main(){
int n, q;
cin >> n >> q;
int a[n];
REP(i, n) cin >> a[i];
vector<ll> minturn(n);
REP(i, n) minturn[i] = 0;
REP(i, n-1){
if(i >= (n-1-i)) minturn[i+1] = 1 + (a[i] + a[i - (n-1-i)])/2;
}
ll ans[n] = { };
FOR(i, n/2, n) ans[0] += a[i];
REP(i, n/2+1) ans[i] = ans[0];
FOR(i, n/2+1, n){
if(n%2 == 0) ans[i] = ans[i-1] - a[i-1] + a[2*(i-1-(n/2))+1];
else ans[i] = ans[i-1] - a[i-1] + a[2*(i-1-(n/2))];
}
REP(xr, q){
int x;
cin >> x;
int l = 0, r = n+1;
while((r-l)!=1){
int m = (l+r)/2;
if(minturn[m] > x) r = m;
else l = m;
}
if(l == n) cout << ans[n-1] << endl;
else cout << ans[l] << endl;
}
} |
p03158 | C++ | #include <stdio.h>
#include <algorithm>
typedef long long ll;
using namespace std;
int main(void) {
ll i, j, k, n, q, x;
scanf("%lld%lld", &n, &q);
ll a[n], sum[n], sum2[n];
for(i = 0; i < n; ++i) scanf("%lld", &a[i]);
for(i = 0; i < n; ++i) {
if(i < 2) sum[i] = a[i];
else sum[i] = sum[i - 2] + a[i];
if(i) sum2[i] = sum2[i - 1] + a[i];
else sum2[i] = a[i];
}
for(i = 0; i < q; ++i) {
scanf("%lld", &x);
ll l = lower_bound(a, a + n, x) - a;
ll ht = 0, tt = 1e9;
while(ht != tt - 1) {
ll t = (ht + tt) / 2;
ll lt = lower_bound(a, a + n, x + t) - a, ft = lower_bound(a, a + n, x - t) - a;
if(n - 1 - lt < lt - ft) tt = t;
else ht = t;
}
ll lt = upper_bound(a, a + n, x + ht) - a - 1, ft = lower_bound(a, a + n, x - ht) - a;
if(lt - ft + 1 > n - lt - 1) {
if(a[lt] - x >= x - a[ft]) lt--;
else ft++;
}
ll ans = sum2[n - 1] - sum2[lt];
if(lt - ft + 1 != n - lt - 1) {
if(ft - 2 >= 0) ans += sum[ft - 2];
} else {
if(ft - 1 >= 0) ans += sum[ft - 1];
}
//printf("%lld %lld %lld ", ht, ft, lt);
printf("%lld\n", ans);
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9+7;
signed main()
{
ll n, q;
cin >> n >> q;
vector<ll> a(n);
for(auto& x : a)
cin >> x;
vector<ll> x(q);
for(auto& y : x)
cin >> y;
vector<ll> rui(n + 1, 0);
for(ll i = n - 1; i >= 0; --i)
rui[i] = rui[i + 1] + a[i];
vector<ll> rui2(n + 2, 0);
for(ll i = 0; i < n; i += 2)
rui2[i + 2] = rui2[i] + a[i];
for(ll i = 1; i < n; i += 2)
rui2[i + 2] = rui2[i] + a[i];
for(auto& p : x){
ll ind = distance(a.begin(), lower_bound(a.begin(), a.end(), p));
// 高橋くんがnum個取る事ができるか
auto f = [&](ll num){
if(n - ind < num)
return true;
// [taka_bound, en]まで高橋くんがとった
// 青木くんが[begin, taka_bound)まで取れる
auto taka_bound = prev(a.end(), num);
// 差が[0,max_diff)の範囲にj個あるかを調べる
ll max_diff = (*taka_bound - p);
ll dist = distance(lower_bound(a.begin(), a.end(), p - max_diff), taka_bound);
return dist < (num - 1);
};
ll st = 1;
ll en = n + 100;
while(en - st > 1){
ll num = (st + en) / 2;
(f(num) ? en : st) = num;
}
// 影響が起こらない限界値
ll value = rui[n - st];
cout << value + rui2[n + 1 - 2 * st] << endl;
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define int long long
#define all(a) a.begin(), a.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
struct CumulativeSum{
vector<int> data;
CumulativeSum(int sz) : data(sz, 0) {};
void add(int k, int x){
data[k] += x;
}
void build(){
for(int i = 1; i < data.size(); i++){
data[i] += data[i - 1];
}
}
//区間[0,k]の和
int query(int k){
if(k < 0) return 0;
return (data[min(k, (int)data.size() - 1)]);
}
//区間[l.r)の和
int query(int l, int r){
return query(r - 1) - query(l - 1);
}
};
int n, q;
vector<int> a;
bool f(int m, int x){
bool res = true;
int takahashi_left = n - m;
int diff = a[takahashi_left] - x;
if(diff < 0) return false;
int left = lower_bound(a.begin(), a.end(), x - diff) - a.begin();
int right = lower_bound(a.begin(), a.end(), x + diff) - a.begin();
int num = right - left;
// cout << m << ' ' << x << ' ' << diff << " " << left << ' ' << right << endl;
return num >= m - 1;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
a.resize(n);
rep(i, 0, n) cin >> a[i];
CumulativeSum odd(n), even(n), sum(n);
rep(i, 0, n){
if(i % 2 == 0){
even.add(i, a[i]);
odd.add(i, 0);
sum.add(i, a[i]);
}else{
even.add(i, 0);
odd.add(i, a[i]);
sum.add(i, a[i]);
}
}
odd.build();
even.build();
sum.build();
while(q--){
int x;
cin >> x;
int ok = 1, ng = n;
while(ng - ok > 1){
int mid = (ng + ok) / 2;
if(f(mid, x)) ok = mid;
else ng = mid;
}
// cout << ok << " " << n - ok << " " << n - 2 * ok - 1 << endl;
int ans = sum.query(n - ok, n);
int idx = n - 2 * ok - 1;
if(idx >= 0){
if(idx % 2 == 0) ans += even.query(0, idx + 1);
else ans += odd.query(0, idx + 1);
}
cout << ans << endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using lint = long long int;
using ulint = unsigned long long int;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<class T, class U> void assign(V<T>& v, int n, const U& a) { v.assign(n, a); }
template<class T, class... Args> void assign(V<T>& v, int n, const Args&... args) { v.resize(n); for (auto&& e : v) assign(e, args...); }
int main() {
cin.tie(nullptr); ios_base::sync_with_stdio(false);
int n, q; cin >> n >> q;
V<> a(n); for (int i = 0; i < n; ++i) cin >> a[i];
V<lint> cum(n + 1);
for (int i = 0; i < n; ++i) {
cum[i + 1] = cum[i] + a[i];
}
V<lint> cum2(n + 1);
for (int i = 0; i < n; ++i) {
cum2[i + 1] = (i ? cum2[i - 1] : 0) + a[i];
}
while (q--) {
int x; cin >> x;
int k = lower_bound(begin(a), end(a), x) - begin(a);
if (k == 0) {
cout << cum[n] - cum[n / 2] << '\n';
continue;
}
if (k == n) {
cout << cum2[n] << '\n';
continue;
}
auto is_taka = [&](int i) -> bool {
int taka = n - 1 - i;
int aoki = (begin(a) + i) - lower_bound(begin(a), end(a), 2 * x - a[i]);
return taka <= aoki;
};
int ng = k - 1, ok = n - 1;
while (ok - ng > 1) {
int m = ng + ok >> 1;
(is_taka(m) ? ok : ng) = m;
}
lint res = cum[n] - cum[ok];
res += cum2[max(2 * ok - n, 0)];
cout << res << '\n';
}
} |
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, Q;
cin >> N >> Q;
vector<int> A(N);
for(auto& e : A) {
cin >> e;
}
vector<int> X(Q);
for(auto& e : X) {
cin >> e;
}
vector<ll> cumsum_all(N), cumsum_even(N), cumsum_odd(N);
cumsum_all[0] = A[0];
cumsum_even[0] = A[0];
cumsum_odd[0] = 0;
for(int i=1;i<N;i++) {
cumsum_all[i] = cumsum_all[i - 1] + A[i];
cumsum_even[i] = cumsum_even[i - 1] + (i % 2 == 0 ? A[i] : 0);
cumsum_odd[i] = cumsum_odd[i - 1] + (i % 2 == 1 ? A[i] : 0);
}
for(int q=0;q<Q;q++) {
int i = lower_bound(A.begin(), A.end(), X[q]) - A.begin();
int l = 0, r = N;
while(r - l > 1) {
int mid = (l + r) / 2;
assert(mid >= 1 && mid + 1 <= N);
int aoki_r = N - mid - 1;
int aoki_l = lower_bound(A.begin(), A.end(), X[q] - abs(X[q] - A[aoki_r])) - A.begin();
if(aoki_r - aoki_l + 1 >= mid) {
l = mid;
}else {
r = mid;
}
}
int aoki_r = N - l - 1;
int aoki_l = lower_bound(A.begin(), A.end(), X[q] - abs(X[q] - A[aoki_r])) - A.begin();
int aoki_len = aoki_r - aoki_l + 1;
assert(l <= aoki_len);
ll ans = cumsum_all[N - 1] - cumsum_all[aoki_r];
if(l < aoki_len) {
ans += A[aoki_r];
int j = aoki_r - 1 - (l + 1);
if (j >= 0) {
ans += j % 2 == 0 ? cumsum_even[j] : cumsum_odd[j];
}
}else {
int j = aoki_r - l;
if (j >= 0) {
ans += j % 2 == 0 ? cumsum_even[j] : cumsum_odd[j];
}
}
cout << ans << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define maxn 100010
#define ll long long
ll s1[maxn],s2[maxn],ans;
int a[maxn],n,q,i,j,x,l,r,mid,t;
int getnum()
{
int s=0;
char c=getchar();
for (;!isdigit(c);c=getchar());
for (;isdigit(c);c=getchar())
s=s*10+c-'0';
return s;
}
int get(int x)
{
int l=1,r=n,mid=(l+r)>>1,ans=n;
for (;l<=r;mid=(l+r)>>1)
if (a[mid]>=x)
{
ans=mid;
r=mid-1;
}
else l=mid+1;
return ans;
}
int main()
{
n=getnum();
q=getnum();
for (i=1;i<=n;i++)
a[i]=getnum();
s1[1]=s2[1]=a[1];
for (i=2;i<=n;i++)
{
s1[i]=s1[i-1]+(ll)a[i];
s2[i]=s2[i-2]+(ll)a[i];
}
for (i=1;i<=q;i++)
{
x=getnum();
l=1;
r=n;
ans=s2[n];
for (mid=(l+r)>>1;l<=r;mid=(l+r)>>1)
if (a[mid]<=x) l=mid+1;
else
{
t=get(x*2-a[mid]);
if (mid-t<n-mid) l=mid+1;
else
{
ans=s1[n]-s1[mid-1]+(n>=(n-mid+1)*2 ? s2[n-(n-mid+1)*2] : 0);
r=mid-1;
}
}
printf("%lld\n",ans);
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
#define debug(x) cerr<<#x<<" = "<<x
#define sp <<" "
#define el <<endl
#define fgx cerr<<"-----------------------------------"<<endl
#define LL long long
#define M 100020
using namespace std;
namespace IO{
const int BS=(1<<23)+5; int Top=0;
char Buffer[BS],OT[BS],*OS=OT,*HD,*TL,SS[20]; const char *fin=OT+BS-1;
char Getchar(){if(HD==TL){TL=(HD=Buffer)+fread(Buffer,1,BS,stdin);} return (HD==TL)?EOF:*HD++;}
void flush(){fwrite(OT,1,OS-OT,stdout),OS=OT;}
void Putchar(char c){*OS++ =c;if(OS==fin)flush();}
void write(int x){
if(!x){Putchar('0');return;} if(x<0) x=-x,Putchar('-');
while(x) SS[++Top]=x%10,x/=10;
while(Top) Putchar(SS[Top]+'0'),--Top;
}
int read(){
int nm=0,fh=1; char cw=getchar();
for(;!isdigit(cw);cw=getchar()) if(cw=='-') fh=-fh;
for(;isdigit(cw);cw=getchar()) nm=nm*10+(cw-'0');
return nm*fh;
}
}using namespace IO;
int n,m,p[M]; LL s[M],t[2][M];
inline int fd(int num){
int l=1,r=n,res=n+1,mid;
while(l<=r){
mid=((l+r)>>1);
if(p[mid]>=num) res=mid,r=mid-1;
else l=mid+1;
} return res;
}
LL Q(int l,int r,int kd){return r<l?0:(t[kd][r]-t[kd][l-1]);}
LL solve(int num){
if(num>=p[n-1]) return t[(n&1)^1][n];
LL l=1,r=num+p[n],t1,t2,mid,dt=0;
while(l<=r){
mid=((l+r)>>1);
t1=fd(num-mid),t2=fd(num+mid+1);
if(n-(t2-t1)+1>=t2) dt=mid,l=mid+1;
else r=mid-1;
}
int k1=fd(num-dt),k2=fd(num+dt+1),len;
len=k2-k1; LL now=s[k2-1]-s[k1-1];
if(k1>1&&k2<=n&&p[k1-1]+p[k2]==num+num&&n-len==k2+1) now-=p[k2],now+=p[k1-1];
now+=Q(k2,n-len,((n-len)&1)^1);
return now+t[(k1&1)^(max(n-len-k2+1,0)&1)][k1-1];
}
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
n=read(),m=read();
for(int i=1;i<=n;i++){
s[i]=s[i-1]+(p[i]=read());
t[0][i]=t[0][i-1],t[1][i]=t[1][i-1];
t[i&1][i]+=p[i];
}
while(m--){
int x=read();
printf("%lld\n",s[n]-solve(x));
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define reg register
#define ll long long
#define ge getchar()
#define Re read()
#define FI "a.in"
#define FO "a.out"
#define MAXN 100100
inline int read() {
int x = 0, t = 0, ch;
while(!isdigit(ch = ge)) t |= ch == '-';
while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = ge;
return t ? -x : x;
}
int n, q;
int a[MAXN + 1];
ll sum[MAXN + 1];
ll bck[MAXN + 1];
inline int find(int x) {
int l = 1;
int r = n;
int p = lower_bound(a, a + 1 + n, x) - a - 1;
int res = n;
while(l <= r) {
int mid = (l + r) >> 1;
int T = mid - (mid >> 1);
if(n - p <= mid && a[n - T] - x < abs(x - a[n - mid]))
r = mid - 1, res = mid;
else l = mid + 1;
}
return res;
}
int main() {
scanf("%d%d", &n, &q);
for(int i = 1; i <= n; i++) a[i] = Re;
sort(a + 1, a + 1 + n);
sum[1] = a[1], sum[2] = a[2];
for(int i = 3; i <= n; i++) sum[i] = sum[i - 2] + a[i];
for(int i = n; i >= 1; i--) bck[i] = bck[i + 1] + a[i];
for(int i = 1; i <= q; i++) {
int x = Re;
int p = find(x);
printf("%lld\n", sum[n - min(n, (p + 1) / 2 * 2)] + bck[n - ((p + 1) >> 1) + 1]);
}
return 0;
} |
p03158 | C++ | #define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <limits>
#include <ctime>
#include <cassert>
#include <map>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <iterator>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
#define ten(n) ((int)1e##n)
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template<typename ...> static inline int getchar_unlocked(void) { return getchar(); }
template<typename ...> static inline void putchar_unlocked(int c) { putchar(c); }
#define mygc(c) (c)=getchar_unlocked()
#define mypc(c) putchar_unlocked(c)
void reader(int& x) { int k, m = 0; x = 0; for (;;) { mygc(k); if (k == '-') { m = 1; break; }if ('0' <= k&&k <= '9') { x = k - '0'; break; } }for (;;) { mygc(k); if (k<'0' || k>'9')break; x = x * 10 + k - '0'; }if (m) x = -x; }
void reader(ll& x) { int k, m = 0; x = 0; for (;;) { mygc(k); if (k == '-') { m = 1; break; }if ('0' <= k&&k <= '9') { x = k - '0'; break; } }for (;;) { mygc(k); if (k<'0' || k>'9')break; x = x * 10 + k - '0'; }if (m) x = -x; }
int reader(char c[]) { int i, s = 0; for (;;) { mygc(i); if (i != ' '&&i != '\n'&&i != '\r'&&i != '\t'&&i != EOF) break; }c[s++] = i; for (;;) { mygc(i); if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break; c[s++] = i; }c[s] = '\0'; return s; }
int reader(string& c) { int i; for (;;) { mygc(i); if (i != ' '&&i != '\n'&&i != '\r'&&i != '\t'&&i != EOF) break; }c.push_back(i); for (;;) { mygc(i); if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break; c.push_back(i); }; return sz(c); }
template <class T, class S> void reader(T& x, S& y) { reader(x); reader(y); }
template <class T, class S, class U> void reader(T& x, S& y, U& z) { reader(x); reader(y); reader(z); }
template <class T, class S, class U, class V> void reader(T& x, S& y, U& z, V & w) { reader(x); reader(y); reader(z); reader(w); }
void writer(int x, char c) { int s = 0, m = 0; char f[10]; if (x<0)m = 1, x = -x; while (x)f[s++] = x % 10, x /= 10; if (!s)f[s++] = 0; if (m)mypc('-'); while (s--)mypc(f[s] + '0'); mypc(c); }
void writer(ll x, char c) { int s = 0, m = 0; char f[20]; if (x<0)m = 1, x = -x; while (x)f[s++] = x % 10, x /= 10; if (!s)f[s++] = 0; if (m)mypc('-'); while (s--)mypc(f[s] + '0'); mypc(c); }
void writer(const char c[]) { int i; for (i = 0; c[i] != '\0'; i++)mypc(c[i]); }
void writer(const string& x, char c) { int i; for (i = 0; x[i] != '\0'; i++)mypc(x[i]); mypc(c); }
void writer(const char x[], char c) { int i; for (i = 0; x[i] != '\0'; i++)mypc(x[i]); mypc(c); }
template<class T> void writerLn(T x) { writer(x, '\n'); }
template<class T, class S> void writerLn(T x, S y) { writer(x, ' '); writer(y, '\n'); }
template<class T, class S, class U> void writerLn(T x, S y, U z) { writer(x, ' '); writer(y, ' '); writer(z, '\n'); }
template<class T, class S, class U, class V> void writerLn(T x, S y, U z, V v) { writer(x, ' '); writer(y, ' '); writer(z, ' '); writer(v, '\n'); }
template<class T> void writerArr(T x[], int n) { if (!n) { mypc('\n'); return; }FOR(i, n - 1)writer(x[i], ' '); writer(x[n - 1], '\n'); }
template<class T> void writerArr(vector<T>& x) { writerArr(x.data(), (int)x.size()); }
template<class T> void chmin(T& a, const T& b) { if (a > b) a = b; }
template<class T> void chmax(T& a, const T& b) { if (a < b) a = b; }
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
ll mod_pow(ll a, ll n, ll mod) {
ll ret = 1;
ll p = a % mod;
while (n) {
if (n & 1) ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
template<class T> T extgcd(T a, T b, T& x, T& y) { for (T u = y = 1, v = x = 0; a;) { T q = b / a; swap(x -= q * u, u); swap(y -= q * v, v); swap(b -= q * a, a); } return b; }
ll mod_inv(ll a, ll m) { ll x, y; extgcd<ll>(a, m, x, y); return (m + x % m) % m; }
#ifdef _DEBUG
template <typename ... Args>
void debugPrintf(const char *format, Args const & ... args) {
fprintf(stdout, format, args ...);
fflush(stdout);
}
#else
#define debugPrintf(...)
#endif
ll a[ten(5) + 10];
ll sa[ten(5) + 10];
ll evenSa[ten(5) + 10];
void init(int n) {
FOR(i, n) sa[i + 1] = sa[i] + a[i];
FOR(i, n) {
evenSa[i + 1] = evenSa[i];
if (i % 2 == 0) evenSa[i + 1] += a[i];
}
}
Pii f(int n, ll md, ll x) {
ll lower = md / 2;
ll upper = md - lower;
int lid = lower_bound(a, a + n, x - lower) - a;
int rid = lower_bound(a, a + n, upper + x) - a;
return Pii(lid, rid);
}
ll naive(int n, ll x) {
set<ll> s(a, a + n);
ll ret = 0;
FOR(i, n) {
if (i % 2 == 0) {
ret += *s.rbegin();
s.erase(--s.end());
} else {
auto it = s.lower_bound(x);
if (it == s.end()) {
s.erase(--s.end());
} else if (it == s.begin()) {
s.erase(it);
} else {
auto it2 = it;
it2--;
if (abs(x - *it2) <= abs(x - *it)) {
s.erase(it2);
} else {
s.erase(it);
}
}
}
}
return ret;
}
ll solve(int n, ll x) {
ll l = 0, r = 2 * ten(9) + 10;
while (r - l != 1) {
ll md = (l + r) / 2;
int lid, rid;
tie(lid, rid) = f(n, md, x);
int aokiUsed = rid - lid;
int takahashiUsed = n - rid;
if (aokiUsed <= takahashiUsed) {
l = md;
} else {
r = md;
}
}
int lid2, rid2;
tie(lid2, rid2) = f(n, l, x);
ll firstUsed = sa[n] - sa[rid2];
if (lid2 == 0) {
return firstUsed;
}
ll secondUsed = 0;
int aokiUsed = rid2 - lid2;
int takahashiUsed = n - rid2;
if (aokiUsed + 1 == takahashiUsed) {
lid2--;
}
if (lid2 % 2 == 0) {
secondUsed = sa[lid2] - evenSa[lid2];
} else {
secondUsed = evenSa[lid2];
}
return firstUsed + secondUsed;
}
void test() {
while (true) {
int n = 10;
FOR(i, n) a[i] = rand() % 5 + 1;
a[0] = ten(9) - ten(3);
FOR(i, n - 1) a[i + 1] += a[i];
sort(a, a + n);
init(n);
FOR(i, 100) {
int x = rand();
ll ans = solve(n, x);
ll ans2 = naive(n, x);
if (ans != ans2) {
cout << "?";
}
}
}
}
int main() {
// test();
int n, q; reader(n, q);
FOR(i, n) reader(a[i]);
init(n);
FOR(i, q) {
ll x; reader(x);
ll ans = solve(n, x);
writerLn(ans);
}
return 0;
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
const int MAX_N=1e5;
int N,Q;
ll A[MAX_N],psm[MAX_N+1],psm2[MAX_N+1];
bool C(ll x,ll r){
int cnt=upper_bound(A,A+N,x+r-1)-lower_bound(A,A+N,x-r+1);
int ub=upper_bound(A,A+N,x+r-1)-A;
return N-ub>=cnt;
}
int main(){
cin>>N>>Q;
REP(i,N)cin>>A[i];
REP(i,N)psm[i+1]=psm[i]+A[i];
psm2[1]=A[0];
REP(i,N-1){
psm2[i+2]=psm2[i]+A[i+1];
}
REP(q,Q){
ll X;
cin>>X;
ll ans=0;
int tn,alb,aub;
{
int lb=0,ub=1e9+1;
while(ub-lb>1){
int mid=(lb+ub)>>1;
if (C(X,mid)){
lb=mid;
}else{
ub=mid;
}
}
ll r=lb;
if (r!=0){
alb=upper_bound(A,A+N,X-r)-A;
aub=lower_bound(A,A+N,X+r)-A;
}else{
alb=aub=lower_bound(A,A+N,X)-A;
}
int cnt=aub-alb;
ans+=psm[N]-psm[N-cnt];
tn=N-cnt-1;
}
while(tn>=aub){
ans+=A[tn];
tn--;
bool f1=false,f2=false;
if (alb>0){
f1=true;
}
if (tn>=aub){
f2=true;
}
if (f1==false && f2==false){
break;
}
if (f1 && (!f2 || X-A[alb-1]<=A[aub]-X)){
alb--;
}else{
aub++;
}
}
ans+=psm2[alb];
cout<<ans<<endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define forr(i, a, b) for(int i = (a); i < (int) (b); i++)
#define forn(i, n) forr(i, 0, n)
#define dforr(i, a, b) for(int i = (int)(b-1); i >= (a); i--)
#define dforn(i, n) dforr(i, 0, n)
#define db(v) cerr << #v << " = " << v << endl
#define pb push_back
#define sz(x) ((int)x.size())
#define fst first
#define snd second
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
const int MAXN = 100500;
int n, q, A[MAXN];
ll S[MAXN], T[MAXN];
int notyet(int x, int d){
auto it1 = lower_bound(A, A+n, x-d);
auto it2 = lower_bound(A, A+n, x+d);
int forB = it2 - it1, forA = A+n - it2;
return forB <= forA;
}
ll sum(int l, int r){ return S[r] - S[l]; }
ll calc(int x, int d, bool deb = 0){
auto it1 = lower_bound(A, A+n, x-d);
auto it2 = lower_bound(A, A+n, x+d);
int forB = it2 - it1, forA = A+n - it2;
assert(forA-forB <= 2);
if(forA - forB == 2) forA--;
if(deb){
printf("Lo primero que toma es %lld\n", sum(n-forA, n));
printf("Luego quedan los primeros %d\n", it1-A);
printf("De aca sale %lld\n", T[it1-A]);
}
return sum(n-forA, n) + T[it1-A];
}
int main(){
// freopen("input.txt", "r", stdin);
while(scanf("%d %d", &n, &q) >= 1){
forn(i, n)scanf("%d", &A[i]);
S[0] = 0; forr(i, 1, n+1)S[i] = S[i-1] + A[i-1];
T[0] = 0; forr(i, 1, n+1)T[i] = T[i-1] + ((n%2 != i%2) ? 0 : A[i-1]);
// printf("S:"); forn(i, n+1)printf(" %lld", S[i]); puts("");
// printf("T:"); forn(i, n+1)printf(" %lld", T[i]); puts("");
forn(cs, q){
int x; scanf("%d", &x);
int l = 0, r = 1e9;
while(r-l > 1){
int m = (l+r)/2;
if(notyet(x, m))l = m;
else r = m;
}
// printf("El limite correcto es %d\n", l);
printf("%lld\n", calc(x, l, 0));
}
}
return 0;
}
|
p03158 | C++ | // need
#include <iostream>
#include <algorithm>
// data structure
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <complex>
//#include <deque>
#include <valarray>
#include <unordered_map>
#include <unordered_set>
#include <array>
// stream
//#include <istream>
#include <sstream>
//#include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
//#include <chrono>
#include <random>
#include <numeric>
// input
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int w_=0; w_<n; ++w_){MACRO_VEC_ROW_Scan(w_, __VA_ARGS__);}
template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }
template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& R:c)for(auto& w:R)std::cin>>w;
// output
#define OUT(dist) std::cout<<(dist);
#define FOUT(n, dist) std::cout<<std::fixed<<std::setprecision(n)<<(dist);
#define SOUT(n, c, dist) std::cout<<std::setw(n)<<std::setfill(c)<<(dist);
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
#define SHOW(dist) {std::cerr << #dist << "\t:" << (dist) << "\n";}
#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}
#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}
#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}
// utility
#define ALL(a) (a).begin(),(a).end()
#define FOR(w, a, n) for(int w=(a);w<(n);++w)
#define RFOR(w, a, n) for(int w=(n)-1;w>=(a);--w)
#define REP(w, n) for(int w=0;w<int(n);++w)
#define RREP(w, n) for(int w=int(n)-1;w>=0;--w)
#define FORLL(w, a, n) for(ll w=ll(a);w<ll(n);++w)
#define RFORLL(w, a, n) for(ll w=ll(n)-1;w>=ll(a);--w)
#define REPLL(w, n) for(ll w=0;w<ll(n);++w)
#define RREPLL(w, n) for(ll w=ll(n)-1;w>=0;--w)
#define IN(a, x, b) (a<=x && x<b)
template<class T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}
//void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template<typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")"; return os;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-10;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template<class T, size_t N> void FILL(T(&a)[N], const T& val) { for (auto& x : a) x = val; }
template<class ARY, size_t N, size_t M, class T> void FILL(ARY(&a)[N][M], const T& val) { for (auto& b : a) FILL(b, val); }
template<class T> void FILL(std::vector<T>& a, const T& val) { for (auto& x : a) x = val; }
template<class ARY, class T> void FILL(std::vector<std::vector<ARY>>& a, const T& val) { for (auto& b : a) FILL(b, val); }
// ------------>8------------------------------------->8------------
signed main() {
INIT;
VAR(int, n, Q);
VEC(int, a, n);
std::vector<int> c(n + 1, 0);
REP(i, n) c[i + 1] = c[i] + a[i];
std::vector<int> e(n + 1, 0);
if (n % 2 == 0) {
e[2] = a[1];
for (int i = 4; i < n; i += 2) e[i] = e[i - 2] + a[i - 1];
}
else {
e[1] = a[0];
for (int i = 3; i < n; i += 2) e[i] = e[i - 2] + a[i - 1];
}
REP(_, Q) {
VAR(int, x);
auto check = [&](int d) {
int t = a[n - d - 1];
int pos = std::lower_bound(ALL(a), x - std::abs(a[n - d] - x)) - a.begin();
return d <= (n - d) - pos + 1;
};
int ok = 0, ng = n;
while (ng - ok > 1) {
int me = (ok + ng) / 2;
if (check(me)) ok = me;
else ng = me;
}
int ans = c[n] - c[n - ok];
if(n - 2 * ok >= 0) ans += e[n - 2 * ok];
OUT(ans)BR;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define SPEED ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define fileio freopen("in.in", "r", stdin),freopen("out.out", "w", stdout);
#define ll long long int
#define FF first
#define SS second
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define pll pair<long long int,long long int>
#define sd(x) scanf("%d",&x)
#define slld(x) scanf("%lld",&x)
#define pd(x) printf("%d\n",x)
#define plld(x) printf("%lld\n",x)
#define pss printf
#define MOD 1000000007
#define INF 1e18
#define eps 0.00001
#define endl '\n'
#define debug(n1) cout<<n1<<endl
int n,q;
ll a[100005];
ll b[100005];
ll so[100005],se[100005];
int in[100005];
int qur[100005];
bool check(int x,int i)
{
int diff=abs(a[i-1]-x);
int j=lower_bound(a+1,a+n+1,x-diff)-a;
return (i-j>n-i+1);
}
ll solve(int x)
{
ll ans=0;
int l=upper_bound(a+1,a+n+1,x)-a,r=n+1;
int mid=(l+r)>>1;
while(r-l>1)
{
if(check(x,mid))
r=mid;
else
l=mid;
mid=(l+r)>>1;
}
while(mid>1&&check(x,mid))mid--;
while(mid<n&&!check(x,mid+1))
mid++;
mid=min(mid,n);
ans=b[n]-b[mid-1];
int cnt=n-mid+1;
if((n-2*cnt)%2)
return ans+so[n-2*cnt];
return ans+se[n-2*cnt];
}
int main()
{
SPEED;
cin>>n>>q;
for(int i=1;i<=n;i++)
{
cin>>a[i],b[i]=a[i]+b[i-1];
so[i]+=so[i-1];
se[i]+=se[i-1];
if(i%2)
so[i]+=a[i];
else
se[i]+=a[i];
}
for(int i=1;i<=q;i++)
cin>>qur[i];
for(int i=1;i<=q;i++)
cout<<solve(qur[i])<<endl;
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
#define va first
#define vb second
#define lb lower_bound
#define pb push_back
#define all(v) v.begin(),v.end()
#define fio ios_base::sync_with_stdio(0);cin.tie(0);
using namespace std;
using ll = long long;
using lf = long double;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
int n, q;
int A[100005];
ll psum[100005], osum[100005];
int main(){
fio;
cin >> n >> q;
for(int i = 1; i <= n; i++){
cin >> A[i];
psum[i] = psum[i-1] + A[i];
osum[i] = A[i];
if(i > 1) osum[i] += osum[i-2];
}
for(int x; q--;){
cin >> x;
//cout << "x = " << x << '\n';
int id = lb(A+1,A+n+1,x) - A;
int lo = id, mi, hi = n;
while(lo < hi){
mi = (lo + hi) >> 1;
int jd = lb( A+1,A+n+1,x+x - A[mi] ) - A;
if(mi - jd < n - mi) lo = mi + 1;
else hi = mi;
}
//cout << "hi = " << hi << '\n';
ll ans = psum[n] - psum[hi-1];
if(2*hi - n - 2 >= 0) ans += osum[2*hi - n - 2];
cout << ans << '\n';
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9+7;
#ifndef M_PI
const double M_PI = acos(-1.0);
#endif
int main(){
int n, q;
cin>>n>>q;
vector<int> a(n);
for(int i=0; i<n; ++i){
scanf("%d", &a[i]);
}
vector<ll> par_sum(n+1), jump_sum(n+1);
for(int i=0; i<n; ++i){
par_sum[i+1] = par_sum[i]+a[i];
}
for(int i=1; i<=n; ++i){
jump_sum[i] = a[i-1];
if(i>1)
jump_sum[i] += jump_sum[i-2];
}
for(int i=0; i<q; ++i){
int x;
scanf("%d", &x);
int l=1, r=(n+1)/2+1;
while(l+1 < r){
int m = (l+r)/2;
if(a[n-m] <= x){
r = m;
}else {
if(a[n-m] - x >= x-a[n-2*m+1]){
l = m;
} else {
r = m;
}
}
}
ll res = par_sum[n]-par_sum[n-l];
if(n-2*l > 0)
res += jump_sum[n-2*l];
printf("%lld ", res);
}
return 0;
} |
p03158 | C++ | #include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<functional>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define MOD 1000000007
#define f(i,n) for(long long i=0;i<(long long)(n);i++)
#define N 200010
long long a[N];
long long n, k, q;
long long bs(long long x, long long r){
long long nl, nr, nm;
nl = 0;
nr = n;
while (nl + 1 < nr){
nm = (nl + nr) / 2;
if (a[nm] >= x - r)nl = nm;
else nr = nm;
}
return nl;
}
int main(){
long long b[N];
long long c[N];
f(i, N)a[i] = 0;
long long x, y, z;
long long s, ans;
long long l, r, m;
bool v = true;
ans = 0;
scanf("%lld %lld", &n,&q);
f(i, n){
scanf("%lld", &a[n-i-1]);
}
b[0] = 0;
f(i, n){
b[i + 1] = b[i] + a[i];
}
b[n + 1] = b[n];
c[n] = 0;
c[n + 1] = 0;
c[n + 2] = 0;
for (int i = n - 1; i >= 0; i--){
if (i % 2 == 0){
c[i] = c[i + 1] + a[i];
}
else c[i] = c[i + 1];
}
f(qq, q){
scanf("%lld", &k);
l = 0;
r = n;
while (l + 1 < r){
m = (l + r) / 2;
z = bs(k, a[m] - k);
x = z - m;
if (m <= x)l = m;
else r = m;
}
ans = 0;
ans = b[l + 1];
ans += c[(2 * l) + 2];
printf("%lld\n", ans);
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <algorithm>
#include <complex>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
int in() { int x; scanf("%d", &x); return x; }
ll lin() { ll x; scanf("%lld", &x); return x; }
int main() {
int n, q;
cin >> n >> q;
VL a(n);
REP(i,n) a[i] = in();
VL s(n+1), s2(n+2);
REP(i,n) s[i+1] = s[i] + a[i];
s2[1] = a[0];
FOR(i,2,n) s2[i] = s2[i - 2] + a[i - 1];
vector<PL> xx(q);
REP(i,q) xx[i] = PL(in(), i);
sort(ALL(xx));
reverse(ALL(xx));
VL ans(q);
ll c = 1;
REP(t,q){
ll x = xx[t].first;
while (true){
ll r = n - c - 1;
ll l = n - 2 * c;
if (l <= 0){
break;
}
if (a[r] - x >= x - a[l - 1]){
c++;
}else{
break;
}
}
ll tmp = s[n] - s[n - c];
ll l = n - 2 * c;
if (l > 0) tmp += s2[l];
ans[xx[t].second] = tmp;
}
REP(i,q){
printf("%lld\n", ans[i]);
}
return 0;
}
|
p03158 | C++ | #include <cstdio>
#include <cmath>
#include <iostream>
#include <set>
#include <algorithm>
#include <vector>
#include <map>
#include <cassert>
#include <string>
#include <cstring>
#include <queue>
using namespace std;
#define rep(i,a,b) for(int i = a; i < b; i++)
#define S(x) scanf("%d",&x)
#define S2(x,y) scanf("%d%d",&x,&y)
#define P(x) printf("%d\n",x)
#define all(v) v.begin(),v.end()
#define FF first
#define SS second
#define pb push_back
#define mp make_pair
typedef long long int LL;
typedef pair<int, int > pii;
typedef vector<int > vi;
const int N = 100005;
int A[N];
LL AS[N], SS[N];
int n;
LL ans[N];
vector<pii > Q;
LL diff(int idx, int val) {
return abs(A[idx] - val);
}
bool check(int x, int y, int val) {
int d = n - y;
int l = y + 1 - d;
if(l < 2) return true;
return diff(l - 1, val) > diff(y, val);
}
int main() {
int q;
S2(n,q);
rep(i,1,n+1) {
S(A[i]);
AS[i] = A[i];
if(i >= 2) {
AS[i] += AS[i - 2];
}
}
for(int i = n; i >= 1; i--) {
SS[i] = SS[i + 1] + A[i];
}
rep(i,0,q) {
int x;
S(x);
Q.pb(mp(x, i));
}
sort(all(Q));
int idx = 0;
int cl = n / 2;
rep(i,0,q) {
int x = Q[i].FF;
while(idx < n && A[idx + 1] <= x) {
idx++;
while(cl < n - 1 && check(idx, cl + 1, x)) {
cl++;
}
cl = max(cl, idx);
}
while(cl < n - 1 && check(idx, cl + 1, x)) {
cl++;
}
cl = max(cl, idx);
// printf("%d %d %d\n",x,idx,cl);
if(idx >= n - 1) {
ans[Q[i].SS] = AS[n];
continue;
} else if(!idx) {
ans[Q[i].SS] = SS[n / 2 + 1];
continue;
}
LL res = SS[cl + 1];
int l = cl - (n - cl);
if(l > 0) {
res += AS[l];
}
ans[Q[i].SS] = res;
}
rep(i,0,q) {
printf("%lld\n",ans[i]);
}
return 0;
}
|
p03158 | C++ | #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>
#include <cassert>
#if __cplusplus >= 201103L
#include <array>
#include <tuple>
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>
#define cauto const auto&
#define ALL(v) begin(v),end(v)
#else
#define ALL(v) (v).begin(),(v).end()
#endif
using namespace std;
namespace{
typedef long long LL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define VV(T) vector<vector< T > >
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
v.assign(a, vector<T>(b, t));
}
template <class T> inline T &chmin(T &x, const T &y){ return x = min(x, y); }
template <class T> inline T &chmax(T &x, const T &y){ return x = max(x, y); }
template <class F, class T>
void convert(const F &f, T &t){
stringstream ss;
ss << f;
ss >> t;
}
#define REP(i,n) for(int i=0;i<int(n);++i)
#define RALL(v) (v).rbegin(),(v).rend()
#define MOD 1000000007LL
#define EPS 1e-8
inline LL get(const vector<LL> &a, int i){
return i < 0 ? 0LL : a[i];
}
void mainmain(){
int n, q;
scanf("%d%d", &n, &q);
--n;
vector<LL> as(n + 1);
for(int i = 1; i <= n; ++i){
scanf("%lld", &as[i]);
}
LL last;
scanf("%lld", &last);
vector<LL> acc(n + 1);
vector<LL> acc2(n + 1);
for(int i = 1; i <= n; ++i){
acc[i] = acc[i - 1] + as[i];
acc2[i] = get(acc2, i - 2) + as[i];
}
for(; q--; ){
LL x;
scanf("%lld", &x);
int low = 0, high = n / 2;
while(low < high){
int num1 = (low + high + 1) >> 1;
bool ok = false;
if(num1 == 0){ ok = true; }
else{
int rt = n - num1 + 1;
LL dif = as[rt] - x;
if(dif >= 0){
int lt = lower_bound(ALL(as), max(x - dif, 1LL)) - as.begin();
int num2 = rt - lt;
if(num2 >= num1){ ok = true; }
}
}
if(ok){ low = num1; }
else{ high = num1 - 1; }
}
LL ans = 0;
if(low == 0){
ans = get(acc2, n - 1);
}
else{
int rt = n - low + 1;
LL dif = as[rt] - x;
int lt = lower_bound(ALL(as), max(x - dif, 1LL)) - as.begin();
lt = max(lt, rt - low);
ans = get(acc, n) - get(acc, rt - 1) + get(acc2, lt - 2);
}
printf("%lld\n", ans + last);
}
}
}
int main() try{
// ios::sync_with_stdio(false); cin.tie(0);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(4);
mainmain();
}
catch(...){}
|
p03158 | C++ | #include <bits/stdc++.h>
#define GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
#define pr(...) cerr<< GET_MACRO(__VA_ARGS__,pr8,pr7,pr6,pr5,pr4,pr3,pr2,pr1)(__VA_ARGS__) <<endl
#define pr1(a) (#a)<<"="<<(a)<<" "
#define pr2(a,b) pr1(a)<<pr1(b)
#define pr3(a,b,c) pr1(a)<<pr2(b,c)
#define pr4(a,b,c,d) pr1(a)<<pr3(b,c,d)
#define pr5(a,b,c,d,e) pr1(a)<<pr4(b,c,d,e)
#define pr6(a,b,c,d,e,f) pr1(a)<<pr5(b,c,d,e,f)
#define pr7(a,b,c,d,e,f,g) pr1(a)<<pr6(b,c,d,e,f,g)
#define pr8(a,b,c,d,e,f,g,h) pr1(a)<<pr7(b,c,d,e,f,g,h)
#define prArr(a) {cerr<<(#a)<<"={";int i=0;for(auto t:(a))cerr<<(i++?", ":"")<<t;cerr<<"}"<<endl;}
using namespace std;
using Int = long long;
using _int = int;
using ll = long long;
using Double = long double;
const Int INF = (1LL<<60)+1e9; // ~ 1.15 * 1e18
const Int mod = (1e9)+7;
const Double EPS = 1e-8;
const Double PI = 6.0 * asin((Double)0.5);
using P = pair<Int,Int>;
template<class T> T Max(T &a,T b){return a=max(a,b);}
template<class T> T Min(T &a,T b){return a=min(a,b);}
template<class T1, class T2> ostream& operator<<(ostream& o,pair<T1,T2> p){return o<<"("<<p.first<<","<<p.second<<")";}
template<class T1, class T2, class T3> ostream& operator<<(ostream& o,tuple<T1,T2,T3> t){
return o<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<")";}
template<class T1, class T2> istream& operator>>(istream& i,pair<T1,T2> &p){return i>>p.first>>p.second;}
template<class T> ostream& operator<<(ostream& o,vector<T> a){Int i=0;for(T t:a)o<<(i++?" ":"")<<t;return o;}
template<class T> istream& operator>>(istream& i,vector<T> &a){for(T &t:a)i>>t;return i;}
//INSERT ABOVE HERE
signed main(){
srand((unsigned)time(NULL));
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
Int N, Q;
cin>>N>>Q;
set<Int> A, B; //A:select max, B:select near x
Int sumA = 0;
Int sumB = 0;
{
vector<Int> tmp(N);
cin>>tmp;
for(Int i=N-1;i>=0;i--){
if((N-1 - i)%2 == 0) {
A.insert(tmp[i]);
sumA += tmp[i];
}
else B.insert(tmp[i]), sumB += tmp[i];
}
}
auto getMax = [](set<Int> &S){return *(--S.end());};
auto getNearX = [](Int X, set<Int> &S){
auto it = S.lower_bound(X);
if(it == S.begin()) return P(-INF,*it);
auto it2 = --S.lower_bound(X);
return P(*it2, *it);
};
auto aplly= [&](Int X){
while(1){
Int b = getMax(B);
Int l, r;
tie(l, r) = getNearX(X, A);
Int x = abs(X - l) <= abs(X - r)? l:r;
//prArr(A);
//prArr(B);
//pr(X, b, x, l, r);
if( b < X ) break;
if( b < x ) x = l;
if( b < x ) break;
if((abs(X - b) > abs(X - x)) || (abs(X - b) == abs(X - x) && x < b)){
B.erase(b);
A.erase(x);
B.insert(x);
A.insert(b);
sumA += b - x;
sumB += x - b;
}
else break;
}
};
vector<P> X;
for(Int i=0;i<Q;i++){
Int x;
cin>>x;
X.push_back(P(x, i));
}
sort(X.begin(), X.end(), greater<P>());
vector<Int> ans(Q);
for(Int i=0;i<Q;i++){
aplly(X[i].first);
ans[X[i].second] = sumA;
}
cout<<ans<<endl;
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
const int N = 1e5 + 10;
int a[N], n, q;
LL sum[N], oddS[N];
void init() {
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
oddS[1] = a[1];
for (int i = 2; i <= n; i++) oddS[i] = oddS[i - 2] + a[i];
}
bool check(int x, int mid) {
if (a[mid] <= x) return 1;
int left = lower_bound(a + 1, a + n + 1, 2 * x - a[mid]) - a;
return mid - left + 1 < n - mid + 1;
}
LL solve(int x) {
if (x >= a[n]) return oddS[n];
int l = 1, r = n;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (check(x, mid)) l = mid;
else r = mid;
}
int p = n - (n - l) * 2;
return sum[n] - sum[l] + oddS[p];
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
init();
while (q--) {
int x;
scanf("%d", &x);
printf("%lld\n", solve(x));
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
int N, Q, A[100001];
int64_t S[100001], Sdiv[100001];
pair<int, int> X[100000];
int64_t ans[100000];
int main(){
cin >> N >> Q;
for(int i=1; i<=N; i++){
cin >> A[i];
S[i] = S[i-1] + A[i];
Sdiv[i] = A[i];
if(i-2 > 0) Sdiv[i] += Sdiv[i-2];
}
for(int i=0; i<Q; i++){
int x;
cin >> x;
X[i] = {x, i};
}
sort(X, X+Q);
int y = 1;
for(int q=0; q<Q; q++){
int x = X[q].first;
while(y<=N && A[y] < x) y++;
while(y<=N){
int upper = N - y + 1;
int lower = y - (lower_bound(A, A+N+1, max(1, 2*x-A[y])) - A) + 1;
if(upper > lower){
y++;
}else{
break;
}
}
int64_t result = S[N] - S[y-1];
int t_first = N - (N-y+1)*2;
if(t_first > 0) result += Sdiv[t_first];
ans[X[q].second] = result;
}
for(int i=0; i<Q; i++) cout << ans[i] << endl;
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll,ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll n,q,a[100005],s[100005],as[100005];
bool ch(ll m,ll x){
ll p=lower_bound(a,a+n,2*x-a[m])-a;
return m-p>=n-m-1;
}
int main(void){
scanf("%lld%lld",&n,&q);
for(int i=0;i<n;i++)scanf("%lld",a+i),s[i]=a[i],as[i]=a[i];
for(int i=0;i+2<n;i++)s[i+2]+=s[i];
for(int i=0;i+1<n;i++)as[i+1]+=as[i];
while(q--){
ll x,ans=0;
scanf("%lld",&x);
ll l=-1,r=n;
while(r-l>1){
ll m=(l+r)/2;
if(ch(m,x))r=m;
else l=m;
}
if(r==0){
printf("%lld\n",as[n-1]);
continue;
}
ans+=(as[n-1]-as[r-1]);
ll p=lower_bound(a,a+n,2*x-a[r])-a;
p=r-(n-r);
if(p-1>=0){
ans+=s[p-1];
}
printf("%lld\n",ans);
}
}
|
p03158 | C++ | // includes {{{
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<tuple>
#include<cmath>
#include<random>
#include<cassert>
// #include<deque>
// #include<multiset>
// #include<bitset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;
// #undef DEBUG
// #define DEBUG
// DEBUG {{{
#include <array>
#include <deque>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <tuple>
#include <valarray>
#include <vector>
// clang-format off
template<int n, class...T> typename enable_if<(n>=sizeof...(T))>::type _ot(ostream &, tuple<T...> const &){}
template<int n, class...T> typename enable_if<(n< sizeof...(T))>::type _ot(ostream & os, tuple<T...> const & t){ os << (n==0?"":", ") << get<n>(t); _ot<n+1>(os, t); }
template<class...T> ostream & operator<<(ostream &o, tuple<T...> const &t){ o << "("; _ot<0>(o, t); o << ")"; return o; }
template<class T, class U> ostream & operator<<(ostream &o, pair<T, U> const &p) { o << "(" << p.first << ", " << p.second << ")"; return o; }
template < class T > ostream &operator<<(ostream &o, const stack<T> &a) { o << "{"; for(auto tmp = a; tmp.size(); tmp.pop()) o << (a.size() == tmp.size() ? "" : ", ") << tmp.top(); o << "}"; return o; }
template <class T, class Container, class Compare > ostream &operator<<(ostream &os, priority_queue<T, Container, Compare> a) { os << "{ (top) "; while(a.size()) os << a.top() << (a.size() == 1 ? "" : ", "), a.pop(); os << " }"; return os; }
template <class T, class Container > ostream &operator<<(ostream &os, queue<T, Container> a) { os << "{ "; while(a.size()) os << a.front() << (a.size() == 1 ? "" : ", "), a.pop(); os << " }"; return os; }
#ifdef DEBUG
#if !defined(DEBUG_OUT)
#define DEBUG_OUT cerr
#endif
#if !defined(DEBUG_LEFT)
#define DEBUG_LEFT "\e[1;36m"
#endif
#if !defined(DEBUG_RIGHT)
#define DEBUG_RIGHT ":\e[m"
#endif
#define dump(...) [&](){auto __debug_tap=make_tuple(__VA_ARGS__);DEBUG_OUT<<DEBUG_LEFT<<__LINE__ << DEBUG_RIGHT << " " <<#__VA_ARGS__<<" = "<<__debug_tap<<endl;}()
template < class T > inline void dump2D(T &d, size_t sizey, size_t sizex) { for(size_t i = 0; i < sizey; i++) { DEBUG_OUT << "\t"; for(size_t j = 0; j < sizex; j++) DEBUG_OUT << d[i][j] << (j + 1 == sizex ? "" : "\t"); DEBUG_OUT << endl; } }
template < class T > inline void dump1D(T &d, size_t sizey) { for(size_t i = 0; i < sizey; i++) { DEBUG_OUT << d[i] << (i + 1 == sizey ? "" : " "); } DEBUG_OUT << endl; }
template < class T, class = typename iterator_traits< decltype(begin(T())) >::value_type, class = typename enable_if<!is_same<T, string>::value>::type > ostream &operator<<(ostream &o, const T &a) { o << "{"; for(auto ite = begin(a); ite != end(a); ++ite) o << (ite == begin(a) ? "" : ", ") << *ite; o << "}"; return o; }
#else
#define dump(...) (42)
#define dump2D(...) (42)
#define dump1D(...) (42)
template < class T, class = typename iterator_traits< decltype(begin(T())) >::value_type, class = typename enable_if<!is_same<T, string>::value>::type > ostream &operator<<(ostream &o, const T &a) { for(auto ite = begin(a); ite != end(a); ++ite) o << (ite == begin(a) ? "" : " ") << *ite; return o; }
#endif
// clang-format on
// }}}
int n, q;
const int N = 1e5;
int x;
int a[N];
int last = 0;
// k回を行えるか
bool check(int k) {
int pnear = k / 2;
int pmax = k - pnear;
int p = lower_bound(a, a + n, x) - a;
// dump(p);
int ng = -1, ok = n - p;
int rest = (n - p) - pmax;
if(rest < 0) return 0;
while(abs(ok - ng) > 1) {
int mid = (ok + ng) >> 1;
int range = a[p + mid] - x;
int q = lower_bound(a, a + n, x - range) - a;
int left = p - q;
// mid + left個食う
if(left + mid >= pnear) ok = mid; else ng = mid;
}
// near は右 ok 個だけ食えばいい
if(ok <= rest) {
return 1;
}
return 0;
}
ll suma[2][N];
ll rang2(int i, int l, int r) {
if(l < 0) l = 0;
if(l > r) return 0;
ll res = suma[i][r];
if(l-1 >= 0) res -= suma[i][l-1];
return res;
}
ll rang(int l, int r) {
return rang2(0, l, r) + rang2(1, l, r);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> q;
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++) suma[i%2][i] = a[i];
for(int i = 1; i < n; i++) suma[0][i] += suma[0][i-1], suma[1][i] += suma[1][i-1];
for(int i = 0; i < q; i++) {
cin >> x;
int ng = n + 1, ok = 0;
// 何ターンで不規則になるか
while(abs(ng - ok) > 1) {
int mid = (ok + ng) >> 1;
// dump(mid);
if(check(mid)) ok = mid; else ng = mid;
}
// dump(ok);
int c = (ok + 1)/2;
ll ans = 0;
ans += rang(n - 1 - c + 1, n - 1);
// n - k - 1 から食べ始める (k % 2) が
ans += rang2(((n - ok - 1) & 1) ^ (ok % 2), 0, n - ok - 1);
cout << ans << "\n";
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int N, Q;
while(cin >> N >> Q){
vector<int> A(N);
for(int& t : A) cin >> t;
vector<long long> sum(N+1, 0);
for(int i=0;i<N;i++) sum[i+1] = sum[i] + A[i];
vector<long long> rest(N, 0);
if(N%2==0){
rest[1] = A[1];
for(int i=3;i<N;i+=2) rest[i] = rest[i-2] + A[i];
} else {
rest[0] = A[0];
for(int i=2;i<N;i+=2) rest[i] = rest[i-2] + A[i];
}
for(int i=0;i<Q;i++){
int X; cin >> X;
int L = 1, R = N;
while(R-L > 1){
int mid = (L+R)/2;
int last = N-mid;
int last_a = N-2*mid+1;
if(last_a >= 0 && abs(A[last]-X) >= abs(A[last_a]-X)) L = mid;
else R = mid;
}
long long res = sum.back() - sum[N-L];
if(N-1-2*L>=0) res += rest[N-1-2*L];
cout << res << endl;
}
}
} |
p03158 | C++ | #include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<bitset>
#include<stack>
#include<memory>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*
cout<<fixed<<setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
*/
const llint mod=1000000007;
const llint big=2.19e15+1;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-15;
template <class T,class U>bool mineq(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool maxeq(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>llint LBI(vector<T>&ar,T in){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>llint UBI(vector<T>&ar,T in){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
int main(void) {
int n,Q,i;cin>>n>>Q;
vector<llint>A(n);
for(i=0;i<n;i++){cin>>A[i];}
vector<llint>hwa(n+1);
for(i=1;i<=n;i++){hwa[i]=hwa[i-1]+A[n-i];}
vector<llint>twa(n);
twa[0]=A[0];twa[1]=A[1];
for(i=2;i<n;i++){twa[i]=twa[i-2]+A[i];}
twa.insert(twa.begin(),0);
twa.insert(twa.begin(),0);
while(Q--){
llint X;cin>>X;
llint bmax=(n+3)/2,bmin=1;
//bmin枚以上は上からとれる
while(bmax-bmin>1){
//cerr<<"d";
llint bgen=(bmax+bmin)/2;
llint Y=A[n-bgen];
if(n-bgen-LBI(A,X+X-Y)+1>=bgen){bmin=bgen;}
else{bmax=bgen;}
}
//cerr<<"bmin="<<bmin<<endl;
cout<<hwa[bmin]+twa[n-bmin-bmin+1]<<endl;
}
} |
p03158 | C++ | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(int i=0;i<n;i++)
#define rep3(i,a,b) for(int i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define tii tuple<int,int,int>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define edge(v,a,b) v[a].pb(b);v[b].pb(a);
#define MAX_V 400010
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define endl "\n"
#define ALL(c) (c).begin(),(c).end()
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
template<typename A, size_t NNN, typename T>
void Fill(A (&array)[NNN], const T &val){
fill( (T*)array, (T*)(array+NNN), val );
}
#define INF 1e9+7
#define LLINF 1e18+7
ll MOD=1e9+7;
#define N 205050
ll n;
ll p;
ll a[N];
ll x[N];
ll b[N],c[N],sum[N];
main(){
int n=in(),q=in();
rep2(i,1,n)a[i]=in();
rep(i,q)x[i]=in();
b[1]=a[1];
c[2]=a[2];
sum[1]=a[1];sum[2]=a[1]+a[2];
rep2(i,3,n){
if(i%2)b[i]=b[i-2]+a[i];
else c[i]=c[i-2]+a[i];
sum[i]=sum[i-1]+a[i];
}
rep(iii,q){
ll t=x[iii];
int l=-1,r=INF;
while(l<r-1){
ll mid=(l+r)/2;
int rr=upper_bound(a+1,a+(n+1),t+mid)-a;
int lll=lower_bound(a+1,a+(n+1),t-mid)-a;
if(n-rr+1>=rr-lll){
l=mid;
}
else r=mid;
}
if(l==-1){
cout<<b[n]+c[n]<<endl;
continue;
}
int rr=upper_bound(a+1,a+(n+1),t+l)-a;
int lll=lower_bound(a+1,a+(n+1),t-l)-a;
int cnt=n-rr+1;
cout<<sum[n]-sum[rr-1]+(b[n-2*cnt]+c[n-2*cnt])<<endl;;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
long long sum[N], sum1[N], sum2[N];
int main(){
int n, q, x, l, r, mid, d;
long long ans;
scanf("%d %d",&n,&q);
for (int i = 1; i <= n; i++) scanf("%d",&a[i]);
sum[0] = sum1[0] = sum2[0] = 0;
for (int i = 1; i <= n; i++){
sum[i] = sum[i - 1] + a[i];
if (i & 1) sum1[(i + 1) / 2] = sum1[(i - 1) / 2] + a[i];
else sum2[i / 2] = sum2[i / 2 - 1] + a[i];
}
for (int i = 1; i <= q; i++){
scanf("%d",&x);
d = lower_bound(a + 1, a + n + 1, x) - a;
l = d - 1; r = n;
while (r - l > 1){
mid = (l + r) / 2;
d = lower_bound(a + 1, a + n + 1, x * 2 - a[mid]) - a;
if (mid - d + 1 > n - mid) r = mid;
else l = mid;
}
ans = sum[n] - sum[l];
if (l * 2 - n >= 1){
if ((l * 2 - n) & 1) ans += sum1[(l * 2 - n + 1) / 2];
else ans += sum2[(l * 2 - n) / 2];
}
printf("%lld\n", ans);
}
return 0;
} |
p03158 | C++ | // KALAM
# include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 77;
int n , q , a[N];
long long Ps[N] , Psr[N];
int Get(int x , int t){
int id = lower_bound(a + 1 , a + 1 + n , x + x - a[t]) - a;
return t - id + 1;
}
long long Solve(int x){
long long A = 0;
if(x >= a[n])
return Psr[n];
if(x <= a[1])
return Ps[n] - Ps[n >> 1];
int id = lower_bound(a + 1 , a + 1 + n , x) - a;
int ri = n , le = id - 1;
while(ri - le > 1){
int mid = ((le + ri) >> 1);
if(Get(x , mid) < n - mid + 1)
le = mid;
else
ri = mid;
}
A = Ps[n] - Ps[ri - 1];
int t = n - ri + 1;
int pos = ri - 1 - t;
A += Psr[pos];
return A;
}
int main(){
ios::sync_with_stdio(0);cin.tie(0);
cin >> n >> q;
for(int i = 1;i <= n;++ i){
cin >> a[i] , Ps[i] = Ps[i - 1] + a[i];
if(i == 1)
Psr[i] = a[i];
else
Psr[i] = a[i] + Psr[i - 2];
}
while(q --){
int k;
cin >> k;
cout << Solve(k) << '\n';
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
// pbds
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
// gp_hash_table<int, int> table;
using namespace std;
#define vec vector
#define ALL(x) begin(x), end(x)
typedef unsigned long long ull;
typedef unsigned int ui;
typedef long long ll;
typedef long double ld;
typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
const int inf = 1000 * 1000 * 1000;
const ll inf64 = 1e18;
const int N = 1e5 + 5;
int n, q;
int a[N];
ll slow(int x) {
vector< int > used(n + 1);
ll res = 0;
for(int iter = 1;iter <= n;iter++) {
if(iter & 1) {
int i = n;
while(used[i]) i--;
res += a[i];
used[i] = 1;
}else {
int p = -1;
for(int i = 1;i <= n;i++) {
if(used[i]) continue;
if(p == -1 || abs(a[i] - x) < abs(a[p] - x)) p = i;
}
used[p] = 1;
}
}
return res;
}
ll pref[N][2];
ll get_sum(int l, int r) {
if(l > r) return 0;
return pref[r][0] + pref[r][1] - pref[l - 1][0] - pref[l - 1][1];
}
void build() {
for(int i = 1;i <= n;i++) {
pref[i][0] = pref[i - 1][0];
pref[i][1] = pref[i - 1][1];
pref[i][i & 1] += a[i];
}
}
int count_leq(int x, int max_dist) {
// |a[i] - x| <= max_dist
// -max_dist <= a[i] - x <= max_dist
// -max_dist + x <= a[i] <= max_dist + x
return upper_bound(a + 1, a + n + 1, max_dist + x) - lower_bound(a + 1, a + n + 1, -max_dist + x) - 1;
}
ll fast(int x) {
ll res = 0;
int bl = 0;
int br = n;
int bm;
while(br - bl > 1) {
bm = (bl + br) / 2;
if(count_leq(x, abs(a[bm] - x)) >= n - bm + 1) {
br = bm;
}else {
bl = bm;
}
}
int p = count_leq(x, abs(a[br] - x)) >= n - br + 1 ? br : br + 1;
res += get_sum(p, n);
if(p > n) {
return pref[n][n & 1] + res;
}
int cnt = count_leq(x, abs(a[p] - x));
if(cnt == n - p + 1) {
int i = n - cnt - (n - p + 1);
return res + pref[i][i & 1];
}else {
if(count_leq(x, abs(a[p - 1] - x)) >= n - p + 1) {
res += a[p - 1];
cnt = n - p + 1;
p--;
int i = n - cnt - (n - p + 1);
return pref[i][1 ^ (i & 1)] + res;
}else {
cnt = n - p + 1;
int i = n - 2 * cnt;
return pref[i][i & 1] + res;
}
}
}
int get_rnd(mt19937 &rnd, int l, int r) {
int ln = r - l + 1;
return rnd() % ln + l;
}
int main() {
#ifdef debug
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
//#define TEST
#ifndef TEST
cin >> n >> q;
#else
n = 50;
q = 100;
#endif
mt19937 rnd(time(NULL));
for(int i = 1;i <= n;i++) {
#ifndef TEST
cin >> a[i];
#else
a[i] = get_rnd(rnd, a[i - 1] + 1, a[i - 1] + 10);
#endif
}
build();
for(int iter = 0;iter < q;iter++) {
int x;
#ifndef TEST
cin >> x;
cout << fast(x) << "\n";
// cout << slow(x) << "\n";
#else
x = get_rnd(rnd, *min_element(a, a + n + 1), *max_element(a, a + n + 1));
ll fs = fast(x);
ll sl = slow(x);
if(fs != sl) {
cout << "#" << iter + 1 << "\n";
cout << "WA!\n";
cout << n << "\n";
for(int i = 1;i <= n;i++) {
cout << a[i] << " ";
}
cout << "\n";
cout << "x = " << x << "\n";
cout << "expected = " << sl << "\n";
cout << "found = " << fs << "\n";
return 0;
}else {
cout << " OK \n";
}
#endif
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
#define hash dhsjakhd
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef long double ld;
ll n,m,T,k,q;
const ll big = 1000000007;
const ll big2 = 998244353;
ll x;
vl A;
ll CS[200002] = {0};
ll CSA[200002] = {0};
// --[++
ll bs1(ll x2){
ll l = 0;
ll r = n;
if(A[0] >= x2)return 0;
while(l < r-1){
ll mid = (l+r)/2;
if(A[mid] >= x2){
r = mid;
}
else{
l = mid;
}
}
return r;
}
// ++)--
ll bs2(ll x2){
ll l = 0;
ll r = n-1;
if(A[n-1] < x2)return n-1;
while(l < r-1){
ll mid = (l+r)/2;
if(A[mid] < x2){
l = mid;
}
else{
r = mid;
}
}
return l;
}
bool mark[100001] = {0};
ll brute(ll x){
for(int c1 = 0; c1 < n; c1++){mark[c1] = 0;}
ll ans = 0;
for(int c1 = 0; c1 < n; c1++){
if(c1%2 == 0){
for(int c1 = n-1; c1 >= 0; c1--){
if(!mark[c1]){
mark[c1] = 1;
ans += A[c1];
break;
}
}
}
else{
ll midiff = 2e9;
ll choose = 0;
for(int c1 = 0; c1 < n; c1++){
if(!mark[c1]){
ll temp = abs(A[c1]-x);
if(temp < midiff){
midiff = temp;
choose = c1;
}
}
}
mark[choose] = 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
//freopen("input.txt","r",stdin);
//freopen("autput.txt","w",stdout);
ll a,b,c,e;
cin >> n >> q;
for(ll c1 = 0; c1 < n; c1++){
cin >> a;
A.push_back(2*a);
}
CS[0] = 0;
for(ll c1 = 0; c1 < n; c1++){
CS[c1+1] = CS[c1]+A[c1];
CSA[c1] = A[c1];
if(c1 > 1)CSA[c1] += CSA[c1-2];
}
for(ll c1 = 0; c1 < q; c1++){
cin >> x;
x *= 2;
if(x >= A[n-2]){
cout << CSA[n-1]/2 << "\n";
continue;
}
if(x <= A[0]){
ll ans = CS[n]-CS[n/2];
cout << ans/2 << "\n";
continue;
}
ll l = 0;
ll r = 3e9;
while(l < r-1){
ll mid = (l+r)/2;
ll i1 = bs1(x-mid);
ll i2 = bs2(x+mid);
a = i2-i1+1;
b = n-i2-1;
if(a <= b){
l = mid;
}
else{
r = mid;
}
// cerr << l << " " << r << "\n";
}
k = n-bs2(x+l)-1;
ll res = CS[n]-CS[n-k] + CSA[n-2*k-1];
cout << (CS[n]-CS[n-k] + CSA[n-2*k-1])/2 << "\n";
/*
ll res2 = brute(x);
if(res2 != res){
cerr << "!!! x: " << x << " " << res << " " << res2 << "\n";
}
*/
}
return 0;
}
|
p03158 | C++ | #include "stdio.h"
#include <iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<math.h>
#include<queue>
using namespace std;
typedef long long int lld;
int main(){
int n,q;
cin>>n>>q;
vector<lld> arr(n);
for(int i=0;i<n;i++)cin>>arr[i];
lld cum_sum[n+1];
lld alternate_sum[n+1];
cum_sum[0]=0;
for(int i=0;i<n;i++)cum_sum[i+1]=cum_sum[i]+arr[i];
alternate_sum[0]=0;
alternate_sum[1]=arr[0];
for(int i=1;i<n;i++){
alternate_sum[i+1]=alternate_sum[i-1]+arr[i];
//cout<<cum_sum[i+1]<<endl;
}
//for(int i=0;i<n;i++)cout<<alternate_sum[i]<<endl;
for(int query=0;query<q;query++){
lld X;
cin>>X;
int lo,hi;
lo=-1;
hi=n-1;
while(hi-lo>1){//cout<<lo<<" "<<hi<<endl;
int mid=(hi+lo)/2;
if(arr[mid]<X)lo=mid;
else{
vector<lld>::iterator it=lower_bound(arr.begin(),arr.end(),2*X-arr[mid]);
int number=it-arr.begin();
int eps=(n-mid)-mid+number;
if(eps<=1)hi=mid;
else lo=mid;
}
}
//cout<<hi<<" ";
int cards_played=n-hi;
lld ans=cum_sum[n]-cum_sum[hi];
//cout<<ans<<" ";
//cout<<cards_played<<" ";
int START=n-2*cards_played;
//cout<<START<<endl;
if(START>=0)ans+=alternate_sum[START];
cout<<ans<<endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N=1e5+5;
int n, q;
int a[N], pref1[N], pref2[N], pref[N];
void precompute()
{
for(int i=1;i<=n;i++)
{
pref1[i]=pref1[i-1];
pref2[i]=pref2[i-1];
pref[i]=pref[i-1]+a[i];
if(i%2)
pref1[i]+=a[i];
else
pref2[i]+=a[i];
}
}
int check(int x, int k)
{
int cnt=upper_bound(a+1, a+n+1, x+k) - lower_bound(a+1, a+n+1, x-k);
int have=n + 1 - (upper_bound(a+1, a+n+1, x+k) - a);
return have>=cnt;
}
int binsearch(int x, int lo, int hi)
{
while(lo<hi)
{
int mid=(lo+hi+1)/2;
if(check(x, mid))
lo=mid;
else
hi=mid-1;
}
return lo;
}
int32_t main()
{
IOS;
cin>>n>>q;
for(int i=1;i<=n;i++)
cin>>a[i];
precompute();
while(q--)
{
int x;
cin>>x;
if(x>=a[n])
{
int ans;
if(n%2==0)
ans=pref2[n];
else
ans=pref1[n];
cout<<ans<<endl;
continue;
}
if(x<=a[1])
{
int cnt=n/2 + n%2;
int ans=pref[n] - pref[n-cnt];
cout<<ans<<endl;
continue;
}
int k=binsearch(x, 0, 1e9);
auto u = upper_bound(a+1, a+n+1, x+k) - a - 1;
auto v = lower_bound(a+1, a+n+1, x-k) - a - 1;
int have=n + 1 - (upper_bound(a+1, a+n+1, x+k) - a);
int cnt=upper_bound(a+1, a+n+1, x+k) - lower_bound(a+1, a+n+1, x-k);
while(have>cnt)
v--, have--;
int ans = pref[n] - pref[u];
if(v%2)
ans+=pref1[v];
else
ans+=pref2[v];
cout<<ans<<endl;
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
int n,q;
cin>>n>>q;
vector<ll> a(n);
for(int i=0;i<n;i++) cin>>a[i],a[i]*=2;
vector<ll> x(q);
for(int i=0;i<q;i++) cin>>x[i],x[i]*=2;
map<ll,pair<int,int>> mp;
for(int i=1;i<=n;i++){
int r=n-i;
int l=n-i-i;
if(l>=0){
mp[(a[r]+a[l])/2]={i,0};
}
l--,r--;
if(l>=0){
mp[(a[r]+a[l])/2]={i,1};
}
}
vector<ll> sum(n+1);
vector<ll> even(n+1);
partial_sum(a.begin(),a.end(),sum.begin()+1);
for(int i=0;i<n;i++){
if(i%2==0) even[i+1]=even[i]+a[i];
else even[i+1]=even[i];
}
for(int i=0;i<q;i++){
if(n==2 || (a[n-2]+a[n-3])/2<x[i]){
if(n%2==1) cout<<even[n]/2<<endl;
else cout<<(sum[n]-even[n])/2<<endl;
}
else if(x[i]<=(a[0]+a[n/2])/2){
cout<<(sum[n]-sum[n/2])/2<<endl;
}
else{
pair<int,int> tmp=(*mp.lower_bound(x[i])).second;
int m=tmp.first;
if(tmp.second==1){
ll res=0;
res+=sum[n]-sum[n-m-1];
if(n%2==0) res+=sum[n-m-1-m]-even[n-m-1-m];
else res+=even[n-m-1-m];
cout<<res/2<<endl;
}
else{
ll res=0;
res+=sum[n]-sum[n-m];
if(n%2==0) res+=sum[n-m-m]-even[n-m-m];
else res+=even[n-m-m];
cout<<res/2<<endl;
}
}
}
return 0;
} |
p03158 | C++ |
#if 1
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <array>
#include <deque>
#include <algorithm>
#include <utility>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <numeric>
#include <assert.h>
#include <bitset>
#include <list>
auto& in = std::cin;
auto& out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI = 3.141592653589793238462643383279502884197169399375105820974944;
int32_t N;
int64_t A[100010];
int64_t X[100010];
int64_t sum[100010];
int64_t sum2[2][100010];
int main()
{
using std::endl;
in.sync_with_stdio(false);
out.sync_with_stdio(false);
in.tie(nullptr);
out.tie(nullptr);
int32_t Q;
in >> N >> Q;
for (size_t i = 0; i < N; i++)
{
in >> A[i];
}
for (size_t i = 0; i < Q; i++)
{
in >> X[i];
}
for (size_t i = 1; i <= N; i++)
{
sum[i] = sum[i-1] + A[i-1];
sum2[i & 1][i] = sum2[i & 1][i - 1] + A[i-1];
sum2[(i + 1) & 1][i] = sum2[(i + 1) & 1][i - 1];
}
for (size_t QUERY = 0; QUERY < Q; QUERY++)
{
const auto& x = X[QUERY];
auto x_index = std::lower_bound(A, A + N, x) - A;
if (x_index >= N-1) {
out << sum2[N & 1][N] << '\n';
continue;
}
using BS_INT = int64_t;
BS_INT ok_range = x_index-1, ng_range = N;
while (std::abs(ok_range - ng_range) > 1) {
BS_INT mid = (ok_range + ng_range) / 2;
bool is_ok = false;
auto diff = (A[mid] - x);
auto min_index = std::lower_bound(A, A + N, x - diff) - A;
auto eat_num = mid - min_index + 1;
is_ok = (mid < N - eat_num);
if (is_ok) {
ok_range = mid;
}
else {
ng_range = mid;
}
}
++ok_range;//0->1
auto eat_num = N - ok_range;
auto next_eat = ok_range - eat_num;
out << sum[N]-sum[ok_range] + sum2[next_eat&1][next_eat] << endl;
}
return 0;
}
#endif
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long llt;
const int MaxN = 100000 + 5, MaxQ = 100000 + 5;
int N, Q;
llt A[MaxN], X[MaxN];
llt pre[MaxN], sum[MaxN];
void init() {
scanf("%d %d", &N, &Q);
for (int i = 1; i <= N; ++i) scanf("%lld", &A[i]);
for (int i = 1; i <= Q; ++i) scanf("%lld", &X[i]);
}
inline bool check(int l, llt x) {
if (l == 1) return true;
int lpos = N - 2 * l + 2, rpos = N - l;
if (A[lpos] >= x) return true;
if (x - A[lpos] > A[rpos + 1] - x) return false;
else return true;
}
void solve() {
pre[1] = sum[1] = A[1];
for (int i = 2; i <= N; ++i)
pre[i] = pre[i - 2] + A[i],
sum[i] = sum[i - 1] + A[i];
for (int i = 1; i <= Q; ++i) {
llt x = X[i];
int lbound = 1, rbound = (N + 1) / 2, ans = 0;
while (lbound <= rbound) {
int mid = (lbound + rbound) >> 1;
if (check(mid, x) == true) {
ans = mid;
lbound = mid + 1;
} else rbound = mid - 1;
}
// printf("ans = %d\n", ans);
llt res = sum[N] - sum[N - ans];
res += pre[N - 2 * ans];
printf("%lld\n", res);
}
}
int main() {
init();
solve();
return 0;
} |
p03158 | C++ | #include <stdio.h>
#include <algorithm>
using namespace std;
using ll = long long;
int n, q, a[100001], x;
int priority(int x, int d) {
int *low = lower_bound(a + 1, a + n + 1, x - d);
int *upp = upper_bound(a + 1, a + n + 1, x + d);
return upp - low;
}
int *nearest(int x) {
int *low = lower_bound(a + 1, a + n + 1, x);
if (low == a + 1)
return low;
if (low == a + n + 1)
return low - 1;
return (x - low[-1]) < (low[0] - x) ? low - 1 : low;
}
ll cross_c[100001], csum[100001];
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++)
scanf("%d", a + i), cross_c[i] = csum[i] = a[i];
cross_c[0] = csum[0] = 0;
for (int i = 1; i <= n; i++) {
if (0 <= i - 2)
cross_c[i] += cross_c[i - 2];
if (0 <= i - 1)
csum[i] += csum[i - 1];
}
for (int task = 0; task < q; task++) {
scanf("%d", &x);
int low = nearest(x) - (a + 1);
if ((n - 1) <= low) {
printf("%lld\n", cross_c[n]);
continue;
}
int upp = n, cen = (low + upp) / 2;
while (2 <= upp - low) {
if ((n - cen + 1) <= priority(x, abs(a[cen] - x)))
upp = cen;
else
low = cen;
cen = (upp + low) / 2;
}
ll cost = csum[n] - csum[low];
int take = n - low;
cost += cross_c[max(low - take, 0)];
printf("%lld\n", cost);
}
} |
p03158 | C++ | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#define int long long
#define MOD7 1000000007
#define MOD9 1000000009
#define rep(i, n) for (int i = 0; i < (n); i++)
#define itrep(i, a) for (auto i = (a).begin(); i != (a).end(); i++)
#define REP(i, a, n) for (int i = (a); i <= (n); i++)
#define all(a) (a).begin(), (a).end()
#define mp(a, b) make_pair((a), (b))
using namespace std;
int dx[4] = { 1, 0, -1, 0 };
int dy[4] = { 0, -1, 0, 1 };
template<class T> void inputVector(vector<T>& v, int n) {
v.resize(n);
for (int i = 0; i < v.size(); i++) cin >> v[i];
}
signed main() {
int N, Q;
cin >> N >> Q;
vector<int> A(N), X(Q);
rep(i, N) scanf("%lld", &A[i]);
rep(i, Q) scanf("%lld", &X[i]);
if (N % 2) {
A.insert(A.begin(), 0);
N++;
}
int sum = 0;
REP(i, N / 2, N - 1) sum += A[i];
set<pair<int, int>>st;
st.insert(mp(0, sum));
int pt1 = 1;
int pt2 = N / 2;
while (pt2 < N - 1) {
int val = (A[pt1] + A[pt2]) / 2 + 1;
sum += A[pt1];
sum -= A[pt2];
st.insert(mp(val, sum));
pt1 += 2;
pt2++;
}
rep(i, Q) {
auto it = st.upper_bound(mp(X[i] + 1, -100));
it--;
cout << it->second << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int maxN = (int)1e5 + 100;
int a[maxN];
ll prefAll[maxN];
ll pref[maxN];
int n, q;
int calcQ(int x, int i) {
if (a[i] >= x) {
int ind = lower_bound(a + 1, a + n + 1, x) - a;
if (2 * x - a[1] <= a[i]) {
return i;
}
else {
int ind2 = lower_bound(a + 1, a + n + 1, 2 * x - a[i]) - a;
return (i - ind2 + 1);
}
}
else {
int ind = lower_bound(a + 1, a + n + 1, x) - a;
if (a[n] < 2 * x - a[i]) {
return n - i + 1;
}
else {
int ind2 = lower_bound(a + 1, a + n + 1, 2 * x - a[i]) - a;
ind2--;
return (ind2 - i + 1);
}
}
}
void solve(int x) {
if (x >= a[n]) {
cout << pref[n] << '\n';
return ;
}
int ind = lower_bound(a + 1, a + n + 1, x) - a;
if (calcQ(x, ind) + ind > n) {
ll ans = prefAll[n] - prefAll[ind - 1];
int left = 2 * ind - n - 2;
if (left > 0) ans += pref[left];
cout << ans << '\n';
return ;
}
else {
int l = ind;
int r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (calcQ(x, mid) + mid > n) {
r = mid;
}
else {
l = mid;
}
}
// l - ok
//cout << l << '\n';
ll ans = prefAll[n] - prefAll[l];
int left = 2 * l - n + 1 - 1;
if (left > 0) ans += pref[left];
cout << ans << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
//freopen("input.txt", "r", stdin);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
prefAll[i] = prefAll[i - 1] + a[i];
if (i >= 2) pref[i] = pref[i - 2] + a[i];
else pref[i] = a[i];
}
for (int i = 1; i <= q; i++) {
int x;
cin >> x;
solve(x);
}
return 0;
} |
p03158 | C++ | #include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "ctime"
using namespace std;
const long long int MOD = 1000000007;
//const int MOD = 998244353;
//long long int N, M, K, H, W, L, R;
long long int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
vector<long long int>v(N);
for (auto &i : v)cin >> i;
auto w = v;
auto a = v;
if (N % 2) {
for (int i = 2; i < N; i += 2)v[i] += v[i - 2];
}
else {
for (int i = 3; i < N; i += 2)v[i] += v[i - 2];
}
for (int i = N - 2; i >= 0; i--) {
w[i] += w[i + 1];
}
vector<pair<int,int>>query(K);
for (int i = 0; i < K; i++) {
cin >> query[i].first;
query[i].second = i;
}
vector<long long int>ans(K);
sort(query.begin(), query.end(), greater<pair<int, int>>());
int con = 0;
for (auto i : query) {
int cn = i.first;
while (N - con * 2 - 3 >= 0) {
R = N - con - 2;
L = R - con - 1;
if (abs(cn - a[L]) > abs(cn - a[R]))break;
else con++;
}
// cout << cn << "# " << con << endl;
ans[i.second] = w[N - 1 - con];
if (N % 2) {
if(N-3-con*2>=0)ans[i.second] += v[N - 3 - con * 2];
}
else {
if (N - 3 - con * 2 >= 0)ans[i.second] += v[N - 3 - con * 2];
}
}
for (auto i : ans)cout << i << endl;
return 0;
} |
p03158 | C++ | #include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <set>
#include <algorithm>
#include <unordered_map>
#include <queue>
#include <iomanip>
#include <map>
#include <utility>
#include <numeric>
#include <chrono>
#include <ctime>
#include <bitset>
#include <iterator>
#define rep(i,n) for(int i=0; i<(int)(n); i++)
#define P pair<long long, long long>
#define debug(x) cerr << #x << ": " << x << ", "
#define debugln(x) cerr << #x << ": " << x << '\n'
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q; cin >> n >> q;
vector<ll> a(n);
rep(i, n) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
ll sum = 0;
rep(i, n) {
if (i%2 == 0) sum += a[i];
}
vector<ll> s(n);
s[0] = sum;
//debug(sum);
for(int i=1; 2*i<n; i++) {
s[i] = s[i-1] - a[2*i] + a[i];
//debug(i); debugln(s[i]);
}
vector<int> pos(n);
pos[0] = INT_MAX;
for(int i=1; 2*i<n; i++) {
pos[i] = (a[i]+a[2*i])/2;
//debug(i); debugln(pos[i]);
}
vector<ll> x(q);
rep(i, q) {
int x; cin >> x;
int mi = 0; // always true
int ma = n/2+1; // always false
while(mi+1 < ma) {
int now = (mi+ma)/2;
if (x <= pos[now]) {
mi = now;
} else {
ma = now;
}
}
cout << s[mi] << '\n';
}
} |
p03158 | C++ |
#include <cstdio>
#include <algorithm>
#include <iostream>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
typedef long long ll;
int N, Q;
int as[100000+10];
ll cs[100000+10];
ll ecs[100000+10];
ll ocs[100000+10];
int go(int x) {
int left = 1;
int right = N;
while(left+1 < right) {
int md = (left + right) / 2;
int v2 = as[N-(md+1)/2-1]; // 青木くんの最大
int v3 = as[N-md]; // 青木くんの最小
int d = max(abs(v2-x), abs(v3-x));
if(abs(as[N-md-1]-x) <= d) {
left = md;
} else {
right = md;
}
}
return right;
}
int main(void) {
scanf("%d%d", &N, &Q);
REP(i, N) {
scanf("%d", &as[i]);
}
REP(i, N) {
cs[i+1] = cs[i] + as[i];
ecs[i+1] = ecs[i] + (i%2 == 0 ? as[i] : 0);
ocs[i+1] = ocs[i] + (i%2 == 1 ? as[i] : 0);
}
REP(i, Q) {
int x;
scanf("%d", &x);
int t = go(x);
// 後ろから(t+1)/2個は高橋くんゾーン、t/2個は青木くんゾーン
// 前側N-t個は交互
ll res = 0;
res += cs[N] - cs[N-(t+1)/2];
// aoki += cs[N-(t+1)/2] - cs[N-t];
if(N % 2 == 0) {
res += ocs[N-t];
} else {
res += ecs[N-t];
}
cout << res << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N=100050;
int a[N];
ll sum[N],pre[N];
int main()
{
int n,q,i;
scanf("%i %i",&n,&q);
for(i=1;i<=n;i++)
{
scanf("%i",&a[i]);
if(i==1) sum[i]=a[i];
else sum[i]=sum[i-2]+a[i];
pre[i]=pre[i-1]+a[i];
}
int x;
while(q--)
{
scanf("%i",&x);
int y=upper_bound(a+1,a+1+n,x)-a;
if(y>=n) printf("%lld\n",sum[n]);
else
{
int top=n,bot=1,mid,ans;
while(top>=bot)
{
mid=top+bot>>1;
int dist=a[n-mid]-x;
int f=lower_bound(a+1,a+1+n,x-dist)-a;
int sz=n-mid-f+1;
if(sz<=mid) ans=mid,top=mid-1;
else bot=mid+1;
}
ll ret=pre[n]-pre[n-ans]+sum[n-ans*2];
printf("%lld\n",ret);
}
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define int long long
#define INF 1000000000000000000
using namespace std;
#define ANS(f) if(f) cout << "YES" << endl; else cout << "NO" << endl;
typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int, int> Pii;
template<typename T>
void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readi(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
void debug(mat m){REP(i, m.size()){ REP(j, m[i].size()){ cout << m[i][j] << ","; } cout << endl; }}
signed main(){
int N, Q; cin >> N >> Q;
vec A(N), X(Q);
readv(A);
readv(X);
SORT(A);
vec sumA(N + 1);
sumA[0] = 0;
REP(i, N) sumA[i + 1] = sumA[i] + A[i];
vec sumA2(N + 2);
sumA2[0] = 0;
sumA2[1] = 0;
REP(i, N) sumA2[i + 2] = sumA2[i] + A[i];
REP(q, Q){
int t1 = 1, t2 = N;
while(t2 - t1 > 1){
int t = (t1 + t2) / 2;
//int d = A[N - 1] - A[N - t];
int d = llabs(X[q] - A[N - t]);
int n = N - t - Lower_bound(A, X[q] - d);
if(n >= t - 1) t1 = t;
else t2 = t;
}
int ans = sumA[N] - sumA[N - t1];
int r = N - 2 * t1;
ans += sumA2[r - 1 + 2];
//cout << t1 << "," << ans << endl;
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include "bits/stdc++.h"
#pragma warning(disable:4996)
using namespace std;
const int mod = 1000000007;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
static_assert(mod<INT_MAX / 2, "mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator*(const long long int a, const Mod b) { return Mod(a)*b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b)*a; }
Mod operator*(const Mod a, const int b) { return Mod(b)*a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod& a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod mod_pow(const Mod a, const long long int n) {
if (n == 0) return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2) res = res * a;
return res;
}
//mod が素数の場合のみ 違う場合はextend euclid を用いる。
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
return Mod(a) / b;
}
Mod operator/=(Mod &a, const Mod b) {
return a = a / b;
}
#define MAX_MOD_N 1024000
Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
void init(const int amax = MAX_MOD_N) {
fact[0] = Mod(1); factinv[0] = 1;
for (int i = 0; i < amax - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
struct Edge {
int src;
int dst;
int cost;
};
using Graph=vector<vector<Edge>>;
int main() {
/*int N,M,D,K;cin>>N>>M>>D>>K;
vector<vector<int>>mat(N*10,vector<int>(N*10));
Graph g(N);
for (int i = 0; i < M; ++i) {
int a,b;cin>>a>>b;a--;b--;
int c;cin>>c;
g[a].push_back(Edge{ a,b,c });
g[b].push_back(Edge{ b,a,c });
}
for (int i = 0; i < N; ++i) {
for (auto e : g[i]) {
int src=e.src;
int dst=e.dst;
int cost=e.cost;
mat[src*10][dst*10+cost-1]
}
}
vector<Mod>start(10*N);
for (int i = 0; i < N; ++i) {
start[i*10]=Mod(1);
}*/
//int N,H,W;cin>>N>>H>>W;
//int ans=(N-H+1)*(N-W+1);
//cout<<ans<<endl;
/*int N;cin>>N;
int A,B;cin>>A>>B;
vector<int>v(N);
for(int i=0;i<N;++i)cin>>v[i];
vector<int>nums(3);
for (int i = 0; i < N; ++i) {
if(v[i]<=A)nums[0]++;
else if(v[i]<=B)nums[1]++;
else nums[2]++;
}
cout<<*min_element(nums.begin(),nums.end())<<endl;*/
/*int H,W;cin>>H>>W;
vector<string>field(H);
for(int i=0;i<H;++i)cin>>field[i];
UnionFind uf(H*W);
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
int dx[] = { -1,0,1,0 };
int dy[] = { 0,1,0,-1 };
for (int way = 0; way < 4; ++way) {
int nextx=j+dx[way];
int nexty=i+dy[way];
if (nextx >= 0 && nextx < W&&nexty >= 0 && nexty < H) {
if (field[i][j] != field[nexty][nextx]) {
int aa=i*W+j;
int bb=nexty*W+nextx;
uf.unionSet(aa,bb);
}
}
}
}
}
map<int,pair<long long int,long long int>>mp;
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
bool flag=(i+j)%2;
if(flag)mp[uf.root(i*W+j)].first++;
else mp[uf.root(i*W+j)].second++;
}
}
long long int answer=0;
for (auto m : mp) {
answer+=m.second.first*m.second.second;
}
cout<<answer<<endl;*/
int N,Q;cin>>N>>Q;
vector<long long int>as(N);
for(int i=0;i<N;++i)cin>>as[i];
vector<long long int>sums(N+1);
vector<long long int>even_sums(N+2);
for (int i = 0; i < N; i += 2) {
even_sums[i+1]=even_sums[i]+as[i];
even_sums[i+2]=even_sums[i+1];
}
for(int i=0;i<N;++i)sums[i+1]=sums[i]+as[i];
for (int i = 0; i < Q; ++i) {
long long int x;cin>>x;
long long int amin=0;
long long int amax=1e10;
auto lt=as.begin();
auto rt=as.end();
bool flag=false;
while (true) {
long long int amid((amin+amax)/2);
bool kkflag=amid%2;
lt=lower_bound(as.begin(),as.end(),x-amid/2);
rt=lower_bound(as.begin(),as.end(),x+amid/2);
if(kkflag)rt=upper_bound(as.begin(),as.end(),x+amid/2);
int b_cnt=rt-lt;
int a_cnt=as.end()-rt;
if(amin+1==amax)break;
if (a_cnt == b_cnt) {
break;
}
else if (b_cnt + 1 == a_cnt) {
break;
}
else if (a_cnt < b_cnt) {
amax=amid;
}
else {
amin=amid;
}
}
int b_cnt=rt-lt;
int a_cnt=as.end()-rt;
long long int nanswer=0;
nanswer+=sums[rt-as.begin()]-sums[lt-as.begin()];
if(N%2==0)nanswer+=even_sums[lt-as.begin()];
else nanswer+=sums[lt-as.begin()]-even_sums[lt-as.begin()];
cout<<sums[N]-nanswer<<endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}
const int64 mod = 1e9+7;
int64 N, Q;
vector<int64> A, sum, bo; // bo -> 0 + 0 + ...
int main(void){
cin >> N >> Q;
A.resize(N); sum.resize(N+1, 0), bo.resize(N+1, 0);
REP(i, N){
cin >> A[i];
sum[i+1] = sum[i]+A[i];
bo[i+1] = bo[i]+(i%2 == (1-N%2) ? A[i] : 0);
}
auto ok = [&](int64 X, int64 x){ // xターン目に取る時，高橋くんが欲しいものをとれない
int64 a = A[N-1-x];
if(x == 0) return true;
if(a <= X && x != 0) return false;
int32 l = lower_bound(all(A), X-abs(X-a))-A.begin();
int32 r = N-x-1;
return ((r-l) >= x);
};
REP(i, Q){
int64 X;
cin >> X;
int32 l = 0, r = N/2+2, m;
while(r-l > 1){
m = (l+r)/2;
if(ok(X, m))
l = m;
else
r = m;
}
int64 res = sum[N]-sum[N-l-1]+(N-2*r < 0 ? 0 : bo[N-2*(l+1)]);
cout << res << endl;
}
}
|
p03158 | C++ | /*
.:*+=%@@@@@@=-.
.:=@#@@@#@@#######%==*.
.-=####@######%*-.....:%##%.
.*@###########%+:--........-%@-
.*@##############@+--.........-:%-
.+##################@==%%%%=+*:----+.
.-@####################%++%@@@@@=+**%@@*
.%###################@%%@@@###@%+:--%@@%.
-@###################@%%%%*::*%++:-----=@+.
-#####################@%=++++++*:-------.-=:
.+####################@%++*::-:::--::*:::***=:
.@#####################%=++*::::-:::++*=##@@#@-
..#####################@%%=++**:::::**+%@#@%%##-..
.%####################@@%=+++*+****::*=@######@.
.=######################@%%==+==++**+=@%@##@###+:...
-#######################@@@%%%===++=@@@%=++===*::--...
-########################@@@@@@@%==%%=++==@@:::::*:--.
..:#########################@@@@@@%%======++++::-..:-.--...
%#############################@###@%%@@%==%=%*----.--.::---.
#############################################*-:*:-:---*---- .
#############################################*--*--:---*---:-.
#############################################+--::--::-*::-::.
###########################################+:*-.---.---.:---*-..
###########################################**:-----------------.
##########################################@::**:--::::::--:::::-
###########################################:--:*:::::::::**::*+*
###########################################=:::***::::::**:::*+*
############################@@@@@@#########@+****::::********+++
############################@%%%%%@@@@@@@###%+***::::::::***+==+
############################@%%%%%%%%%%%@####=+:::-::::-::*+=%%+
#############################@%%%%%%%%%%@#####=::--------:*=%@%+
%###########################@%%%%==%%%%%%@##@#=:------..-:+%@@%=
----------------------------------------------
--------------------------------------------
----------------------------------------------
--------------------------------------------
----------------------------------------------
o###########oo
o##" ""##o
o#" "##
o#" "#o
#" ## ## "##
#" ##
# ################### #
# #
# #
# #
# #
# #
# #
#o #
"#o ##
"#o ##
"#o o#"
"#o ##
"#o o#"
"#ooo ooo#######oo
############### "######o
o###"" "###o # ###
o###o oooo ### oo####"
o###**# #**# ############"
""##""""""""""########### #
# oooooooo#"#** ## #
# # # # ** ## #
#o# #o# *****###ooo#
##
## o###o
## o##***##
o########## #***#**##o
o##" ""### #***##***#
o#######o ### oo#### ##**####*#
o##" ""#############"" ##****###
##" ## ##*##*###
## ### ##### ##
## ### # ## #
## ## #
## ##
## ###
## ###oo
### ""###
###
###
*/
///YEAH IM THE BEST I'VE EVER WAS
///SO HAPPY
#include <bits/stdc++.h>
#define popcnt(x) __builtin_popcount(x)
#define fr first
#define sc second
#define m_p make_pair
#define low_bo(a, x) lower_bound(a.begin(), a.end(), x) - a.begin()
#define up_bo(a, x) upper_bound(a.begin(), a.end(), x) - a.begin()
#define unique(a) a.resize(unique(a.begin(), a.end()) - a.begin())
#define popcnt(x) __builtin_popcount(x)
//#include <ext/pb_ds/assoc_container.hpp>
//using namespace __gnu_pbds;
//gp_hash_table<int, int> table;
//#pragma GCC optimize("O3")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
//#pragma GCC target("avx,tune=native")
//float __attribute__((aligned(32)))
/*char memory[(int)1e8];
char memorypos;
inline void * operator new(size_t n){
char * ret = memory + memorypos;
memorypos += n;
return (void *)ret;
}
inline void operator delete(void *){}
*/
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef unsigned int uint;
ll sqr(ll x){
return x * x;
}
int mysqrt(ll x){
int l = 0, r = 1e9 + 1;
while (r - l > 1){
int m = (l + r) / 2;
if (m * (ll)m <= x)
l = m;
else
r = m;
}
return l;
}
#ifdef ONPC
mt19937 rnd(231);
mt19937_64 rndll(231);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
mt19937_64 rndll(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
ll AR = 19, BR = 13, CR = 23, XR = 228, YR = 322, MODR = 1e9 + 993;
ll myrand(){
ll ZR = (XR * AR + YR * BR + CR) % MODR;
XR = YR;
YR = ZR;
return ZR;
}
int gcd(int a, int b){
return a ? gcd(b % a, a) : b;
}
int gcdex(int a, int b, int &x, int &y){
if (a == 0){
x = 0;
y = 1;
return b;
}
int x1, y1;
int ret = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return ret;
}
const int Mod = 1e9 + 7;
int Bpow(int x, ll y){
int ret = 1;
int w = x;
while (y){
if (y & 1)
ret = (ret * (ll)w) % Mod;
w = (w * (ll)w) % Mod;
y >>= 1;
}
return ret;
}
int Bdiv(int x){
int a, b;
gcdex(x, Mod, a, b);
if (a < 0)
a += Mod;
return a;
}
int Bdiv(int x, int y){
return (x * (ll)Bpow(y, Mod - 2)) % Mod;
}
inline int ad(int x, int y){
return x + y >= Mod ? x + y - Mod : x + y;
}
inline int dif(int x, int y){
return x - y < 0 ? x - y + Mod : x - y;
}
inline int mul(int x, int y){
return (x * (ll)y) % Mod;
}
int inv(int a){
int b = Mod, x = 0, y = 1;
while (a){
int t = b / a;
b -= a * t;
x -= t * y;
swap(a, b);
swap(x, y);
}
if (x < 0)
x += Mod;
return x;
}
void setmin(int &x, int y){
x = min(x, y);
}
void setmax(int &x, int y){
x = max(x, y);
}
void setmin(ll &x, ll y){
x = min(x, y);
}
void setmax(ll &x, ll y){
x = max(x, y);
}
const ll llinf = 4e18 + 100;
const ld eps = 1e-9;
const int maxn = 2e5 + 100, maxw = 1e6 + 100, inf = 2e9 + 100, sq = 600, X = 43, LG = 17;
int n, zap;
int a[maxn];
pair<int, int> que[maxn];
ll p[maxn];
ll pq[maxn];
int main()
{
#ifdef ONPC
//ifstream cin("a.in");
//ofstream cout("a.out");
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
#else
//ifstream cin("gymnasts.in");
//ofstream cout("gymnasts.out");
//freopen("nextpartition.in", "r", stdin);
//freopen("nextpartition.out", "w", stdout);
#endif // ONPC
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> zap;
for (int i = 0; i < n; i++) {
cin >> a[i];
p[i] = a[i] + (i < 2 ? 0 : p[i - 2]);
}
for (int i = 1; i <= n; i++)
pq[i] = pq[i - 1] + a[n - i];
for (int i = 0; i < zap; i++)
cin >> que[i].fr, que[i].sc = i;
sort(que, que + zap);
vector<ll> ans(zap);
int bef = 0;
for (int its = 0; its < zap; its++) {
int aid = que[its].sc;
int X = que[its].fr;
while (bef < n && a[bef] < X)
bef++;
int l = -1, r = n - bef;
while (r - l > 1) {
int m = (l + r) / 2;
int B = n - bef - m, A = m;
if (B < A) {
r = m;
continue;
}
int ds = a[bef + m] - X;
if (bef - (B - 1 - A) >= bef) {
r = m;
continue;
}
if (bef - (B - A - 1) >= 0) {
if (X - a[bef - (B - A - 1)] <= ds)
r = m;
else
l = m;
continue;
} else {
l = m;
}
}
int B = n - bef - r, A = r;
int to = bef - (B - A) - 1;
ans[aid] = pq[B] + (to < 0 ? 0 : p[to]);
}
for (auto i : ans)
cout << i << '\n';
}
|
p03158 | C++ | #define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/STACK:108777216")
#define _FORTIFY_SOURCE 0
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("fast-math")
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <utility>
#include <algorithm>
#include <ctime>
using namespace std;
int const MAX_N = 128 * 1024;
void my_gets(char * st) {
int len = 0;
char ch = getc(stdin);
while (ch != '\n' && ch != '\r' && ch != 0 && !feof(stdin)) {
st[len++] = ch;
ch = getc(stdin);
}
st[len] = 0;
}
int n, q;
int s[MAX_N], x[MAX_N];
long long suf_sum[MAX_N], ods[MAX_N];
inline long long get_odd_sum(int p) {
if (p < 0)
return 0LL;
return ods[p];
}
void get_window(int X, int moves_taken, int &a, int &b) {
if (X >= s[n - 1]) {
b = n - 1;
a = b - moves_taken + 1;
return;
}
if (X <= s[0]) {
a = 0;
b = a + moves_taken - 1;
return;
}
int down = 0, up = n;
while (up > down) {
int mid = (up + down) / 2;
if (s[mid] >= X) up = mid;
else down = mid + 1;
}
int p_before = down;
down = 0, up = min(moves_taken, p_before) + 1;
while (up > down) {
int mid = (up + down) / 2;
int go_left = mid;
int L = p_before - go_left;
//long long dist = X - s[L];
//long long max_val = X + dist;
int R = p_before + (moves_taken - mid) - 1;
int Ok = 1;
if (R + 1 < n && s[R + 1] - X < X - s[L])
Ok = 0;
/*if (R < n)
if (s[R] < max_val)
Ok = 0;
*/
if (!Ok) up = mid;
else down = mid + 1;
}
down--;
int go_left = down;
int L = p_before - go_left;
int R = p_before + (moves_taken - down) - 1;
a = L;
b = R;
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", &s[i]);
for (int i = 0; i < q; i++) scanf("%d", &x[i]);
long long odd_sum = 0;
for (int i = n - 1; i >= 0; i -= 2)
odd_sum += s[i];
suf_sum[n - 1] = s[n - 1];
for (int i = n - 2; i >= 0; i--)
suf_sum[i] = suf_sum[i + 1] + s[i];
ods[0] = s[0];
for (int i = 2; i < n; i += 2)
ods[i] = ods[i - 2] + s[i];
ods[1] = s[1];
for (int i = 3; i < n; i += 2)
ods[i] = ods[i - 2] + s[i];
for (int t = 0; t < q; t++) {
int X = x[t];
int down = 0, up = n / 2 + 10;
while (up > down) {
int mid = (up + down) / 2;
int a, b;
get_window(X, mid, a, b);
int c, d = n - 1;
c = d - mid + 1;
if (max(a, c) <= min(b, d))
up = mid;
else
down = mid + 1;
}
down--;
if (down < 0) { // X > an or nearest to X is an
printf("%lld\n", odd_sum);
continue;
}
else {
int a, b;
get_window(X, down, a, b);
int c, d = n - 1;
c = d - down + 1;
long long taken = suf_sum[c];
if (b + 1 == c) {
taken += get_odd_sum(a - 1);
}
else {
taken += s[b + 1];
taken += get_odd_sum(a - 2);
}
printf("%lld\n", taken);
}
}
return 0;
}
|
p03158 | C++ | /*
* RD
*/
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#ifndef rd
#define endl '\n'
#endif
#define deb cout<<"Line: "<<__LINE__<<" plz "
#define pb push_back
#define fi first
#define se second
#define int long long
typedef long long ll;
#define pii pair<int,int>
#define sz(x) ((int)x.size())
#define fr(a,b,c) for(int a=b; a<=c; a++)
#define all(con) con.begin(),con.end()
const ll inf=1e18;
const int mod=1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll powm(ll a, ll b, ll m);
int n,q;
int a[100005];
int pref[100005],prefo[100005];
void solve()
{
cin>>n>>q;
for(int i=1; i<=n; i++)
{
cin>>a[i];
pref[i]=pref[i-1]+a[i];
if((i&1))
prefo[i]=prefo[i-1]+a[i];
else
prefo[i]=prefo[i-1];
}
for(int i=0; i<q; i++)
{
int te;
cin>>te;
if(abs(a[n/2+1]-te)>=abs(a[1]-te))
{
cout<<pref[n]-pref[n/2]<<endl;
continue;
}
int lo=1,hi=n/2,mid=(1+lo+hi)/2;
while(lo<hi)
{
if(abs(te-a[n-mid+1])>=abs(te-a[n-2*mid+2]))
lo=mid;
else
hi=mid-1;
mid=(lo+hi+1)/2;
}
ll sum=pref[n]-pref[n-mid];
if(n&1)
sum+=prefo[n-2*mid];
else
sum+=pref[n-2*mid]-prefo[n-2*mid];
cout<<sum<<endl;
}
}
signed main()
{
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
srand(chrono::steady_clock::now().time_since_epoch().count());
auto clk=clock();
int t=1;
// cin>>t;
while(t--)
solve();
#ifdef rd
cout<<endl<<endl<<(double)(clock()-clk)/CLOCKS_PER_SEC<<endl;
#endif
return 0;
}
ll powm(ll a,ll b, ll m) {
ll te=1;
while(b) {
if(b&1) te=(te*a)%m;
a=(a*a)%m;
b>>=1;
}
return te;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int Maxn = 100005;
int n, q;
int a[Maxn];
ll sum[Maxn][2];
ll acc[Maxn];
int main()
{
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum[i][0] = acc[i] = a[i];
if (i > 0) {
sum[i][0] += sum[i - 1][1];
sum[i][1] += sum[i - 1][0];
acc[i] += acc[i - 1];
}
}
while (q--) {
int x; scanf("%d", &x);
ll res = 0;
if (a[n - 1] <= x) { printf("%lld\n", sum[n - 1][0]); continue; }
int lef = 0, rig = 1000000007;
while (lef <= rig) {
int mid = lef + rig >> 1;
int beg = lower_bound(a, a + n, x - mid) - a;
int en = upper_bound(a, a + n, x + mid) - a;
int len = en - beg;
if (beg + 2 * len <= n) lef = mid + 1;
else rig = mid - 1;
}
lef--;
int beg = lower_bound(a, a + n, x - lef) - a;
int en = upper_bound(a, a + n, x + lef) - a;
int len = en - beg;
if (beg + 2 * len == n) {
res += acc[n - 1];
if (en > 0) res -= acc[en - 1];
if (beg > 0) res += sum[beg - 1][0];
} else if (beg + 2 * len == n - 1) {
res += acc[n - 1];
if (en > 0) res -= acc[en - 1];
if (beg > 0) res += sum[beg - 1][1];
} else {
res += acc[n - 1];
if (en > 0) res -= acc[en - 1];
if (beg > 1) res += sum[beg - 2][1];
}
printf("%lld\n", res);
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <algorithm>
#include <stdlib.h>
#define llint long long
using namespace std;
llint n, Q;
llint a[100005], sum[100005];
llint osum[100005], esum[100005];
bool check(llint mid, llint x)
{
if(x >= a[n-mid+1]) return false;
int d = abs(a[n-mid+1] - x);
int num = lower_bound(a+1, a+n+1, x+d) - lower_bound(a+1, a+n+1, x-d);
return num >= mid-1;
}
int main(void)
{
cin >> n >> Q;
for(int i = 1; i <= n; i++) cin >> a[i];
for(int i = 1; i <= n; i++) sum[i] = sum[i-1] + a[i];
for(int i = 1; i <= n; i++){
osum[i] = osum[i-1];
esum[i] = esum[i-1];
if(i%2) osum[i] += a[i];
else esum[i] += a[i];
}
for(int q = 0; q < Q; q++){
llint x;
cin >> x;
llint ub = n+1, lb = 0, mid;
while(ub-lb>1){
mid=(ub+lb)/2;
if(check(mid, x)) lb = mid;
else ub = mid;
}
llint ans = sum[n] - sum[n-lb];
if(n%2) ans += osum[n-2*lb];
else ans += esum[n-2*lb];
cout << ans << endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N,Q;
ll A[101010];
ll S[101010];
ll T[101010];
ll X;
int ok(int v) {
if(v>N) return 0;
int aa=(v+1)/2;
int re=N-aa;
int x=lower_bound(A,A+N,X-(A[re]-X))-A;
return (x+v<=N);
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N>>Q;
FOR(i,N) {
cin>>A[i];
S[i+1]=S[i]+A[i];
T[i+1]=(i>=1?T[i-1]:0)+A[i];
}
while(Q--) {
cin>>X;
int turn=0;
for(i=20;i>=0;i--) {
if(ok(turn+(1<<i))) turn+=1<<i;
}
int a=(turn+1)/2;
if(turn%2) turn++;
ll ret=S[N]-S[N-turn/2];
if(turn<N) ret+=T[N-turn];
cout<<ret<<endl;
}
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
|
p03158 | C++ | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define N 100010
int read()
{
int x=0,f=1;char c=getchar();
while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
return x*f;
}
int n,m,a[N];
ll s[N],f[N];
int findmax(int x,int k)
{
int l=1,r=n;
while (l+1<r)
{
int mid=l+r>>1;
if (mid+k-1>n) r=mid;
else if (x-a[mid]>a[mid+k-1]-x) l=mid;
else r=mid;
}
int ans=l;
for (int i=l+1;i<=r;i++)
if (r+k-1<=n&&max(x-a[i],a[i+k-1]-x)<max(x-a[ans],a[ans+k-1]-x)) ans=i;
return a[ans+k-1];
}//和x最接近的数中取k个后最大的
bool check(int k,int x)
{
if (k*2-1>n) return 0;
//cout<<k<<' '<<x<<endl;
//cout<<findmax(x,1)<<' '<<a[n-k+1]<<endl;
return findmax(x,k-1)<a[n-k+1];
}
int main()
{
n=read(),m=read();
for (int i=1;i<=n;i++) a[i]=read();
sort(a+1,a+n+1);
s[1]=a[1];
for (int i=2;i<=n;i++) s[i]=s[i-2]+a[i];
for (int i=n;i>=1;i--) f[i]=f[i+1]+a[i];
for (int i=1;i<=m;i++)
{
int x=read();
int l=1,r=n,t=0;
while (l<=r)
{
int mid=l+r>>1;
if (check(mid,x)) t=mid,l=mid+1;
else r=mid-1;
}
//cout<<t<<endl;
ll ans=f[n-t+1];int y=n-t*2;
if (y>0) ans+=s[y];
printf("%lld\n",ans);
}
} |
p03158 | C++ | #include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main()
{
int n, q;
cin>>n>>q;
ll a[100001];
ll s[100001], s0[100001], s1[100001]; s[0]=0, s0[0]=0, s1[0]=0;
for(int i=1; i<=n; i++){
cin>>a[i];
s[i]=s[i-1]+a[i];
s0[i]=s0[i-1], s1[i]=s1[i-1];
if(i&1) s1[i]+=a[i];
else s0[i]+=a[i];
}
ll x[100001];
int ind[100001];
ll ans[100001];
for(int i=0; i<q; i++){
cin>>x[i];
ind[i]=i;
}
sort(ind, ind+q, [&](int i, int j){ return x[i]>x[j];});
int t=n;
for(int i=0; i<q; i++){
ll x0=x[ind[i]];
if(x0>=a[n]){
if(n&1) ans[ind[i]]=s1[n];
else ans[ind[i]]=s0[n];
continue;
}
while(t>=1){
ll d1=a[t]-x0;//d2=a[t+1]-x0;
int i1=lower_bound(a+1, a+n+1, x0-d1)-a;
//int i2=lower_bound(a+1, a+n+1, x0-d2)-a;
if(t-i1+1>n-t) t--;
else break;
}
if(n&1) ans[ind[i]]=s[n]-s[t]+s1[2*t-n];
else ans[ind[i]]=s[n]-s[t]+s0[2*t-n];
}
for(int i=0; i<q; i++) cout<<ans[i]<<endl;
return 0;
} |
p03158 | C++ | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ld,ld> pdd;
#define X first
#define Y second
//#include <boost/unordered_map.hpp>
//using namespace boost;
/*
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> rbtree;
rbtree T;
*/
namespace io{
const int L = (1 << 20) + 1;
char buf[L], *S , *T, c;
char getchar() {
if(__builtin_expect(S == T, 0)) {
T = (S = buf) + fread(buf, 1, L, stdin);
return (S == T ? EOF : *S++);
}
return *S++;
}
int inp() {
int x = 0, f = 1; char ch;
for(ch = getchar(); !isdigit(ch); ch = getchar())
if(ch == '-') f = -1;
for(; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
return x * f;
}
unsigned inpu()
{
unsigned x = 0; char ch;
for(ch = getchar(); !isdigit(ch); ch = getchar());
for(; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
return x;
}
ll inp_ll() {
ll x = 0; int f = 1; char ch;
for(ch = getchar(); !isdigit(ch); ch = getchar())
if(ch == '-') f = -1;
for(; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
return x * f;
}
char B[25], *outs=B+20, *outr=B+20;
template<class T>
inline void print(register T a,register char x=0){
if(x) *--outs = x, x = 0;
if(!a)*--outs = '0';
else
while(a)
*--outs = (a % 10) + 48, a /= 10;
if(x)
*--outs = x;
fwrite(outs, outr - outs , 1, stdout);
outs = outr;
}
};
using io :: print;
using io :: inp;
using io :: inpu;
using io :: inp_ll;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
ll power(ll a, ll b, ll p)
{
if (!b) return 1;
ll t = power(a, b/2, p);
t = t*t%p;
if (b&1) t = t*a%p;
return t;
}
const int MAXN = 100010;
const int MAXP = 10000000;
const u64 MOD = 1000000007;
const f80 MI = f80(1)/MOD;
const int INF = 1000000010;
int n, q;
int a[MAXN];
ll s[MAXN], t[MAXN];
bool check(int m, int x)
{
if (x >= a[n-m+1]) return false;
int d = abs(x-a[n-m+1]);
int L = lower_bound(a+1, a+n+1, x-d)-a;
int R = upper_bound(a+1, a+n+1, x+d)-a-1;
if (R-L >= m-1) return true; else return false;
}
void solve(int x)
{
int L = 2, R = n, pos = 1;
while (L <= R)
{
int m = (L+R)/2;
if (check(m, x))
{
pos = m;
L = m+1;
}
else
R = m-1;
}
ll ans = s[n]-s[n-pos];
ans += t[n-pos-pos];
printf("%lld\n", ans);
}
int main()
{
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++ i)
scanf("%d", &a[i]);
for (int i = 1; i <= n; ++ i)
s[i] = s[i-1]+a[i];
t[1] = a[1];
t[2] = a[2];
for (int i = 3; i <= n; ++ i)
t[i] = t[i-2]+a[i];
while (q --)
{
int x;
scanf("%d", &x);
solve(x);
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <utility>
#define maxn 100005
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n,Q,a[maxn];
struct Query{
int val,id;
bool operator < (const Query &b)const
{
return val > b.val;
}
}q[maxn];
ll ans[maxn],sum[maxn],sumodd[maxn];
bool check(int pos,int x){
if(a[pos] >= x) return false;
int pos2 = pos + ((n - pos) >> 1);
return a[pos2] - x < x - a[pos];
}
int main(){
scanf("%d%d",&n,&Q);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
sum[i] = sum[i - 1] + a[i];
sumodd[i] = sumodd[i - 1] + ((n - i + 1) & 1) * a[i];
}
int x = n;
for(int i=1;i<=Q;i++){
scanf("%d",&q[i].val);
q[i].id = i;
}
sort(q + 1,q + Q + 1);
for(int i=1;i<=Q;i++){
if(a[n] <= x) ans[q[i].id] = sumodd[n];
else{
while(x > 0 && !check(x,q[i].val)) x -= 2;
if(x == 0) ans[q[i].id] = sum[n] - sum[n >> 1];
else ans[q[i].id] = sum[n] - sum[x + ((n - x) >> 1)] + sumodd[x];
}
}
for(int i=1;i<=Q;i++){
printf("%lld\n",ans[i]);
}
return 0;
}
|
p03158 | C++ | /* <ik:include(base.hpp)> */
/* subset of bits/stdc++.h */
#include<algorithm>
#include<iomanip>
#include<iostream>
#include<map>
#include<numeric>
#include<queue>
#include<vector>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#define int LL
#define times(n, i) uptil(0, n, i)
#define rtimes(n, i) downto((n) - 1, 0, i)
#define upto(f, t, i) for(auto i##0_to = (t), i = decltype(t)(f); i <= i##0_to; i++)
#define uptil(f, t, i) for(auto i##0_to = (t), i = decltype(t)(f); i < i##0_to; i++)
#define downto(f, t, i) for(auto i##0_to = decltype(f)(t), i = (f); i >= i##0_to; i--)
#define downtil(f, t, i) for(auto i##0_to = decltype(f)(t), i = (f); i > i##0_to; i--)
#define iter(v) begin(v), end(v)
#define citer(v) cbegin(v), cend(v)
#if defined(EBUG) && !defined(ONLINE_JUDGE)
#define debug true
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 2
#define _LIBCPP_DEBUG2 2
#define ln << endl
#define dd(x) cerr << #x << " = " << (x) << ", "
#define ddd(x) cerr << #x << " = " << (x) ln
#else
#define debug false
#define ln << '\n'
#define dd(x) cerr
#define ddd(x) cerr
#endif
#define tb << '\t'
#define sp << ' '
#define db dd
#define dbg ddd
#if __cplusplus >= 201703L
#if debug
#define PARABLE execution::par_unseq,
#else
#define PARABLE execution::seq,
#endif
#else
#define PARABLE /* none */
#endif
#define CS const
#define IL inline
#define RT return
#define TL template
#define lambda [&]
#define foldl accumulate
#define scanl accumulate
typedef struct unit{}unit;
TL<class T> void amax(T&v,const T&a){v=max(v,a);}
TL<class T> void amin(T&v,const T&a){v=min(v,a);}
namespace kpl {
template<class V, class W>
static inline void append(V& v, const W& w) { copy(PARABLE citer(w), back_inserter(v)); }
template<class V>
static inline auto flatten(const V& xss, unsigned reserve_size = 0) {
vector<decltype(*begin(*begin(xss)))> ret;
ret.reserve(reserve_size);
for(const auto& xs : xss) append(ret, xs);
ret.shrink_to_fit();
return move(ret);
}
template<class I>
static inline bool is_in(I x, I l, I r) { /* Of course half-open interval [l,r) is used */
return l <= x && x < r;
}
}
/* <ik:include(util.hpp)> */
#ifndef __cpp_lib_exchange_function
#define __cpp_lib_exchange_function 201304L
TL<class T, class U=T> T exchange(T& t, U&& u) {
T ret = move(t); t = forward<U>(u); return ret;
}
#endif
/* </ik:include(util.hpp)> */
/* <ik:include(mod.hpp)> */
#ifndef MOD
#ifdef MOD9
#define MOD 1000000009
#elif defined MOD998244353
#define MOD 998244353
#else
#define MOD 1000000007
#endif
#endif
/* <ik:include(power.hpp)> */
TL<class T> T power(T x,ULL n){T rt(1);while(n){if(n%2)rt*=x;x*=x;n/=2;}RT rt;}
/* </ik:include(power.hpp)> */
IL int modulo(int a,int m){a%=m;RT a>=0?a:a+m;}
TL<ULL mod=MOD>class MInt{
/*
int with modulo.
`mod` must be a prime for `log`.
`mod` must be coprime to `val` for `inv` and to `m.val` for `operator/` and `operator/=`.
*/
/*! https://ei1333.github.io/luzhiled/snippets/other/mod-int.html */
public:
int val;
MInt():val(0){}
explicit MInt(int v):val(modulo(v,mod)){}
MInt&operator+=(CS MInt&m){val+=m.val;if(val>=mod)val-=mod;RT*this;}
MInt&operator-=(CS MInt&m){val-=m.val;if(val<0)val+=mod;RT*this;}
MInt&operator*=(CS MInt&m){val=val*m.val%mod;RT*this;}
MInt&operator/=(CS MInt&m){val=val*m.inv().val%mod;RT*this;}
MInt operator+(CS MInt&m)CS{RT MInt(*this)+=m;}
MInt operator-(CS MInt&m)CS{RT MInt(*this)-=m;}
MInt operator*(CS MInt&m)CS{RT MInt(*this)*=m;}
MInt operator/(CS MInt&m)CS{RT MInt(*this)/=m;}
MInt operator-()CS{MInt m;m.val=val?mod-val:0;RT m;}
bool operator==(CS MInt&m)CS{RT val==m.val;}
bool operator!=(CS MInt&m)CS{RT val!=m.val;}
//MInt pow(int n)CS{MInt x(*this),rt(1);while(n){if(n%2)rt*=x;x*=x;n/=2;}RT rt;}
MInt pow(int n)CS{RT power(*this,n);}
MInt inv()CS{int a=val,b=mod,x=1,y=0,t;while(b){t=a/b;swap(b,a-=t*b);swap(y,x-=t*y);}RT(MInt)x;}
friend ostream&operator<<(ostream&o,CS MInt<mod>&m){RT o<<m.val;}
friend istream&operator>>(istream&i,MInt<mod>&m){int v;i>>v;m=MInt<mod>(v);RT i;}
};
using mint=MInt<>;
#pragma rab:gsub \b(\d+)m\b mint(\1)
/* </ik:include(mod.hpp)> */
/* <ik:include(vector_usings.hpp)> */
TL<class T> using vec = vector<T>;
TL<class T> using vvec = vec<vec<T>>;
#define VUSE(v,t)using P##v=pair<t,t>;using V##v=vec<t>;using W##v=vvec<t>
VUSE(I,int);VUSE(M,mint);VUSE(PI,PI);VUSE(PM,PM);
/* </ik:include(vector_usings.hpp)> */
/* <ik:include(debug.hpp)> */
TL<class T>
IL istream&operator>>(istream&s,vec<T>&v){for(auto&&p:v)s>>p;RT s;}
TL<class T,class S>
IL ostream&operator<<(ostream&s,CS pair<T,S>&p){RT s<<"("<<p.first<<","<<p.second<<")";}
TL<class T>
IL ostream&operator<<(ostream&,CS vec<T>&);
TL<class T,class S>
IL ostream&operator<<(ostream&,CS map<T,S>&);
#define DEFINE_ITER_OUTPUT(s,x,sep){int i=0;for(CS auto&x##0_elem:x){if(i++)s<<sep;s<<x##0_elem;}RT s;}
TL<class T>
IL ostream&operator<<(ostream&s,CS vec<T>&v)DEFINE_ITER_OUTPUT(s,v,' ')
TL<class T,class S>
IL ostream&operator<<(ostream&s,CS map<T,S>&m)DEFINE_ITER_OUTPUT(s,m,' ')
TL<class T>
IL ostream&operator<<(ostream&s,CS vec<vec<T>>&w)DEFINE_ITER_OUTPUT(s,w,'\n')
TL<class T,class S>
IL ostream&operator<<(ostream&s,CS vec<map<T,S>>&v)DEFINE_ITER_OUTPUT(s,v,'\n')
/* </ik:include(debug.hpp)> */
void solve();
signed main() {
if(debug) {
cerr << "mod = " << MOD ln;
} else {
cin.tie(0);
ios::sync_with_stdio(0);
}
cout << fixed << setprecision(20);
cerr << fixed << setprecision(20);
solve();
return 0;
}
/* </ik:include(base.hpp)> */
void solve() {
// NQN(A)N(X)
/* <foxy.memo-area> */
int N;int Q;cin>>N;cin>>Q;VI A(N);times(N,Ri_0){cin>>A[Ri_0];}VI X(Q);times(
Q,Ri_0){cin>>X[Ri_0];}
/* </foxy.memo-area> */
VI dp(N+1), dr(N+1);
times(N, i) dp[i+1] = dp[i] + (N % 2 != i % 2) * A[i];
rtimes(N, i) dr[i] = dr[i+1] + A[i];
if(debug) cerr << dp ln << dr ln;
times(Q, i) {
int ok = 1, ng = (N+1)/2 + 1;
while(abs(ng - ok) > 1) {
int m = (ok + ng) / 2;
if(N - 2 * m + 1 >= 0 && A[N - m] - X[i] >= X[i] - A[N - 2 * m + 1]) {
ok = m;
} else {
ng = m;
}
// cerr << m sp << ok sp << ng tb;
}
if(debug) cerr << ok ln;
cout << dr[N - ok] + (N - ok * 2 >= 0 ? dp[N - ok * 2] : 0) ln;
}
}
|
p03158 | C++ | #define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <utility>
#include <algorithm>
#include <functional>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <limits>
#include <numeric>
#include <valarray>
#include <fstream>
using namespace std;
typedef unsigned int uint;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PP;
#define REP(i, a, n) for(LL i = (a), i##_max = (n); i < i##_max; ++i)
#define REM(i, a, n) for(LL i = (LL)(n) - 1, i##min = (a); i >= i##min; --i)
#define ALL(arr) (arr).begin(), (arr).end()
#define FLOAT fixed << setprecision(16)
#define SPEEDUP {cin.tie(NULL); ios::sync_with_stdio(false);}
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const string INFSTR = "\x7f";
const double EPS = 1.0e-9;
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U>
istream& operator>>(istream& ist, pair<T, U>& right) { return ist >> right.first >> right.second; }
template <class T, class U>
ostream& operator<<(ostream& ost, const pair<T, U>& right) { return ost << right.first << ' ' << right.second; }
template <class T, class TCompatible, size_t N>
void Fill(T(&dest)[N], const TCompatible& val) { fill(dest, dest + N, val); }
template <class T, class TCompatible, size_t M, size_t N>
void Fill(T(&dest)[M][N], const TCompatible& val) { for (int i = 0; i < M; ++i) Fill(dest[i], val); }
template<class T>
T Compare(T left, T right) { return left > right ? 1 : (left < right ? -1 : 0); }
istream& Ignore(istream& ist) { string s; ist >> s; return ist; }
bool Inside(int i, int j, int h, int w) { return i >= 0 && i < h && j >= 0 && j < w; }
template <class T>
T Next() { T buf; cin >> buf; return buf; }
#ifdef ONLY_MY_ENVIR
#include "IntMod.h"
#include "UnionFind.h"
#include "Graph.h"
#include "Range.h"
#include "Global.h"
#include "FlowSolver.h"
#include "Tree.h"
#include "SuffixArray.h"
#include "Geometry.h"
#include "Matrix.h"
#include "SegmentTree.h"
#include "SegmentTree2D.h"
#include "BIT.h"
#include "Rational.h"
#include "Position.h"
#include "Factorization.h"
#include "Math.h"
#endif
#ifdef __GNUC__
typedef __int128 LLL;
istream& operator>> (istream& ist, __int128& val) { LL tmp; ist >> tmp; val = tmp; return ist; }
ostream& operator<< (ostream& ost, __int128 val) { LL tmp = val; ost << tmp; return ost; }
#endif
#if 1234567891
#include <array>
#include <random>
#include <unordered_set>
#include <unordered_map>
template<typename T>
using PriorityQ = priority_queue<T, vector<T>, greater<T> >;
// template <class T>
// auto Is(const T& value) { return [value](const auto& comparand) -> bool { return comparand == value; }; }
#endif
int N, Q;
LL A[100000];
LL P[100001];
LL R[100002];
vector<int> th;
void pre() {
REP(i, 0, N) {
P[i + 1] = P[i] + A[i];
R[i + 2] = R[i] + A[i];
}
REP(i, 1, N) {
int r = N - 1 - i;
int l = N - 1 - 2 * i;
if (l < 0) continue;
int mid = (A[l] + A[r]) / 2;
th.push_back(mid + 1);
}
}
LL sub(int x) {
auto it = lower_bound(th.begin(), th.end(), x, greater<int>());
int idx = it - th.begin() + 1;
LL na = P[N] - P[N - idx];
LL ni = R[N - 2 * idx + 1];
return na + ni;
}
int main() {
cin >> N >> Q;
REP(i, 0, N) {
cin >> A[i];
}
pre();
REP(j, 0, Q) {
int a;
cin >> a;
cout << sub(a) << endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> void Max(T &m, const T q) { if (m < q) m = q; }
template<typename T> void Min(T &m, const T q) { if (m > q) m = q; }
template<typename T1, typename T2> pair<T1, T2> operator+(pair<T1, T2> &l, pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(pair<T1, T2> &l, pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
int N, Q;
vector<lint> A, As, Asalt[2];
int main()
{
cin >> N >> Q;
A.resize(N);
cin >> A;
As.resize(N + 1);
REP(i, N) As[i + 1] = As[i] + A[i];
REP(d, 2) Asalt[d].resize(1);
REP(i, N)
{
Asalt[i % 2].push_back(Asalt[i % 2].back() + A[i]);
}
REP(_, Q)
{
lint X;
cin >> X;
int pos = distance(A.begin(), lower_bound(A.begin(), A.end(), X));
if (pos == 0)
{
printf("%lld\n", As[N] - As[N / 2]);
}
else if (pos == N)
{
if (N % 2) printf("%lld\n", Asalt[0][N / 2 + 1]);
else printf("%lld\n", Asalt[1][N / 2]);
}
else
{
int l = 0, r = (N + 1) / 2 + 1;
while (r - l > 1)
{
int c = (l + r) / 2;
lint diff = A[N - c] - X;
if (diff <= 0)
{
r = c;
continue;
}
int n = distance(lower_bound(A.begin(), A.end(), X - diff), lower_bound(A.begin(), A.end(), X + diff));
if (n >= c - 1) l = c;
else r = c;
}
lint ans = As[N] - As[N - l];
if (N % 2)
{
if (N - l * 2 >= 0) ans += Asalt[0][(N - l * 2) / 2 + 1];
}
else ans += Asalt[1][(N - l * 2) / 2];
printf("%lld\n", ans);
}
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
#include <ostream>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n-1); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(20) << fixed;
int n, q;
cin >> n >> q;
V<ll> a(n), as(n + 1);
V<ll> two(n);
for (int i = 0; i < n; ++i) {
cin >> a[i]; a[i] *= 3;
as[i + 1] = as[i] + a[i];
two[i] = (i >= 2 ? two[i - 2] : 0) + a[i];
}
for (int ph = 0; ph < q; ph++) {
ll x;
cin >> x;
x *= 3; x--;
ll lw = 0, up = TEN(10);
while (up - lw > 1) {
ll md = (lw + up) / 2;
int cnt0 = upper_bound(a.begin(), a.end(), x + md) - lower_bound(a.begin(), a.end(), x - md);
int cnt1 = a.end() - upper_bound(a.begin(), a.end(), x + md);
if (cnt0 <= cnt1) {
lw = md;
} else {
up = md;
}
}
ll md = lw;
int cnt0 = upper_bound(a.begin(), a.end(), x + md) - lower_bound(a.begin(), a.end(), x - md);
int cnt1 = a.end() - upper_bound(a.begin(), a.end(), x + md);
ll ans = as.back() - as[n - cnt1];
if (cnt0 < cnt1) {
if (n - cnt1 - cnt0 - 2 >= 0) ans += two[n - cnt1 - cnt0 - 2];
} else {
if (n - cnt1 - cnt0 - 1 >= 0) ans += two[n - cnt1 - cnt0 - 1];
}
cout << ans / 3 << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define DEBUG(x) cerr<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cerr<<#v<<":";for(int i=0;i<v.size();i++) cerr<<" "<<v[i]; cerr<<endl
typedef long long ll;
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
template<class S, class T> pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first + t.first, s.second + t.second); }
template<class S, class T> pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first - t.first, s.second - t.second); }
template<class S, class T> ostream& operator<<(ostream& os, pair<S, T> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
#define X first
#define Y second
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(n);i>0;i--)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(),c.end()
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a = b; return 1; } return 0; }
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = 1e18;
const ll MOD = 1000000007;
//const ll MOD = 998244353;
const double pi = 3.14159265358979323846;
#define Sp(p) cout<<setprecision(15)<< fixed<<p<<endl;
int dx[4] = { 1,0, -1,0 }, dy[4] = { 0,1,0,-1 };
int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
#define fio() cin.tie(0); ios::sync_with_stdio(false);
//#define mp make_pair
int main() {
fio();
int n, q;
cin >> n >> q;
vl a(n);
rep (i, n) {
cin >> a[i];
}
vl sumr(n + 1);
rrep (i, n) {
sumr[i] = sumr[i + 1] + a[i];
}
vl sum0(n), sum1(n);
sum0[0] = a[0];
for (int i = 2; i < n; i += 2) {
sum0[i] = sum0[i - 2] + a[i];
}
sum1[1] = a[1];
for (int i = 3; i < n; i += 2) {
sum1[i] = sum1[i - 2] + a[i];
}
while (q--) {
ll x;
cin >> x;
auto itr = lower_bound(all(a), x);
int ng = n, ok = 1;
while (ok + 1 < ng) {
int mid = (ng + ok) / 2;
int ue = a[n - mid];
int teki;
if (ue <= x) {
teki = 0;
}
else {
int diff = ue - x;
int sita = lower_bound(all(a), x - diff) - a.begin();
teki = n - mid - sita;
}
if (teki + 2 <= mid) {
ng = mid;
}
else {
ok = mid;
}
}
int mid = ok;
ll ue = a[n - mid];
int teki;
if (ue <= x) {
teki = 0;
}
else {
ll diff = ue - x;
int sita = lower_bound(all(a), x - diff) - a.begin();
teki = n - mid - sita;
}
ll ans = sumr[n - ok];
if (n - 2*ok > 0) {
if ((n - 2*ok) % 2 == 0) {
ans += sum1[n - 2*ok - 1];
}
else {
ans += sum0[n - 2*ok - 1];
}
}
cout << ans << endl;
}
}
|
p03158 | C++ | #define DEB
#include<bits/stdc++.h>
#define REP(i,m) for(int i=0;i<(m);++i)
#define REPN(i,m,in) for(int i=(in);i<(m);++i)
#define ALL(t) (t).begin(),(t).end()
#define CLR(a) memset((a),0,sizeof(a))
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
using namespace std;
#ifdef DEB
#define dump(x) cerr << #x << " = " << (x) << endl
#define prl cerr<<"called:"<< __LINE__<<endl
#define dumpR(x) cerr<<"\x1b[31m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpY(x) cerr<<"\x1b[33m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpG(x) cerr<<"\x1b[32m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
template<class T> void debug(T a,T b){ for(;a!=b;++a) cerr<<*a<<' ';cerr<<endl;}
#else
#define dump(x) ;
#define dumpR(x) ;
#define dumpY(x) ;
#define dumpG(x) ;
#define prl ;
template<class T> void debug(T a,T b){ ;}
#endif
template<class T> void chmin(T& a,const T& b) { if(a>b) a=b; }
template<class T> void chmax(T& a,const T& b) { if(a<b) a=b; }
typedef long long int lint;
typedef pair<int,int> pi;
namespace std{
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.fr<<','<<a.sc<<')';
return out;
}
}
//const int INF=5e8;
int n,q;
lint ar[100005];
lint sum[100005][2];
lint sumA[100005];
int main(){
cin>>n>>q;
const lint M=1e10;
REP(i,n){
cin>>ar[i];
ar[i]*=4;
}
REP(i,n){
sum[i+1][0]=sum[i][0];
sum[i+1][1]=sum[i][1];
sum[i+1][i&1]+=ar[i];
sumA[i+1]=sumA[i]+ar[i];
}
REP(hoge,q){
lint v;cin>>v;
v=v*4-1;
lint lb=-1,ub=M;
while(ub-lb>1){
lint md=(lb+ub)>>1;
lint L=v-md,R=v+md;
int L1=lower_bound(ar,ar+n,L)-ar,R1=lower_bound(ar,ar+n,R)-ar;
int cntA=R1-L1,cntT=n-R1;
if(cntA<=cntT){
lb=md;
}else{
ub=md;
}
}
int L1=lower_bound(ar,ar+n,v-lb)-ar,R1=lower_bound(ar,ar+n,v+lb)-ar;
lint res=sum[L1][((n-L1)&1)^(L1&1)^1]+(sumA[n]-sumA[R1]);
printf("%lld\n",res/4);
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define _MACRO(_1, _2, _3, NAME, ...) NAME
#define _repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define _rep(i,n) _repl(i,0,n)
#define rep(...) _MACRO(__VA_ARGS__, _repl, _rep)(__VA_ARGS__)
#define pb push_back
#define all(x) begin(x),end(x)
#define uniq(x) sort(all(x)),(x).erase(unique(all(x)),end(x))
#ifdef LOCAL
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
void _dbg(string){cerr<<endl;}
template<class H,class... T> void _dbg(string s,H h,T... t){int l=s.find(',');cerr<<s.substr(0,l)<<" = "<<h<<", ";_dbg(s.substr(l+1),t...);}
template<class T,class U> ostream& operator<<(ostream &o, const pair<T,U> &p){o<<"("<<p.first<<","<<p.second<<")";return o;}
template<class T> ostream& operator<<(ostream &o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
#else
#define dbg(...) {}
#endif
int main(){
int n,q;
cin>>n>>q;
vector<int> a(n);
rep(i,n) cin>>a[i];
vector<long> acc(n+1,0);
rep(i,n) acc[i+1] = acc[i] + a[i];
vector<long> step(n+2,0);
for(int i=(n+1)%2; i<n; i+=2){
step[i] += a[i];
step[i+2] += step[i];
}
vector<long> keys;
vector<long> values;
rep(i,1,(n+1)/2 + 1){
keys.pb((a[n-i-1]+a[n-i*2-1])/2);
long v = acc[n] - acc[n-i];
if(n-2*i-1 >= 0) v += step[n-2*i-1];
values.pb(v);
}
reverse(all(keys));
reverse(all(values));
dbg(keys, values);
rep(_,q){
long x;
cin>>x;
int idx = lower_bound(all(keys), x) - begin(keys);
dbg(idx);
cout << values[max(0,idx-1)] << "\n";
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
int N, Q;
cin >> N >> Q;
vector<ll> A(N), sum(N + 1), sum2(N + 1);
for (int i = 0; i < N; i++) {
cin >> A[i];
sum[i + 1] = sum[i] + A[i];
sum2[i + 1] = (i ? sum2[i - 1] : 0) + A[i];
}
while (Q--) {
ll X;
cin >> X;
int lb = 0, ub = N + 1;
while (ub - lb > 1) {
int t = (lb + ub) >> 1;
if (abs(A[N - (t + 1) / 2] - X) < abs(A[N - t] - X)) {
ub = t;
}
else {
lb = t;
}
}
cout << sum2[max(N - lb - (lb & 1), 0)] + (sum[N] - sum[N - (lb + 1) / 2]) << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, Q;
cin >> N >> Q;
vector<int> A(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
vector<pair<int, int>> X(Q);
for (int i = 0; i < Q; ++i) {
cin >> X[i].first;
X[i].second = i;
}
sort(begin(X), end(X));
reverse(begin(X), end(X));
vector<long long> preA(N, 0), evenA(N, 0), oddA(N, 0);
preA[0] = evenA[0] = A[0];
for (int i = 1; i < N; ++i) {
preA[i] = A[i] + preA[i - 1];
evenA[i] = (i % 2 == 0 ? A[i] : 0) + evenA[i - 1];
oddA[i] = (i % 2 == 0 ? 0 : A[i]) + oddA[i - 1];
}
vector<long long> res(Q);
for (int q = 0, i = N - 3, j = N - 2; q < Q; ++q) {
while (i >= 0 && j >= 0 && abs(A[i] - X[q].first) <= abs(A[j] - X[q].first)) {
i -= 2;
--j;
//cout << "move" << endl;
}
/*cout << "for " << X[q] << endl;
for (int k = 0; k < N; ++k) {
if (k <= i) {
cout << "abw " << A[k] << endl;
} else if (k <= j) {
cout << "aoki " << A[k] << endl;
} else {
cout << "taka " << A[k] << endl;
}
}*/
long long cur = preA[N - 1] - (j < 0 ? 0 : preA[j]);
if (i % 2 == 0) {
cur += (i < 0 ? 0 : evenA[i]);
} else {
cur += (i < 0 ? 0 : oddA[i]);
}
res[X[q].second] = cur;
}
for (long long x : res) {
cout << x << "\n";
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
//#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int N, Q, A[101010], X[101010];
set<int> AS;
//---------------------------------------------------------------------------------------------------
ll B[101010];
void init() {
B[0] = A[0];
rep(i, 1, N) B[i] = B[i - 1] + A[i];
}
ll get(int L, int R) {
ll res = B[R];
if (L) res -= B[L - 1];
return res;
}
//---------------------------------------------------------------------------------------------------
pair<int, int> f(int x, int len) {
int lft = lower_bound(A, A + N, x - len) - A;
int rht = upper_bound(A, A + N, x + len) - A - 1;
return { lft, rht };
}
//---------------------------------------------------------------------------------------------------
ll takasm[101010];
void pre() {
rep(i, 0, N) {
if (N % 2 == 1 and i % 2 == 0) takasm[i] = A[i];
if (N % 2 == 0 and i % 2 == 1) takasm[i] = A[i];
}
rep(i, 1, N) takasm[i] += takasm[i - 1];
}
//---------------------------------------------------------------------------------------------------
ll solve(int x) {
int ng = -1, ok = inf;
while (ng + 1 != ok) {
int md = (ng + ok) / 2;
auto p = f(x, md);
if (p.first > p.second) {
ng = md;
continue;
}
int len = p.second - p.first + 1;
if (N - 1 <= p.second + len) ok = md;
else ng = md;
}
int L, R;
tie(L, R) = f(x, ok);
int turn = R - L + 1;
//printf("[%d %d %d]\n", ok, L, R);
int taka = N - R - 1;
int aoki = turn;
if (taka != aoki) {
R--;
aoki--;
turn--;
}
//if (taka != aoki) printf("%d %d %d\n", x, taka, aoki);
ll res = get(R + 1, N - 1);
if (L) res += takasm[L - 1];
return res;
}
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N >> Q;
rep(i, 0, N) cin >> A[i];
rep(i, 0, Q) cin >> X[i];
rep(i, 0, N) AS.insert(A[i]);
init();
pre();
rep(i, 0, Q) printf("%lld\n", solve(X[i]));
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long LL;
typedef pair<int, int> PII;
int n, q;
int a[100000];
int x;
int cfrom, cto;
LL pref[100001], suf[100001];
bool check(int turns) {
int taka = (turns + 1) / 2;
int aoki = turns / 2;
int lo = 0, hi = n - aoki, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
int from = mid;
int to = mid + aoki - 1;
bool ok;
if (a[to] - x >= x - a[from]) {
ok = (from == 0 || a[to] - x < x - a[from - 1]);
if (!ok) {
hi = mid - 1;
}
} else {
ok = (to == n - 1 || a[to + 1] - x >= x - a[from]);
if (!ok) {
lo = mid + 1;
}
}
if (ok) {
lo = hi = mid;
break;
}
}
cfrom = lo;
cto = lo + aoki - 1;
return cto < n - taka;
}
LL solve(int _x) {
x = _x;
int lo = 1, hi = n, mid;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
if (check(mid)) {
lo = mid;
} else {
hi = mid - 1;
}
}
LL res = suf[n - (lo + 1) / 2];
res += pref[n - lo];
return res;
}
int main() {
// freopen("input.txt", "r", stdin);
scanf("%d%d", &n, &q);
forn(i, n) scanf("%d", a + i);
pref[0] = 0;
forn(i, n) {
if (i % 2 != n % 2) {
pref[i + 1] = pref[i] + a[i];
} else {
pref[i + 1] = pref[i];
}
}
suf[n] = 0;
for (int i = n - 1; i >= 0; --i) {
suf[i] = suf[i + 1] + a[i];
}
forn(_, q) {
int x;
scanf("%d", &x);
LL res = solve(x);
printf("%lld\n", res);
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
//const ll mod = 1000000007;
ll S[100050][3];
ll sum(int from, int to, int index){
ll val = S[to][index];
if(from > 0){
val -= S[from - 1][index];
}
return val;
}
int main() {
//cout.precision(10);
int n, q;
cin >> n >> q;
vector<ll> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
sort(a.begin(), a.end());
for(int i = 0; i < 3; i++){
S[0][i] = a[0];
}
S[0][1] = 0;
for(int i = 1; i < n; i++){
for(int k = 0; k < 3; k++){
S[i][k] = S[i - 1][k] + a[i];
if(k == 2) continue;
if((i % 2) != (k % 2)){
S[i][k] = S[i - 1][k];
}
}
for(int k = 0; k < 3; k++){
//cout << S[i][k] << " " ;
}
//cout << endl;
}
while(q--){
ll x;
cin >> x;
ll ok = n - 1;
ll ng = 0;
while(ok - ng > 1){
ll mid = (ok + ng) / 2;
ll Takahashi = a[mid];
ll delta = n - mid;
if(mid - delta + 1 < 0) {
ng = mid;
continue;
}
ll Aoki = a[mid - delta + 1];
if(abs(Takahashi - x) < abs(Aoki - x)){
ng = mid;
continue;
}
if(abs(Takahashi - x) >= abs(Aoki - x)){
ok = mid;
}
}
//cout << ok << endl;
ll get = n - ok;
ll checked = n - get - get;
//cout << checked << endl;
ll ans = sum(ok, n - 1, 2);
if(checked >= 1){
ans += sum(0, checked - 1, 1 - (n % 2));
}
cout << ans << endl;
}
return 0;
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+7;
int n,Q,num;
ll sum[N],ou[N],ji[N],a[N],ans;
bool check(int pos,ll x)
{
int sz=n-pos+1,posl=pos-sz+1;
if(posl<1)return 0;
if(x<=a[posl]||a[pos]-x>=x-a[posl])return 1;
return 0;
}
int main()
{
scanf("%d%d",&n,&Q);
for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
for(int i=1;i<=n;i++)
{
sum[i]=sum[i-1]+a[i];
if(i==1)ji[i]=a[i];
else if(i&1)ji[i]=ji[i-2]+a[i];
else ou[i]=ou[i-2]+a[i];
}
num=(n+1)/2;
while(Q--)
{
ll x;scanf("%lld",&x);
if(x<=a[n/2+1]&&a[n/2+1]-x>x-a[1]){printf("%lld\n",sum[n]-sum[n/2]);continue;}
int l=n/2+1,r=n,mid,pos=n;
while(l<=r)
{
mid=(l+r)/2;
if(check(mid,x))pos=mid,r=mid-1;
else l=mid+1;
}
int sz=n-pos+1,posl=pos-sz;
ans=sum[n]-sum[pos-1]+max(ou[posl-1],ji[posl-1]);
printf("%lld\n",ans);
}
} |
p03158 | C++ | #include <iostream>
#include <algorithm>
#include <vector>
#include <string.h>
#include <complex>
using namespace std;
#define mod (long)(998244353)
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl(long(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
//#define long long long
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void POSS(T condition){ if(condition) cout << "POSSIBLE" << endl; else cout << "IMPOSSIBLE" << endl; }
template<class T> inline void Poss(T condition){ if(condition) cout << "Possible" << endl; else cout << "Impossible" << endl; }
template<class T> inline void First(T condition){ if(condition) cout << "First" << endl; else cout << "Second" << endl; }
template<class T = string, class U = char>int character_count(T text, U character){ int ans = 0; for(U i: text){ ans += (i == character); } return ans; }
long power(long base, long exponent, long module){ if(exponent % 2){ return power(base, exponent - 1, module) * base % module; }else if(exponent){ long root_ans = power(base, exponent / 2, module); return root_ans * root_ans % module; }else{ return 1; }}
struct position{ int y, x; }; position mv[4] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // double euclidean(position first, position second){ return sqrt((second.x - first.x) * (second.x - first.x) + (second.y - first.y) * (second.y - first.y)); }
template<class T, class U> string to_string(pair<T, U> x){ return to_string(x.first) + "," + to_string(x.second); }
template<class itr> void array_output(itr start, itr goal){ string ans; for(auto i = start; i != goal; i++){ ans += to_string(*i) + " "; } ans.pop_back(); cout << ans << endl; }
template<class itr> void cins(itr start, itr goal){ for(auto i = start; i != goal; i++){ cin >> (*i); } }
template<class T> T gcd(T a, T b){ if(a && b){ return gcd(min(a, b), max(a, b) % min(a, b)); }else{ return a; }} template<class T> T lcm(T a, T b){ return a / gcd(a, b) * b; }
struct combination{ vector<long> fact, inv; combination(int sz) : fact(sz + 1), inv(sz + 1){ fact[0] = 1; for(int i = 1; i <= sz; i++){ fact[i] = fact[i - 1] * i % mod; } inv[sz] = power(fact[sz], mod - 2, mod); for(int i = sz - 1; i >= 0; i--){ inv[i] = inv[i + 1] * (i + 1) % mod; } } long C(int p, int q) const{ if(q < 0 || p < q) return 0; return (fact[p] * inv[q] % mod * inv[p - q] % mod); } };
int main(){
int N, Q;
cin >> N >> Q;
long A[N];
cins(A, A + N);
long A_sum[N + 1];
A_sum[0] = 0;
for(int i = 0; i < N; i++){
A_sum[i + 1] = A[i] + A_sum[i];
}
long ichimatsu[N];
ichimatsu[0] = A[0];
ichimatsu[1] = A[1];
for(int i = 2; i < N; i++){
ichimatsu[i] = ichimatsu[i - 2] + A[i];
}
for(int i = 0; i < Q; i++){
long X;
cin >> X;
int left = 0, right = (N + 1) / 2; // (left, right]
while(left + 1 < right){
int middle = (left + right) / 2;
if(middle * 2 >= N){
right = middle;
continue;
}
if(abs(X - A[N - middle - 1]) < abs(X - A[N - middle * 2 - 1])){
right = middle;
}else{
left = middle;
}
}
if(N - right * 2 - 1 >= 0){
cout << A_sum[N] - A_sum[N - right] + ichimatsu[N - right * 2 - 1] << endl;
}else{
cout << A_sum[N] - A_sum[N - right] << endl;
}
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))
// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a)%MOD+MOD)%MOD
// floating
typedef double Real;
const Real EPS = 1e-11;
#define EQ0(x) (abs(x)<EPS)
#define EQ(a,b) (abs(a-b)<EPS)
typedef complex<Real> P;
int n,q;
int a[125252];
int x[125252];
ll sum[125252];
ll esum[125252];
int main(){
scanf("%d%d",&n,&q);
REP(i,n)scanf("%d",a+i);
REP(i,q)scanf("%d",x+i);
REP(i,n)sum[i+1] = sum[i] + a[i];
REP(i,n)esum[i+1] = esum[i] + (i%2==0 ? a[i] : 0);
REP(_,q){
int X = x[_];
int low = -1, high = 1000000025;
int ml=n, mr=n;
while(low+1<high){
int d = (low+high)/2;
int l = lower_bound(a,a+n,X-d)-a;
int r = upper_bound(a,a+n,X+d)-a;
// printf("X:%d, d:%d, l:%d, r:%d\n",X,d,l,r);
int sz = r-l;
if(sz>=2 && X-a[l] == a[r-1]-X){
// same
r--; sz--;
if(n-sz < r){
high = d;
}else{
if(n-sz-1 < r+1){
// puts("1");
low = d;
ml = l;
mr = r;
}else{
// puts("2");
low = d;
ml = l;
mr = r+1;
}
}
}else{
if(n-sz < r){
high = d;
}else{
// puts("3");
low = d;
ml = l; mr = r;
}
}
}
int sz = mr-ml;
int zl = n-sz, zr = n;
// DEBUG(X);
// DEBUG(ml); DEBUG(mr); DEBUG(zl); DEBUG(zr);
ll ans = sum[mr] - sum[ml];
if(zl == mr){
ans += (ml%2==0 ? esum[ml] : (sum[ml]-esum[ml]));
}else{
ans += (ml%2==1 ? esum[ml] : (sum[ml]-esum[ml]));
}
printf("%lld\n",sum[n] - ans);
}
return 0;
}
|
p03158 | C++ | // vvvvvvvvvvvv TEMPLATE vvvvvvvvvvvv
#include <bits/stdc++.h>
using namespace std; using ll = long long; using P = pair<ll, ll>;
const ll linf = 1e18; const double eps = 1e-12, pi = acos(-1);
#define FOR(i,a,b) for (ll i=(a),__last_##i=(b);i<__last_##i;i++)
#define RFOR(i,a,b) for (ll i=(b)-1,__last_##i=(a);i>=__last_##i;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define each(i,a) for (auto&& i : a)
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
#define pb push_back
#define eb emplace_back
#define all(a) begin(a),end(a)
#define chmin(x,v) x = min(x, v)
#define chmax(x,v) x = max(x, v)
#define min(x,y) (x < y ? x : y)
#define max(x,y) (x < y ? y : x)
template<typename Head> void out(Head h) { cout << h << endl; } template<typename Head, typename... Tail>void out(Head h, Tail... t) { cout << h << " "; out(t...); }
template<typename T> istream& operator>>(istream& is, vector<T>& v) { each(x,v) is >> x; return is; }
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) { rep(i,v.size()) { if (i) os << " "; os << v[i]; } return os; }
ostream& operator<<(ostream& os, const vector<string>& v) { rep(i,v.size()) { if (i) os << endl; os << v[i]; } return os; }
template<typename T> ostream& operator<<(ostream& os, const vector<vector<T>>& v) { rep(i,v.size()) { if (i) os << endl; os << v[i]; } return os; }
template<typename T1, typename T2> ostream& operator<<(ostream& os, const pair<T1, T2>& p) { return os << "(" << p.first << ", " << p.second << ")"; }
struct yes_no : std::numpunct<char> { string_type do_truename() const { return "Yes"; } string_type do_falsename() const { return "No"; } };
void solve(); int main() {
ios::sync_with_stdio(false); cin.tie(0); locale loc(locale(), new yes_no); cout.imbue(loc); cout << fixed << setprecision(10) << boolalpha;
solve();
}
// ^^^^^^^^^^^^ TEMPLATE ^^^^^^^^^^^^
void solve() {
ll n, Q; cin >> n >> Q;
vector<ll> A(n); cin >> A;
sort(all(A));
vector<ll> S1(n+1, 0), S2(n+1, 0);
rep(i, n) S1[i+1] = S1[i] + A[i];
rep(i, n) S2[i+1] = A[i];
rep(i, 2, n+1) S2[i] += S2[i-2];
ll sum = 0;
auto check = [&](ll mid, ll X, ll xub) {
ll fst = mid, snd = mid;
if (n-1-fst < xub) return true;
ll right = n-fst-xub;
ll left = xub;
if (right == 0) return true;
if (left + right <= snd) return true;
if (snd < right) return false;
ll L = snd - (right-1) - 1;
// cout << left << " " << right << " " << L << endl;
if (L < 0) return false;
if (L >= left) return true;
return abs(X-A[xub+right-1]) < abs(X-A[xub-L-1]);
};
// cout << check(2, 4, 1) << endl;
// return;
rep(i, Q) {
ll X; cin >> X;
ll lb = 0, ub = n;
ll xub = upper_bound(all(A), X) - A.begin();
rep(t, 30) {
// 高橋くんが何ターン行うか
ll mid = (lb + ub) / 2;
if (check(mid, X, xub)) {
ub = mid;
}
else {
lb = mid;
}
}
ll T = ub;
// cout << T << endl;
ll ans = (S1[n] - S1[n-T]) + S2[max(0, n-2*T)];
cout << ans << endl;
}
}
|
p03158 | C++ | #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v) out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 200010
int n, Q, a[SIZE];
ll sum[SIZE] = {}, sum_e[SIZE][2] = {};
int main(){
scanf("%d%d", &n, &Q);
for(int i=0;i<n;i++){
scanf("%d", a+i);
sum[i+1] = sum[i] + a[i];
sum_e[i+1][0] += sum_e[i][0];
sum_e[i+1][1] += sum_e[i][1];
sum_e[i+1][i%2] += a[i];
}
for(int i=0;i<Q;i++){
int x;
scanf("%d", &x);
int pos = lower_bound(a, a+n, x) - a;
int l = 0, r = 1e9;
while(l < r){
int mid = (l+r)/2;
int c1 = upper_bound(a, a+n, x+mid) - lower_bound(a, a+n, x-mid);
int c2 = a+n - lower_bound(a, a+n, x+mid+1);
if (c1 < c2) {
l = mid+1;
} else {
r = mid;
}
}
int posA = lower_bound(a, a+n, x+l+1) - a;
int posB = lower_bound(a, a+n, x-l) - a;
if (n - posA < posA - posB) posA--;
debug(posA);
debug(posB);
debug(l);
ll sumA = sum[n] - sum[posA] + sum_e[posB][1-n%2];
ll sumB = sum[posA] - sum[posB] + sum_e[posB][n%2];
printf("%lld\n", sumA);
}
return 0;
}
|
p03158 | C++ | #define _CRT_SECURE_NO_DEPRECATE
#define _USE_MATH_DEFINES
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <memory.h>
#include <set>
#include <ctime>
#include <map>
#include <cstring>
#include <iterator>
#include <queue>
#include <assert.h>
#include <bitset>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <functional>
//#pragma comment(linker, "/STACK:512000000")
using namespace std;
#define pb emplace_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define forn(i, n) for (int i = 0; i < (n); ++i)
#define forab(i, a, b) for (int i = (a); i < (b); ++i)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int infi = 1e9 + 7;
const ll infl = (ll)1e18 + (ll)7;
ll ar[100500];
ll sum1[100500];
ll sum2[100500];
int get1(int n, int x, int d) {
int l = lower_bound(ar, ar + n, x - d) - ar;
int r = lower_bound(ar, ar + n, x + d) - ar - 1;
return max(r - l + 1, 0);
}
int32_t main() {
cin.sync_with_stdio(false);
cin.tie(0);
//srand(time(NULL));
// freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
//freopen("customs.in", "r", stdin); freopen("customs.out", "w", stdout);
int n, q;
cin >> n >> q;
forn(i, n)
cin >> ar[i];
sort(ar, ar + n);
forn(i, n) {
sum1[i] = ar[i];
if (i)
sum1[i] += sum1[i - 1];
sum2[i] = ar[i];
if (i > 1)
sum2[i] += sum2[i - 2];
}
while (q--) {
int x;
cin >> x;
if (x >= ar[n - 1]) {
cout << sum2[n - 1] << '\n';
continue;
}
int l = 1, r = n, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
int i = n - mid;
if (ar[i] < x) {
r = mid - 1;
continue;
}
int cnt = get1(n, x, abs(x - ar[i]));
if (cnt + 1 >= mid) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
ll sum = 0;
int i = n - ans;
sum = sum1[n - 1];
if (i)
sum -= sum1[i - 1];
i -= ans + 1;
if (i >= 0)
sum += sum2[i];
cout << sum << '\n';
}
return 0;
} |
p03158 | C++ | #include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
template<class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp=0; begin!=end; ++begin) { if (sp) putchar(' '); else sp = true; printf(fmt, *begin); }
putchar('\n');
}
int N, Q;
int A[100111];
LL sums[100111];
LL suma[100111];
void MAIN() {
scanf("%d%d", &N, &Q);
REP (i, N) scanf("%d", A+i);
REP (i, N) sums[i+1] = sums[i] + A[i];
REP (i, N) suma[i+1] = (i? suma[i-1]: 0) + A[i];
REP (i, Q) {
int x;
scanf("%d", &x);
int lo = 0, hi = N;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (mid * 2 - 1 <= N && A[N-mid] - x >= x - A[N-mid-mid+1]) {
lo = mid;
} else {
hi = mid;
}
}
LL ans = (sums[N]-sums[N-lo]) + (N-lo-lo >= 0? suma[N-lo-lo]: 0);
//eprintf("%lld %lld\n", sums[N]-sums[N-lo], suma[N-lo-lo]);
printf("%lld\n", ans);
}
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP (tc, TC) MAIN();
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << (x) << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){
return o<<"("<<p.fs<<","<<p.sc<<")";
}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){
o<<"{";
for(const T& v:vc) o<<v<<",";
o<<"}";
return o;
}
using ll = long long;
template<class T> using V = vector<T>;
template<class T> using VV = vector<vector<T>>;
int N,Q;
ll A[100010];
ll ac[100010];
ll bc[100010];
int main(){
cin>>N>>Q;
rep(i,N) cin>>A[i];
rep(i,N) ac[i+1] = ac[i] + A[i];
rep(i,N){
bc[i] = (i>=2?bc[i-2]:0) + A[i];
}
rep(_,Q){
ll X;
cin>>X;
auto better = [&](ll a,ll b){
if(abs(X-a) != abs(X-b)) return abs(X-a) < abs(X-b);
return a<b;
};
auto touch = [&](int t){
if(t+t+1>N) return true;
if(better(A[N-t-1],A[N-t-t-1])) return true;
return false;
};
int ub = N, lb = 0;
while(ub-lb>1){
int m = (ub+lb)/2;
if(touch(m)) ub = m;
else lb = m;
}
// show(ub);
ll res = (ac[N]-ac[N-ub]) + (N-1-ub-ub>=0 ? bc[N-1-ub-ub] : 0);
cout<<res<<endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
using ll=long long;
using R=long double;
const R EPS=1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R& r){return(r > EPS)-(r < -EPS);}
inline R sq(R x){return sqrt(max(x,0.0L));}
const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};
const pid_t pid = getpid();
// Problem Specific Parameter:
#define error(args...) { vector<string> _debug = split(#args, ',');err(begin(_debug), args);}
vector<string> split(const string& s, char c){
vector<string> v;stringstream ss(s);string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {cerr << endl;}
template<typename T, typename... Args> void err(vector<string>::iterator it, T a,Args... args){
cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << " ",err(++it, args...);
}
const int limit = 100010;
int n, a[limit];
bool check(int x,int k){
const int val = a[n - k - 1];
const int len = val - x;
const int num = upper_bound(a, a + n, x + len) - lower_bound(a, a + n, x - len);
return k >= num;
}
int get_idx(int x,int k){
const int val = a[n - k - 1];
const int len = val - x;
const int num = upper_bound(a, a + n, x + len) - lower_bound(a, a + n, x - len);
const int idx = lower_bound(a, a + n, x - len) - a - (k - num);
return idx - 1;
}
ll lsum[limit];
ll hsum[limit];
int main(void){
int q;
cin >> n >> q;
rep(i,n) cin >> a[i];
hsum[0] = 0LL;
rrep(i, n){
const int idx = n - i;
hsum[idx] = hsum[idx - 1] + a[i];
}
rep(i, n){
if(i - 2 >= 0) lsum[i] += lsum[i - 2];
lsum[i] += a[i];
}
rep(loop,q){
int x;
cin >> x;
int ng = 0, ok = (n + 1) /2;
while(ok - ng > 1){
const int mid = (ng + ok) / 2;
if(check(x,mid))
ok = mid;
else
ng = mid;
}
const int idx = get_idx(x, ok);
// error(ok, idx);
ll ans = 0LL;
ans += hsum[ok];
if(idx >= 0) ans += lsum[idx];
cout << ans << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
using ll = long long;
using i_i = tuple<int, int>;
int main() {
int N, Q;
cin >> N >> Q;
vector<ll> a(N);
rep(i, N) scanf("%lld", &a[i]);
rep(i, N) a[i] *= 4;
vector<ll> sum(N + 1);
rep(i, N) sum[i + 1] = sum[i] + a[i];
vector<ll> unko(N + 1);
unko[1] = a[0];
for (int i = 2; i <= N; i++)
unko[i] = unko[i - 2] + a[i - 1];
while (Q--) {
ll x; scanf("%lld", &x);
x = x * 4 - 1;
ll lb = 0, ub = 10LL * INT_MAX;
int l0 = N, r0 = N;
while (ub - lb > 1) {
ll mid = (lb + ub) / 2;
ll xl = x - mid, xr = x + mid;
int l = lower_bound(all(a), xl) - a.begin();
int r = upper_bound(all(a), xr) - a.begin();
int d = r - l;
if (r <= N - d) {
lb = mid;
l0 = l;
r0 = r;
}
else ub = mid;
}
ll ans = sum[N] - sum[r0];
if ((N - l0) % 2) l0--;
if (l0 >= 0) ans += unko[l0];
printf("%lld\n", ans / 4);
}
}
|
p03158 | C++ | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
#define DEBUGP(val) cerr << #val << "=" << val << "\n"
using namespace std;
typedef long long int ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
const ll mod = 1e9 + 7;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
VL a(n);
REP(i, 0, n) cin >> a[i];
REP(i, 0, n) a[i] = 10 * a[i] + 1;
VL x(q);
REP(i, 0, q) cin >> x[i];
REP(i, 0, q) x[i] *= 10;
VL acc(n + 1);
VL acc2(n + 1);
REP(i, 0, n) acc[i + 1] = acc[i] + a[i] / 10;
acc2[1] = a[0] / 10;
REP(i, 1, n) acc2[i + 1] = acc2[i - 1] + a[i] / 10;
REP(i, 0, q) {
ll fail = 1e11;
ll pass = -1;
while (fail - pass > 1) {
ll mid = (pass + fail) / 2;
int idx0 = lower_bound(a.begin(), a.end(), x[i] - mid) - a.begin();
int idx1 = upper_bound(a.begin(), a.end(), x[i] + mid) - a.begin();
if (n - idx1 >= idx1 - idx0) pass = mid;
else fail = mid;
}
int idx0 = lower_bound(a.begin(), a.end(), x[i] - pass) - a.begin();
int idx1 = upper_bound(a.begin(), a.end(), x[i] + pass) - a.begin();
ll tot = 0;
assert ((n - idx1) - (idx1 - idx0) >= 0);
assert ((n - idx1) - (idx1 - idx0) <= 1);
if (n - idx1 == idx1 - idx0) {
tot += acc[n] - acc[idx1] + acc2[idx0];
} else {
tot += acc[n] - acc[idx1] + (idx0 >= 1 ? acc2[idx0 - 1] : 0);
}
cout << tot << "\n";
}
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct FastIO{
FastIO(){
cin.tie(0);
ios::sync_with_stdio(0);
}
}fastio_beet;
//INSERT ABOVE HERE
signed main(){
Int n,q;
cin>>n>>q;
vector<Int> a(n),xs(q);
for(Int i=0;i<n;i++) cin>>a[i];
for(Int i=0;i<q;i++) cin>>xs[i];
vector<Int> s(n+1,0);
for(Int i=0;i<n;i++) s[i+1]=s[i]+a[i];
vector<Int> t(n+1,0);
for(Int i=0;i<n;i++)
t[i+1]=(i?t[i-1]:0)+a[i];
for(Int x:xs){
auto check=
[&](Int k)->Int{
if(a[n-k]<=x) return 0;
Int l=-1,r=n-k;
while(l+1<r){
Int m=(l+r)>>1;
if(abs(a[m]-x)<=abs(a[n-k]-x)) r=m;
else l=m;
}
Int len=(n-(k+1))-r+1;
return len+1>=k;
};
Int l=1,r=n+1;
while(l+1<r){
Int m=(l+r)>>1;
if(check(m)) l=m;
else r=m;
}
//cout<<l<<" "<<n-l*2<<endl;
Int ans=(s[n]-s[n-l])+(n-l*2>=0?t[n-l*2]:0);
cout<<ans<<"\n";
}
cout<<flush;
return 0;
}
|
p03158 | C++ | #include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, Q;
cin >> N >> Q;
vector<long long> A(N);
for (int i = 0; i < N; ++i) cin >> A[i], A[i] *= 3;
vector<long long> S(N + 1), chrosum(N + 1);
for (int i = 0; i < N; ++i) {
S[i + 1] = S[i] + A[i];
chrosum[i + 1] = chrosum[i] + (i % 2 != N % 2 ? A[i] : 0);
}
for (int i = 0; i < Q; ++i) {
long long X;
cin >> X; X = 3 * X - 1;
long long L = 0, R = 3000000000;
while (R - L > 1) {
long long M = (L + R) >> 1;
int div1 = lower_bound(A.begin(), A.end(), X - M) - A.begin();
int div2 = lower_bound(A.begin(), A.end(), X + M + 1) - A.begin();
if (div2 - div1 > N - div2) R = M;
else L = M;
}
int fdiv1 = lower_bound(A.begin(), A.end(), X - L) - A.begin();
int fdiv2 = lower_bound(A.begin(), A.end(), X + L + 1) - A.begin();
long long ans = (S[N] - S[fdiv2]) + chrosum[fdiv1];
cout << ans / 3 << '\n';
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <algorithm>
using namespace std;
long long N, Q, A[1 << 17], X[1 << 17], V[1 << 17], B[1 << 17];
long long ranged(long long L1, long long R1) {
return B[R1 + 1] - B[L1];
}
long long query(long long Z) {
long long L = 0, R = N + 1, M, minx = N + 1;
for (int i = 0; i < 30; i++) {
M = (L + R) / 2;
pair<long long, long long> V = make_pair(N - M, N - (M + 1LL) / 2LL - 1LL); // 順当に行った場合の区間
bool ok = false; // 違反しているか
if (V.first <= V.second) {
long long SUB = max(abs(Z - A[V.first]), abs(Z - A[V.second]));
if (0LL <= V.second + 1 && V.second - 1 < N && abs(Z - A[V.second + 1]) < SUB) ok = true; // 左すぎ！
}
if (ok == true) { minx = min(minx, M); R = M; }
else { L = M; }
}
// minx が確定した
long long K = minx - 1;
long long T1 = ranged(N - (K + 1LL) / 2LL, N - 1LL);
long long T2 = V[N - K];
return T1 + T2;
}
int main() {
cin >> N >> Q;
for (int i = 0; i < N; i++) { cin >> A[i]; B[i + 1] = A[i]; V[i + 1] = V[i]; if (((N - 1) - i) % 2 == 0) V[i + 1] += A[i]; }
for (int i = 1; i <= N; i++) B[i] += B[i - 1];
for (int i = 0; i < Q; i++) cin >> X[i];
for (int i = 0; i < Q; i++) {
cout << query(X[i]) << endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll=int64_t;
#define int ll
#define FOR(i,a,b) for(int i=int(a);i<int(b);i++)
#define REP(i,b) FOR(i,0,b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(),x.end()
auto& errStream=cerr;
#ifdef LOCAL
#define cerr (cerr<<"-- line "<<__LINE__<<" -- ")
#else
class CerrDummy{}cerrDummy;
template<class T>
CerrDummy& operator<<(CerrDummy&cd,const T&){
return cd;
}
using charTDummy=char;
using traitsDummy=char_traits<charTDummy>;
CerrDummy& operator<<(CerrDummy&cd,basic_ostream<charTDummy,traitsDummy>&(basic_ostream<charTDummy,traitsDummy>&)){
return cd;
}
#define cerr cerrDummy
#endif
#define REACH cerr<<"reached"<<endl
#define DMP(x) cerr<<#x<<":"<<x<<endl
#define ZERO(x) memset(x,0,sizeof(x))
#define ONE(x) memset(x,-1,sizeof(x))
using pi=pair<int,int>;
using vi=vector<int>;
using ld=long double;
template<class T,class U>
ostream& operator<<(ostream& os,const pair<T,U>& p){
os<<"("<<p.first<<","<<p.second<<")";
return os;
}
template<class T>
ostream& operator <<(ostream& os,const vector<T>& v){
os<<"{";
REP(i,(int)v.size()){
if(i)os<<",";
os<<v[i];
}
os<<"}";
return os;
}
ll read(){
ll i;
scanf("%" SCNd64,&i);
return i;
}
void printSpace(){
printf(" ");
}
void printEoln(){
printf("\n");
}
void print(ll x,int suc=1){
printf("%" PRId64,x);
if(suc==1)
printEoln();
if(suc==2)
printSpace();
}
string readString(){
static char buf[3341000];
scanf("%s",buf);
return string(buf);
}
char* readCharArray(){
static char buf[3341000];
static int bufUsed=0;
char* ret=buf+bufUsed;
scanf("%s",ret);
bufUsed+=strlen(ret)+1;
return ret;
}
template<class T,class U>
void chmax(T& a,U b){
if(a<b)
a=b;
}
template<class T,class U>
void chmin(T& a,U b){
if(b<a)
a=b;
}
template<class T>
T Sq(const T& t){
return t*t;
}
#define CAPITAL
void Yes(bool ex=true){
#ifdef CAPITAL
cout<<"YES"<<endl;
#else
cout<<"Yes"<<endl;
#endif
if(ex)exit(0);
}
void No(bool ex=true){
#ifdef CAPITAL
cout<<"NO"<<endl;
#else
cout<<"No"<<endl;
#endif
if(ex)exit(0);
}
const ll infLL=LLONG_MAX/3;
#ifdef int
const int inf=infLL;
#else
const int inf=INT_MAX/2-100;
#endif
signed main(){
int n=read(),q=read();
vi a(n);
REP(i,n)
a[i]=read();
vi r(n+1,0),s(n+1,0);
REP(i,n){
r[i+1]=r[i]+a[i];
s[i+1]=(i-1>=0?s[i-1]:0)+a[i];
}
REP(_,q){
int x=read();
int bot=1,top=n;
while(top-bot>1){
const int mid=(bot+top)/2;
bool ok=true;
if(a[n-mid]<=x)
ok=false;
else{
int len=a[n-mid]-x;
int pos=lower_bound(ALL(a),x-len)-a.begin();
if(n-mid-pos<mid-1)
ok=false;
}
if(ok)
bot=mid;
else
top=mid;
}
int ans=r[n]-r[n-bot];
if(n-bot*2>=0)
ans+=s[n-bot*2];
print(ans);
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n,q;
ll a[100005];
ll sum[100005];
ll sum2[100005];
bool C(int rpos,ll x){
ll dif=a[rpos]-x;
int lpos=lower_bound(a,a+n,x-dif)-a;
int cnt=rpos-lpos+1;
int cnt2=n-rpos-1;
if(cnt2>=cnt)return true;
return false;
}
ll solve(ll x){
int l=0,r=n;
while(l+1<r){
int mid=(l+r)/2;
if(C(mid,x)){
l=mid;
}else{
r=mid;
}
}
ll ans=sum[n]-sum[l+1];
int len=n-l-1;
int n2=n-len*2;
if(n2>=0){
ans+=sum2[n2];
}
return ans;
}
int main(void){
scanf("%d%d",&n,&q);
for(int i=0;i<n;i++){
scanf("%lld",&a[i]);
sum[i+1]+=sum[i];
sum[i+1]+=a[i];
}
sum2[1]=a[0];
sum2[2]=a[1];
for(int i=2;i<n;i++){
sum2[i+1]+=sum2[i-1];
sum2[i+1]+=a[i];
}
sort(a,a+n);
for(int i=0;i<q;i++){
ll x;
scanf("%lld",&x);
printf("%lld\n",solve(x));
}
return 0;
} |
p03158 | C++ | #include <cstdio>
#include <algorithm>
using namespace std;
int a[100000];
int x[100000];
long long sum1[100001];
long long sum2[100001];
int main() {
int n, q, i;
scanf("%d %d", &n, &q);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < q; i++) scanf("%d", &x[i]);
for (i = 0; i < n; i++) sum1[i + 1] = sum1[i] + a[i];
for (i = 0; i < n; i++) {
sum2[i + 1] = sum2[i];
if (n % 2 != i % 2) sum2[i + 1] += a[i];
}
for (i = 0; i < q; i++) {
int l, r, m;
long long ans = 0;
l = 1, r = n, m = (l + r) / 2;
while (r - l > 1) {
if (m * 2 > n + 1) {
r = m;
m = (l + r) / 2;
} else {
int p = a[n - m];
int q = a[max(n - m * 2 + 1, 0)];
if (abs(x[i] - p) >= abs(x[i] - q)) {
l = m;
m = (l + r) / 2;
} else {
r = m;
m = (l + r) / 2;
}
}
}
ans += sum1[n] - sum1[n - l];
if (n - l * 2 > 0) ans += sum2[n - l * 2 + 1];
printf("%lld\n", ans);
}
return 0;
}
|
p03158 | C++ | #include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <functional>
#include <string>
#include <set>
#include <map>
#include <cmath>
#include <cassert>
#define SIZE 100005
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
ll A[SIZE];
ll sum[SIZE];
ll s2[SIZE];
int main()
{
int n,Q;
scanf("%d %d",&n,&Q);
for(int i=0;i<n;i++) scanf("%lld",&A[i]);
for(int i=0;i<n;i++)
{
sum[i]=0;
if((n-i-1)%2==0) sum[i]=A[i];
if(i>0) sum[i]+=sum[i-1];
s2[i]=A[i];
if(i>0) s2[i]+=s2[i-1];
}
while(Q--)
{
ll x;
scanf("%lld",&x);
int l=0,r=n+1;
while(r-l>1)
{
int d=(l+r)/2;
if(A[n-d]<=x) r=d;
else
{
if(2*d-1>n) r=d;
else
{
if(A[n-d]-x>=x-A[n-2*d+1]) l=d;
else r=d;
}
}
}
ll ret=s2[n-1]-s2[n-l-1];
if(n-2*l-1>=0) ret+=sum[n-2*l-1];
printf("%lld\n",ret);
}
return 0;
}
|
p03158 | C++ | #include<cstdio>
#include<algorithm>
using namespace std;
const int MAX_N = 100000;
const int MAX_Q = 100000;
const long long UB = 1000000000;
long long A[MAX_N];
int N;
long long eSum[MAX_N], oSum[MAX_N];
long long sum[MAX_N];
bool lt(int x, int a, int b){
if(b < 0 || b >= N) return true;
if(a < 0 || a >= N) return false;
long long d1 = abs(x - A[a]);
long long d2 = abs(x - A[b]);
if(d1 < d2) return true;
if(d1 == d2) return a < b;
return false;
}
long long calc(int r, int d){
if(r < 0) return 0;
if(d == 0) return eSum[r];
else if(d == 1) return oSum[r];
else return sum[r];
}
long long calc(int l, int r, int d){
if(l > r) return 0;
return calc(r, d) - calc(l - 1, d);
}
long long query(int x){
int lb = 1, ub = N + 1;
while(ub - lb > 1){
int mid = (lb + ub) / 2;
int a = mid / 2;
int b = mid / 2;
if(a + b < mid) a++;
int l = N - mid;
int r = N - a - 1;
// take [l, r]
if(lt(x, r + 1, l)) ub = mid;
else lb = mid;
}
// lb cards: no conflict
int a = (lb + 1) / 2;
int d = N % 2;
long long ans = calc(0, N - lb - 1, d) + calc(N - lb, N - a - 1, -1);
return sum[N - 1] - ans;
}
int main(){
int Q;
scanf("%d%d", &N, &Q);
for(int i = 0; i < N; ++i) scanf("%lld", A + i);
sum[0] = A[0];
for(int i = 1; i < N; ++i) sum[i] = sum[i - 1] + A[i];
eSum[0] = A[0];
for(int i = 1; i < N; ++i) eSum[i] = eSum[i - 1] + (i % 2 == 0 ? A[i] : 0);
oSum[0] = 0;
for(int i = 1; i < N; ++i) oSum[i] = oSum[i - 1] + (i % 2 == 1 ? A[i] : 0);
for(int i = 0; i < Q; ++i){
long long x;
scanf("%lld", &x);
long long ans = query(x);
printf("%lld\n", ans);
}
return 0;
}
|
p03158 | Python | def main(n,q,a,x):
a.reverse()
keys=[]
sums1=[0]
sums2=[0]
tmp1=0
tmp2=0
for i in range(n):
if i%2==0:tmp1+=a[i]
tmp2+=a[i]
sums1.append(tmp1)
sums2.append(tmp2)
sums=[]
for i in range((n-1)//2):
k=a[i+1]+a[i+1+(i+1)]
keys.append(k//2+1)
#
s=sums2[i+1]+sums1[-1]-sums1[i+1+(i+1)]
sums.append(s)
sums.append(sums2[(n+2-1)//2])
keys.append(0)
sums.reverse()
keys.reverse()
from bisect import bisect_right
#print(sums)
#print(keys)
for xx in x:
idx=bisect_right(keys,xx)-1
print(sums[idx])
n,q=map(int,input().split())
a=list(map(int,input().split()))
x=[int(input()) for _ in range(q)]
main(n,q,a,x)
|
p03158 | Python | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
import bisect
n,q = map(int,readline().split())
a = [0] + list(map(int,readline().split()))
x = [0] + list(map(int,read().split()))
cumsum = [0] * (n+1)
cumsum_eo = [0] * (n+1)
for i in range(1,n+1):
cumsum[i] = cumsum[i-1] + a[i]
if(i==1):
cumsum_eo[1] = a[1]
else:
cumsum_eo[i] = cumsum_eo[i-2] + a[i]
ans = []
for xi in x[1:]:
ok = 0
ng = (n+4)//2
cnt=0
while(ng-ok > 1):
mid = (ng+ok)//2
if( mid*2-1 > n):
ng = mid
continue
t_l = a[n+1-mid]
a_r = a[n-mid]
a_lr = a[n+1-mid*2+1]
if(t_l - xi < xi-a_lr ):
ng = mid
else:
ok = mid
cnt+=1
t_l_ind = n+1-ok
a_l_ind = n+1-ok*2
tmp = cumsum[-1] - cumsum[t_l_ind-1]
if(a_l_ind>1):
tmp += cumsum_eo[a_l_ind-1]
ans.append(tmp)
# print(ng,ok)
print('\n'.join(map(str,ans))) |
p03158 | Python | from bisect import bisect_left
N, Q, *AX = map(int, open(0).read().split())
A, X = AX[:N], AX[N:]
if N % 2 == 1:
A = [0] + A
M = len(A) // 2
B = []
S = [sum(A[M:])]
for i in range(M - 1):
l, r = A[2 * i + 1], A[i + M]
B.append((l + r) // 2)
S.append(S[-1] + l - r)
for x in X:
print(S[bisect_left(B, x)]) |
p03158 | Python | import sys
import bisect
input = sys.stdin.readline
def main():
n, q = map(int, input().split())
a = list(map(int, input().split()))
s = [0]*(n+1)
odd = [0]*(n+1)
even = [0]*(n+1)
for i in range(n):
s[i+1] += s[i]+a[i]
odd[i+1] += odd[i]
even[i+1] += even[i]
if i%2:
odd[i+1] += a[i]
else:
even[i+1] += a[i]
key = []
value = dict()
v = 0
for i in range(n):
if i == n-1:
k = pow(10, 9)
key.append(k)
value[k] = v
continue
k = (a[i+(n-i)//2]+a[i])//2
v = s[i+(n-i)//2]-s[i]
if (n-i)%2:
if i%2:
v += even[max(0, i)]
else:
v += odd[max(0, i)]
else:
if i%2:
v += odd[max(0, i-1)]
else:
v += even[max(0, i-1)]
key.append(k)
value[k] = v
sum_a = s[n]
for i in range(q):
x = int(input())
k = key[bisect.bisect_left(key, x)]
ans = sum_a-value[k]
print(ans)
if __name__ == "__main__":
main()
|
p03158 | Python | import sys
import bisect
input = sys.stdin.readline
def main():
n, q = map(int, input().split())
a = list(map(int, input().split()))
s = [0]*(n+1)
odd = [0]*(n+1)
even = [0]*(n+1)
for i in range(n):
s[i+1] += s[i]+a[i]
odd[i+1] += odd[i]
even[i+1] += even[i]
if i%2:
odd[i+1] += a[i]
else:
even[i+1] += a[i]
key = []
value = dict()
v = 0
for i in range(n):
if i == n-1:
k = pow(10, 9)
key.append(k)
value[k] = v
continue
k = (a[i+(n-i)//2]+a[i])//2
v = s[i+(n-i)//2]-s[i]
if (n-i)%2:
if i%2:
v += even[max(0, i)]
else:
v += odd[max(0, i)]
else:
if i%2:
v += odd[max(0, i-1)]
else:
v += even[max(0, i-1)]
key.append(k)
value[k] = v
sum_a = s[n]
for i in range(q):
x = int(input())
k = key[bisect.bisect_left(key, x)]
ans = sum_a-value[k]
print(ans)
if __name__ == "__main__":
main()
|
p03158 | Python | import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,Q=MI()
A=LI()
if N%2==1:#長さが奇数なら0を足しておく
A+=[0]
N+=1
A.sort()
"""
連続する区間or交互
"""
S=[0]*(N+1)
S2=[0]*(N+1)#偶数のみ
for i in range(N):
S[i+1]=S[i]+A[i]
for i in range(0,N-1):
S2[i+2]=S2[i]+A[i]
# print(S)
# print(S2)
def calc(P):
# 先手が上からP枚，後手がその後のP枚をとり，残りを交互に取った時の先手のscore
fi=S[-1]-S[-P-1]
fi+=S2[-2*P]
return fi
def ch(X,P):
#xが指定され，先手が上からP枚以上取れるか
maxa=A[-P-1]#後手が取るmax
mina=A[-2*P+1]#後手がP-1ターン目までに取る取るmin(後手がPターン目に取るものはなんでも良い)
diff=A[-P]-X
# print(X,P,mina,maxa,diff)
if diff<0:
return False
if X-diff<=mina and maxa<=X+diff:
return True
return False
for _ in range(Q):
x=I()
#先手が上から何枚以上取れるか
ng=N//2 +1
ok=1#先手が最大値をとる
while ng-ok>1:
med=(ok+ng)//2
if ch(x,med):
ok=med
else:
ng=med
# print(ok)
print(calc(ok))
main()
|
p03158 | Python | #!/usr/bin/env python3
import sys
from typing import Any, Callable, Deque, Dict, List, Mapping, Optional, Sequence, Set, Tuple, TypeVar, Union
# import time
# import math, cmath
# import numpy as np
# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random # random, uniform, randint, randrange, shuffle, sample
# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import _heapify_max, _heappop_max, _siftdown_max
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from fractions import Fraction # Fraction(a, b) => a / b ∈ Q. note: Fraction(0.1) do not returns Fraciton(1, 10). Fraction('0.1') returns Fraction(1, 10)
def main():
Num = Union[int, float]
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79e+308
# inf = 2 ** 63 - 1 # (for fast JIT compile in PyPy) 9.22e+18
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def isp(): return input().split()
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
def debug(x): print(x, file=sys.stderr)
# def _heappush_max(h, item): h.append(item); _siftdown_max(h, 0, len(h)-1)
def calc_takahasi_top_n(x):
# takahashi がとるカードの左端 ind を求める -> 枚数は n - ind
left = -1 # これより上
right = n - 1 # これ以下
while right - left > 1:
mid = (left + right) // 2
# debug(f'{left} {right} {mid}')
# [n], [n-1], ..., [ind] ととっていく
takahashi_order = n - mid
# [x - (A[ind] - x), A[ind]] のカードは全てとっている
aoki_order = bisect_right(L, L[mid]) - bisect_left(L, x - (L[mid] - x))
if takahashi_order <= aoki_order:
# そのカードは takahashi のもの
right = mid
else:
left = mid
return n - right
def solve(x):
top_n = calc_takahasi_top_n(x)
res = max(0, n - top_n * 2)
# debug(f'top_n {top_n}')
# debug(f'res {res}')
return rev_acum[top_n] + skip_sum[res]
n, q = mi()
L = lmi()
query = [ii() for _ in range(q)]
rev_acum = [0] + list(reversed(L))
for i in range(n + 1):
if i > 0:
rev_acum[i] += rev_acum[i-1]
skip_sum = [0] + L[:]
for i in range(n + 1):
if i > 1:
skip_sum[i] += skip_sum[i-2]
# debug(rev_acum)
# debug(skip_sum)
for x in query:
print(solve(x))
if __name__ == "__main__":
main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.