p_id
stringlengths 6
6
| language
stringclasses 10
values | code
stringlengths 11
983k
|
|---|---|---|
p03158 | C++ | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <numeric>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <string>
#include <functional>
#include <list>
#include <random>
#include <time.h>
#include <iomanip>
#include <assert.h>
#include <numeric>
#define BIT(nr) (1UL << (nr))
#define int long long
//#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2+1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define FOR(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define mp make_pair
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; }
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = { 0, 1, 0, -1 }; // x軸方向への変位
int dy[4] = { 1, 0, -1, 0 }; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph& g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph& g, int a, int b, Weight w = 1) { g[a].emplace_back(a, b, w); }
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x]) std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
template <signed M, unsigned T>
struct mod_int {
constexpr static signed MODULO = M;
constexpr static unsigned TABLE_SIZE = T;
signed x;
mod_int() : x(0) {}
mod_int(long long y) : x(static_cast<signed>(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO)) {}
mod_int(signed y) : x(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO) {}
mod_int& operator+=(const mod_int& rhs) {
if ((x += rhs.x) >= MODULO) x -= MODULO;
return *this;
}
mod_int& operator-=(const mod_int& rhs) {
if ((x += MODULO - rhs.x) >= MODULO) x -= MODULO;
return *this;
}
mod_int& operator*=(const mod_int& rhs) {
x = static_cast<signed>(1LL * x * rhs.x % MODULO);
return *this;
}
mod_int& operator/=(const mod_int& rhs) {
x = static_cast<signed>((1LL * x * rhs.inv().x) % MODULO);
return *this;
}
mod_int operator-() const { return mod_int(-x); }
mod_int operator+(const mod_int& rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int& rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int& rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int& rhs) const { return mod_int(*this) /= rhs; }
bool operator<(const mod_int& rhs) const { return x < rhs.x; }
mod_int inv() const {
assert(x != 0);
if (x <= static_cast<signed>(TABLE_SIZE)) {
if (_inv[1].x == 0) prepare();
return _inv[x];
}
else {
signed a = x, b = MODULO, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mod_int(u);
}
}
mod_int pow(long long t) const {
assert(!(x == 0 && t == 0));
mod_int e = *this, res = mod_int(1);
for (; t; e *= e, t >>= 1)
if (t & 1) res *= e;
return res;
}
mod_int fact() {
if (_fact[0].x == 0) prepare();
return _fact[x];
}
mod_int inv_fact() {
if (_fact[0].x == 0) prepare();
return _inv_fact[x];
}
mod_int choose(mod_int y) {
assert(y.x <= x);
return this->fact() * y.inv_fact() * mod_int(x - y.x).inv_fact();
}
static mod_int _inv[TABLE_SIZE + 1];
static mod_int _fact[TABLE_SIZE + 1];
static mod_int _inv_fact[TABLE_SIZE + 1];
static void prepare() {
_inv[1] = 1;
for (int i = 2; i <= (int)TABLE_SIZE; ++i) {
_inv[i] = 1LL * _inv[MODULO % i].x * (MODULO - MODULO / i) % MODULO;
}
_fact[0] = 1;
for (unsigned i = 1; i <= TABLE_SIZE; ++i) {
_fact[i] = _fact[i - 1] * signed(i);
}
_inv_fact[TABLE_SIZE] = _fact[TABLE_SIZE].inv();
for (int i = (int)TABLE_SIZE - 1; i >= 0; --i) {
_inv_fact[i] = _inv_fact[i + 1] * (i + 1);
}
}
};
template <signed M, unsigned F>
std::ostream& operator<<(std::ostream& os, const mod_int<M, F>& rhs) {
return os << rhs.x;
}
template <signed M, unsigned F>
std::istream& operator >> (std::istream& is, mod_int<M, F>& rhs) {
long long s;
is >> s;
rhs = mod_int<M, F>(s);
return is;
}
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
bool operator==(const mod_int<M, F>& lhs, const mod_int<M, F>& rhs) {
return lhs.x == rhs.x;
}
template <int M, unsigned F>
bool operator!=(const mod_int<M, F>& lhs, const mod_int<M, F>& rhs) {
return !(lhs == rhs);
}
const signed MF = 1000010;
const signed MOD = 1000000007;
using mint = mod_int<MOD, MF>;
mint binom(int n, int r) { return (r < 0 || r > n || n < 0) ? 0 : mint(n).choose(r); }
mint fact(int n) { return mint(n).fact(); }
mint inv_fact(int n) { return mint(n).inv_fact(); }
//出典 http://beet-aizu.hatenablog.com/entry/2017/12/01/225955
/*
コンストラクタ引数説明
int n_
要素数。
f
2つの要素Tをマージするための関数。
区間MAX区間更新の時: max
区間Sum区間Addの時: +
g
1つの要素Tに作用素Eを適用するための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
h
2つの作用素Eをマージするための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
T d1
演算fの単位元。
区間MAX区間更新の時: -INF
区間Sum区間Addの時: 0
E d0,
g, hの単位元。
区間MAX区間更新の時: 定義域外のどこか
区間Sum区間Addの時: 0
vector<T> v = vector<T>()
セグ木を構成するときのvector
P p = [](E a, int b) {return a; }
区間の長さbを引数に取り、区間の長さによって変化する作用素E'を返す関数。
例えば、区間MAX区間Addの時なんかは区間長によって足すべき数が変化するので必要
区間Sum区間Addの時: *
//具体例
//区間chmin, 区間min
auto myMin = [](int a, int b) {return min(a, b); };
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間update、区間min
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
*/
template <typename T, typename E>
struct SegmentTree {
typedef function<T(T, T)> F;
typedef function<T(T, E)> G;
typedef function<E(E, E)> H;
typedef function<E(E, int)> P;
int n;
F f;
G g;
H h;
P p;
T d1;
E d0;
vector<T> dat;
vector<E> laz;
SegmentTree(int n_, F f, G g, H h, T d1, E d0,
vector<T> v = vector<T>(), P p = [](E a, int b) {return a; }) :
f(f), g(g), h(h), d1(d1), d0(d0), p(p) {
init(n_);
if (n_ == (int)v.size()) build(n_, v);
}
//初期化。要素配列と遅延配列を2*n-1個にする
void init(int n_) {
n = 1;
while (n < n_) n *= 2;
dat.clear();
dat.resize(2 * n - 1, d1);
laz.clear();
laz.resize(2 * n - 1, d0);
}
//既存のvectorからセグ木を構築
void build(int n_, vector<T> v) {
for (int i = 0; i < n_; i++) dat[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
//ノードを評価する。
inline void eval(int len, int k) {
//遅延配列に単位元が入ってたら評価済みなのでおしまい
if (laz[k] == d0) return;
//葉ノードでないなら遅延伝播する
if (k * 2 + 1 < n * 2 - 1) {
//h: 2つの作用素を引数に取り合成した作用素を返す関数
laz[k * 2 + 1] = h(laz[k * 2 + 1], laz[k]);
laz[k * 2 + 2] = h(laz[k * 2 + 2], laz[k]);
}
//p: このノードに対応する区間長と作用素を引数に取り、区間長に対応する作用素を返す関数
//dat[k] にlaz に溜めていた作用素を適用(g: 要素型と作用素型を引数に取り、要素に作用素を作用させた結果を返す関数、ここでの作用素とは区間Sum区間Addなら (+ 3) とか)
dat[k] = g(dat[k], p(laz[k], len));
//適用し終わったので遅延配列をクリア
laz[k] = d0;
}
//[l,r)の区間を再帰的に見ながら0-indexedの[a, b)を更新する
T update(int a, int b, E x, int k, int l, int r) {
//先に評価
eval(r - l, k);
//範囲外ならなにもしないでそのノードが持つ値を返す
if (r <= a || b <= l) return dat[k];
//完全被覆なら既に遅延配列に入っている作用素と追加したい作用素をマージした後にそれを要素に作用させた結果を返す、pは区間長に対応する作用素を得るための（ｒｙ
if (a <= l && r <= b) {
laz[k] = h(laz[k], x);
return g(dat[k], p(laz[k], r - l));
}
//完全被覆でも範囲外でもないなら(中途半端にかぶっているなら)完全被覆と範囲外の境界が見えるまで木を潜って変化後の値を得る
return dat[k] = f(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
}
T update(int a, int b, E x) {
return update(a, b, x, 0, 0, n);
}
T query(int a, int b, int k, int l, int r) {
eval(r - l, k);
//範囲外なら単位元を返す
if (r <= a || b <= l) return d1;
//完全被覆ならそのまま返す
if (a <= l && r <= b) return dat[k];
//一部被覆なら完全被覆と範囲外に分かれるまで木を潜る
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
//0-indexedで[a, b)の区間*を求める
T query(int a, int b) {
return query(a, b, 0, 0, n);
}
};
//座標圧縮
class compress {
public:
static const int MAP = 10000000;
map<int, int> zip;
int unzip[MAP];
compress(vector<int>& x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
}
};
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b) swap(a, b);
if (!b) break;
a %= b;
}
return a;
}
//https://ei1333.github.io/luzhiled/snippets/dp/cumulative-sum-2d.html
template< class T >
struct CumulativeSum2D {
vector< vector< T > > data;
CumulativeSum2D(int W, int H) : data(W + 1, vector< int >(H + 1, 0)) {}
void add(int x, int y, T z) {
++x, ++y;
if (x >= data.size() || y >= data[0].size()) return;
data[x][y] += z;
}
void build() {
for (int i = 1; i < data.size(); i++) {
for (int j = 1; j < data[i].size(); j++) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
}
T query(int sx, int sy, int gx, int gy) {
return (data[gx][gy] - data[sx][gy] - data[gx][sy] + data[sx][sy]);
}
};
//lib
int nC2(int n) {
return n * (n - 1) / 2;
}
class node {
public:
int depth;
int num;
node(int d, int n) {
depth = d;
num = n;
}
};
CumulativeSum2D<int> sumB(4001, 4001);
template< class T >
struct CumulativeSum {
vector< T > data;
CumulativeSum(int sz) : data(sz, 0) {};
void add(int k, T x) {
data[k] += x;
}
void build() {
for (int i = 1; i < data.size(); i++) {
data[i] += data[i - 1];
}
}
T query(int k) {
if (k < 0) return (0);
return (data[min(k, (int)data.size() - 1)]);
}
//[left, right]の和
T query(int left, int right) {
return query(right) - query(left - 1);
}
};
std::vector<bool> IsPrime;
void sieve(size_t max) {
if (max + 1 > IsPrime.size()) { // resizeで要素数が減らないように
IsPrime.resize(max + 1, true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for (size_t i = 2; i * i <= max; ++i) // 0からsqrt(max)まで調べる
if (IsPrime[i]) // iが素数ならば
for (size_t j = 2; i * j <= max; ++j) // (max以下の)iの倍数は
IsPrime[i * j] = false; // 素数ではない
}
vector< int64_t > divisor(int64_t n) {
vector< int64_t > ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// 汎用的な二分探索のテンプレ(めぐる式)
int binary_search(function<bool(int)> isOk, int ng, int ok) {
/* ok と ng のどちらが大きいかわからないことを考慮 */
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOk(mid)) ok = mid;
else ng = mid;
}
return ok;
}
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph& g, int s) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto& e : g[i]) es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto& e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
//更新がなくなったらおはり
if (!update) break;
//n回以上更新されてたら負閉路がある
if (i > n) {
negCycle = true;
break;
}
}
return std::make_pair(dist, !negCycle);
}
//ゴールを指定して、それまでのパスに負閉路がなかったらOK(これは嘘)
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph& g, int s, int d) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto& e : g[i]) es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0; i < n * 2; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto& e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
if (e.dst == d && i == n * 2 - 1) negCycle = true;
}
}
//更新がなくなったらおはり
if (!update) break;
}
return std::make_pair(dist, !negCycle);
}
//R[i] == S[i] を中心とした極大回文長 なるvector Rを返す
vector<int> Manachar(string S) {
int len = S.length();
vector<int> R(len);
int i = 0, j = 0;
while (i < S.size()) {
while (i - j >= 0 && i + j < S.size() && S[i - j] == S[i + j]) ++j;
R[i] = j;
int k = 1;
while (i - k >= 0 && i + k < S.size() && k + R[i - k] < j) R[i + k] = R[i - k], ++k;
i += k; j -= k;
}
return R;
}
std::vector<int> tsort(const Graph &g) {
int n = g.size(), k = 0;
std::vector<int> ord(n), in(n);
for (auto &es : g)
for (auto &e : es) in[e.dst]++;
std::queue<int> q;
//入次数0の点をキューに追加
for (int i = 0; i < n; ++i)
if (in[i] == 0) q.push(i);
while (q.size()) {
int v = q.front();
//Sから node n を削除する
q.pop();
//L に n を追加する
ord[k++] = v;
for (auto &e : g[v]) {
//選択した点から出てる辺を削除、0になったらキューに追加
if (--in[e.dst] == 0) {
q.push(e.dst);
}
}
}
return *std::max_element(in.begin(), in.end()) == 0 ? ord : std::vector<int>();
}
std::vector<Weight> dijkstra(const Graph &g, int s) {
const Weight INF = std::numeric_limits<Weight>::max() / 8;
using state = std::tuple<Weight, int>;
std::priority_queue<state> q;
std::vector<Weight> dist(g.size(), INF);
dist[s] = 0;
q.emplace(0, s);
while (q.size()) {
Weight d;
int v;
std::tie(d, v) = q.top();
q.pop();
d *= -1;
/* if(v == t) return d; */
if (dist[v] < d) continue;
for (auto &e : g[v]) {
if (dist[e.dst] > dist[v] + e.weight) {
dist[e.dst] = dist[v] + e.weight;
q.emplace(-dist[e.dst], e.dst);
}
}
}
return dist;
}
void solve(long long A, long long B) {
}
std::pair<std::vector<int>, std::vector<int>> prime_factor_decomp(int n) {
std::vector<int> p, e;
int m = n;
for (int i = 2; i * i <= n; i++) {
if (m % i != 0) continue;
int c = 0;
while (m % i == 0) c++, m /= i;
p.push_back(i);
e.push_back(c);
}
if (m > 1) {
p.push_back(m);
e.push_back(1);
}
return std::make_pair(p, e);
}
signed main() {
int N, Q;
cin >> N >> Q;
vector<int> A(N+1), X(Q), S(N+1, 0), Sdiv(N+1, 0);
REPS(i, N) {
cin >> A[i];
S[i] = S[i - 1] + A[i];
Sdiv[i] = A[i];
if (i - 2 > 0) Sdiv[i] += Sdiv[i - 2];
}
rep(i, Q) {
cin >> X[i];
}
rep(q, Q) {
//クエリにこたえる
//境界を二分探索するための判定関数、Akを高橋君が取る場合true, そうでない場合false(ただし、交互に取っていく部分のことは考えない)
auto isTakahashi = [&](int k) -> bool {
//Akが青木君のxより小さい場合境界にはなりえない
if (X[q] > A[k]) {
return false;
}
else {
int takahashi = N - k + 1;
//A[k] を青木君がとると仮定して特定座標範囲内のカードの枚数を数える
//2*xq - Ak なのは、Ak を青木君が取る時、x + ay = Ak.ここで、Ak とxから x- Ak を求めるには、2*x - Ak で、x-Ak が求まるから。
//ここで、x-Ak 以上となる最小のインデックスが求まり、青木君が取るカードの左端 、aoki には青木君が何番目にカードAk を取るのかが入る
int aoki = k - (lower_bound(A.begin(), A.begin() + N + 1, max(1LL, 2 * X[q] - A[k])) - A.begin()) + 1;
//高橋君がAkを先に取るならtrue, そうでなければfalse
if (takahashi > aoki) {
return false;
}
else {
return true;
}
}
};
//isTakahashi がTrue になる最小値を求める
int takahashi = binary_search(isTakahashi, 0, N);
int ans = S[N] - S[takahashi - 1];
//交互に取る範囲の先頭t_First は二人が取った枚数だけ右から取り除いたときの右端
int t_first = N - (N - takahashi + 1) * 2;
if (t_first > 0) ans += Sdiv[t_first];
cout<<ans<<"\n";
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[])
{
int n,q;
cin>>n>>q;
long long a[n];
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
reverse(a,a+n);
long long s[n+5]={},s2[n+5]={};
for (int i = 0; i < n; ++i)
{
s[i+1]=s[i]+a[i];
s2[i+1]=s2[i];
if (i%2==0)
{
s2[i+1]+=a[i];
}
}
vector<long long> memo,ans;
for (int i = 0; i < (n+1)/2-1; ++i)
{
long long tmp=(a[i+1]+a[2*(i+1)])/2LL+1LL,nans=s[i+1]+s2[n]-s2[2*(i+1)];
memo.push_back(tmp);
ans.push_back(nans);
}
reverse(memo.begin(), memo.end());
reverse(ans.begin(), ans.end());
for (int i = 0; i < q; ++i)
{
long long x;
cin>>x;
int tmp=upper_bound(memo.begin(), memo.end(),x)-memo.begin();
if (tmp==0)
{
cout<<s[(n+1)/2]<<endl;
}
else
{
cout<<ans[tmp-1]<<endl;
}
}
return 0;
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(a) (a).begin(),(a).end()
#define ALLR(a) (a).rbegin(),(a).rend()
#define spa << " " <<
#define lfs <<fixed<<setprecision(10)<<
#define test cout<<"test"<<endl;
#define fi first
#define se second
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define rep(i,n,m) for(ll i = n; i < (ll)(m); i++)
#define rrep(i,n,m) for(ll i = n - 1; i >= (ll)(m); i--)
using ll = long long;
using ld = long double;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const ll INF = 1e18;
using P = pair<ll, ll>;
template<typename T>
void chmin(T &a,T b){if(a>b)a=b;}
template<typename T>
void chmax(T &a,T b){if(a<b)a=b;}
void pmod(ll &a,ll b){a=(a+b)%MOD;}
void pmod(ll &a,ll b,ll c){a=(b+c)%MOD;}
void qmod(ll &a,ll b){a=(a*b)%MOD;}
void qmod(ll &a,ll b,ll c){a=(b*c)%MOD;}
ll median(ll a,ll b, ll c){return a+b+c-max({a,b,c})-min({a,b,c});}
void ans1(bool x){if(x) cout<<"Yes"<<endl;else cout<<"No"<<endl;}
void ans2(bool x){if(x) cout<<"YES"<<endl;else cout<<"NO"<<endl;}
void ans3(bool x){if(x) cout<<"Yay!"<<endl;else cout<<":("<<endl;}
template<typename T1,typename T2>
void ans(bool x,T1 y,T2 z){if(x)cout<<y<<endl;else cout<<z<<endl;}
template<typename T>
void debug(vector<vector<T>>v,ll h,ll w){for(ll i=0;i<h;i++)
{cout<<v[i][0];for(ll j=1;j<w;j++)cout spa v[i][j];cout<<endl;}};
void debug(vector<string>v,ll h,ll w){for(ll i=0;i<h;i++)
{for(ll j=0;j<w;j++)cout<<v[i][j];cout<<endl;}};
template<typename T>
void debug(vector<T>v,ll n){if(n!=0)cout<<v[0];
for(ll i=1;i<n;i++)cout spa v[i];cout<<endl;};
template<typename T>
vector<vector<T>>vec(ll x, ll y, T w){
vector<vector<T>>v(x,vector<T>(y,w));return v;}
ll gcd(ll x,ll y){ll r;while(y!=0&&(r=x%y)!=0){x=y;y=r;}return y==0?x:y;}
template<typename T>
vector<ll>dx={1,0,-1,0,1,1,-1,-1};
vector<ll>dy={0,1,0,-1,1,-1,1,-1};
template<typename T>
vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
template<typename... Ts>
auto make_v(size_t a,Ts... ts){
return vector<decltype(make_v(ts...))>(a,make_v(ts...));
}
int main(){
cin.tie(NULL);
ios_base::sync_with_stdio(false);
ll res=0,res1=INF,res2=-INF,buf=0;
bool judge = true;
ll n,q;cin>>n>>q;
vector<ll>a(n),b(n);
vector<P>x(q);
vector<ll>ret(q);
rep(i,0,n)cin>>a[i];
b[0]=a[0],b[1]=a[1];
rep(i,2,n)b[i]=b[i-2]+a[i];
rep(i,0,q){
cin>>x[i].fi;
x[i].se=i;
}
sort(ALLR(x));
ll limit=0,pt=0,sumbuf=0;
rep(i,1,n){
sumbuf+=a[n-i];
if(n-2*i-1<0)limit=0;
else limit=(a[n-i-1]+a[n-2*i-1])/2;
//cout<<i spa limit spa pt spa sumbuf<<endl;
while(pt<q&&x[pt].fi>limit){
ret[x[pt].se]=sumbuf;
if(n-2*i-1>=0)ret[x[pt].se]+=b[n-2*i-1];
pt++;
}
if(pt>=q)break;
}
rep(i,0,q)cout<<ret[i]<<endl;
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = 1ll<<30;
const ll longINF = 1ll<<60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
const bool debug = 0;
//---------------------------------//
int N, Q;
ll A[112345], sum[112345], ans[112345];
int X[112345];
int main() {
cin >> N >> Q;
REP(i, N) scanf("%lld", A + i);
REP(i, Q) scanf("%d", X + i);
sum[0] = A[0];
sum[1] = A[1];
FOR(i, 2, N) sum[i] = A[i] + sum[i - 2];
vector<pii> v;
REP(i, Q) v.push_back(pii(X[i], i));
sort(ALL(v));
int x = (N + 1) / 2;
ll cur = 0;
REP(i, x) cur += A[N - i - 1];
for (pii query : v) {
int q = query.fi;
int idx = lower_bound(A, A + N, q) - A; // 初めに青木くんが取るカード
if (idx > 0 && abs(A[idx] - q) >= abs(A[idx - 1] - q)) idx--;
while (x > 0) {
bool ok = true;
int l = max(N - 2 * x, 0); // [l, r) : Aoki
int r = N - x; // [r, N) : Takahashi
if (l > idx || r <= idx) ok = false;
if (2 * x - 1 == N) {
if (abs(A[l] - q) > abs(A[r] - q)) ok = false;
}
else {
if (abs(A[l + 1] - q) > abs(A[r] - q)) ok = false;
if (l > 1 && abs(A[l - 1] - q) <= abs(A[r - 1] - q)) ok = false;
}
if (ok) break;
cur -= A[N - x];
x--;
}
if (2 * x - 1 == N) ans[query.se] = cur;
else ans[query.se] = cur + sum[N - 2 * x - 1];
}
REP(i, Q) printf("%lld\n", ans[i]);
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 998244353
#define ll long long
using namespace std;
ll sum[114514],ev[114514];
signed main(){
int n,q;
cin>>n>>q;
vector<int> a;
for(int i=0;i<n;i++){
int x;
cin>>x;
a.pb(x);
}
if(n%2==1){ a.pb(-1); n++; }
sort(a.begin(),a.end());
vector<int> qry;
for(int i=0;i<q;i++){
int x;
cin>>x;
qry.pb(x);
}
for(int i=1;i<=n;i++){
sum[i] = sum[i-1] + a[i-1];
ev[i] = ev[i-1] + a[i-1] * ( (i-1) % 2 );
}
for(int i=0;i<=n;i++){
//cout<<i<<" "<<sum[i]<<" "<<ev[i]<<endl;
}
for(int k=0;k<q;k++){
int cx = qry[k];
int lef = 0, rig = n/2 + 1;
while(rig-lef>1){
int mid = (lef+rig)/2;
int tak = abs( a[n-mid] - cx );
int aok = abs( a[n-2*mid+1] -cx);
if( tak >= aok){
lef = mid;
}
else{
rig = mid;
}
}
ll ans = 0;
ans += ev[n-2*lef];
ans += sum[n]-sum[n-lef];
cout<<ans<<endl;
}
return 0;
} |
p03158 | C++ | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
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;
}
template <class C>
void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c), std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
int main() {
int n, q;
cin >> n >> q;
vl a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n % 2 == 1) {
a.push_back(-1000000000); // Aoki-kun takes this
n++;
}
sort(a.begin(), a.end(), greater<ll>());
vl x(q);
for (int i = 0; i < q; ++i) {
cin >> x[i];
}
vl psum(n);
psum[0] = a[0];
vl evensum(n);
evensum[0] = a[0];
for (int i = 1; i < n; ++i) {
psum[i] = psum[i - 1] + a[i];
evensum[i] = evensum[i - 1];
if (i % 2 == 0)
evensum[i] += a[i];
}
auto check = [&](int m, int iq) {
ll min_tak = a[m];
ll max_aok = a[m + 1];
ll min_aok = a[2 * m];
return abs(a[m] - x[iq]) >= abs(a[2 * m] - x[iq]) && abs(a[m] - x[iq]) >= abs(a[m + 1] - x[iq]);
};
for (int i = 0; i < q; ++i) {
int ok = 0, ng = n / 2;
while (ok + 1 != ng) {
int mid = (ok + ng) / 2;
if (check(mid, i))
ok = mid;
else
ng = mid;
}
ll ret = psum[ok] + evensum[n - 1] - evensum[2 * ok];
cout << ret << "\n";
}
return 0;
} |
p03158 | C++ | #pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace::std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
// #include <boost/multiprecision/cpp_dec_float.hpp>
// #include <boost/multiprecision/cpp_int.hpp>
// #include <boost/numeric/interval.hpp>
// #include <boost/numeric/interval/io.hpp>
// #include <boost/intrusive/rbtree.hpp>
// #include <boost/geometry.hpp>
// #include <boost/geometry/geometries/linestring.hpp>
// #include <boost/geometry/geometries/polygon.hpp>
// #include <boost/geometry/geometries/point_xy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds;
using namespace::std;
// namespace mp = boost::multiprecision;
// typedef mp::number<mp::cpp_dec_float<0>> cfloat;
// typedef mp::cpp_int cint;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
typedef vector<pair<lint,lint>> pvec;
typedef vector<vector<pair<lint,lint>>> pmat;
typedef vector<vector<vector<pair<lint,lint>>>> pmat3;
#define rep(i, n) for(lint i = 0; i < (lint)(n); i++)
#define irep(i) for(lint i = 0;; i++)
#define irep1(i) for(lint i = 1;; i++)
#define irep2(i) for(lint i = 2;; i++)
#define rrep(i, n) for(lint i = (lint)(n-1); i >-1; i--)
#define rrepi(i,a,b) for(lint i = (lint)(b-1); i >a-1; i--)
#define repi(i,a,b) for(lint i=lint(a);i<lint(b);i++)
#define rep2(i,a,b,c) for(lint i=lint(a);i>lint(b);i+=c)
#define all(x) (x).begin(),(x).end()
#define PI 3.141592653589793
#define dist(x1,y1,x2,y2) (pow(pow(x2-x1,2)+pow(y2-y1,2),0.5))
#define output(v) do{bool f=0;for(auto i:v){cout<<(f?" ":"");if(i>INF/2)cout<<"INF";else cout<<i;f=1;}cout<<"\n";}while(0)
#define output2(v) for(auto j:v)output(j);
#define input(a,n) lint n;cin>>n;vector<lint>a(n);rep(i,n)cin>>a[i];
#define SUM(v) accumulate(all(v),0LL)
#define INF (1LL<<60)
#define IINF (1<<30)
#define EPS (1e-10)
#define LINF 9223372036854775807
#define MOD 1000000007
#define endl "\n"
template<typename T=lint>T in(){return *istream_iterator<T>(cin);}
inline lint gcd(lint a,lint b){return b?gcd(b,a%b):a;}
inline lint lcm(lint a,lint b){return a*b/gcd(a,b);}
inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
vector<lint> dx={-1,1,0,0,1,1,-1,-1};
vector<lint> dy={0,0,-1,1,1,-1,1,-1};
lint bs(lint mn=0,lint mx=INF,function<bool(lint)> func=[](lint x){return true;}) {
lint left = mn-1;
lint right =mx;
while (right - left > 1) {
lint mid = left + (right - left) / 2;
if (func(mid)) right = mid;
else left = mid;
}
return right;
}
int main(){
lint n,q;
cin>>n>>q;
vec a(n);
rep(i,n)cin>>a[i];
reverse(all(a));
vec b(n/2+1),c(n-n/2+1),d(n+1);
b[0]=0;c[0]=0;d[0]=0;
rep(i,n/2)b[i+1]=b[i]+a[2*i+1];
rep(i,n-n/2)c[i+1]=c[i]+a[2*i];
rep(i,n)d[i+1]=d[i]+a[i];
rep(i,q){
lint x;
cin>>x;
lint tmp=bs(0,n,[&](lint y){
if(2*y>=n)return true;
return abs(a[y]-x)<abs(a[2*y]-x);
});
cout<<d[tmp]+c[n-n/2]-c[tmp]<<endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define fi first
#define se second
#define mp make_pair
#define itrfor(itr,A) for(auto itr = A.begin(); itr !=A.end();itr++)
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
typedef long long llong;
char moji[26]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
char moji2[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
char moji3[10]={'0','1','2','3','4','5','6','7','8','9'};
#define Sort(a) sort(a.begin(),a.end());
#define Reverse(a) reverse(a.begin(),a.end());
#define print(a) cout << a << endl;
#define MOD llong(1e9+7)
#define MAX int(2 * 1e5 +5)
#define debug(x) cout << #x << " = " << (x) << endl;
#define pi acos(-1.0)
#define int llong
#define INF llong(1e17)
template<class T> bool chmax(T &a, T b) {if(a<b){a=b; return 1;} return 0;}
template<class T> bool chmin(T &a, T b) {if(a>b){a=b; return 1;} return 0;}
bool Add(int &a,int b){a = (a + b) % MOD;}
void myprint(int* A,int A_num){
REP(i,A_num) cout << A[i] << " ";
cout << endl;
}
signed main(){
int n,q;
cin >> n >> q;
int A[n];
REP(i,n) cin >> A[i];
int ruiseki[n + 1],gu[n+1],ki[n + 1];
ruiseki[0] = 0;
REP(i,n) ruiseki[i+1] = ruiseki[i] + A[i];
gu[0] = 0;
ki[0] = 0;
REP(i,n){
gu[i + 1] = gu[i];
ki[i + 1] = ki[i];
if(i %2 == 0) gu[i + 1] += A[i];
else ki[i + 1] += A[i];
}
REP(i,q){
int x;
cin >> x;
int l = 0;
int r = n / 2 ;
if(n %2 == 1) r ++;
while(l + 1 < r){
int mid = ( l + r) / 2;
if( A[n - 1 -mid] - x >= x - A[n-1 - mid * 2 ] ) l = mid;
else r = mid;
}
int res = 0;
res = ruiseki[n] - ruiseki[n - r];
if(n %2 == 1){
res += gu[ max(llong(0),n - 2 * r)];
}
else{
res += ki[n - 2 * r];
}
cout << res << endl;
}
} |
p03158 | C++ | #include<algorithm> // sort,reverse,min,lower_bound
#include<iostream>
#include<vector>
#include<numeric> //iota
using namespace std;
#define df 0
typedef long int li;
int main(){
if(df) printf("*debug mode*\n");
int n,q; cin >>n >>q;
li a[n];
for(int i=0,len=n/2;i<len;i++){
cin >>a[i];
}
li large=0,j=(n+1)%2;
vector<li> v;
for(int i=n/2;i<n;i++){
cin >>a[i];
large+=a[i];
v.push_back((a[j]+a[i])/2+1);
j+=2;
}
v.pop_back();
li x[q];
for(int i=0;i<q;i++){
cin >>x[i];
}
int idx[q];
iota(idx,idx+q,0);
sort(idx,idx+q,[&x](const int& a, const int& b){return x[a]<x[b];});
if(df){
printf("large:%ld\nv:",large);
for(const li& p: v){
printf("%ld ",p);
}
printf("\nidx:");
for(const int& p: idx){
printf("%d ",p);
}
printf("\n");
}
li ans[q],small=0;
j=(n+1)%2;
for(int i=0;i<q;i++){
while(j<n && v[j/2]<=x[idx[i]]){
large-=a[(n+j)/2];
small+=a[j];
j+=2;
if(df)printf("(%ld,%ld) ",large,small);
}
ans[idx[i]]=large+small;
}
for(li p: ans){
printf("%ld\n",p);
}
}
/// confirm df==0 /// |
p03158 | C++ | ///////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <iomanip>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <typeinfo>
#include <numeric>
#include <cassert>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
///////////////////////////////////////////////////////////////////////////////
#define DEBUG 0
#define pb push_back
#define V vector
#define M unordered_map
#define rep(i,n) for(ll i=0LL;i<n;++i)
#define srep(i,s,n) for(ll i=s;i<n;++i)
#define rrep(i,n) for(ll i=n-1LL;i>=0LL;--i)
#define ALL(a) (a).begin(),(a).end()
#define CIN(x) do { \
assert(!cin.eof()); \
cin >> x; \
assert(!cin.fail()); \
} while(0);
#if DEBUG
#define debug_print(...) _debug_print(__VA_ARGS__)
#define debug_printf(...) printf(__VA_ARGS__)
#else // DEBUG
#define debug_print(...)
#define debug_printf(...)
#endif // DEBUG
typedef long long ll;
typedef unsigned long long ull;
typedef tuple<ll, ll> t2;
typedef tuple<ll, ll, ll> t3;
typedef tuple<ll, ll, ll, ll> t4;
typedef tuple<ll, ll, ll, ll, ll> t5;
template <typename T>
using priority_queue_incr = priority_queue<T, V<T>, greater<T>>;
template <typename S, typename T>
T get_m(M<S, T> &m, S k, S default_value)
{
if (m.find(k) == m.end()) return m[k] = default_value;
return m[k];
}
struct UnionFind
{
ull *parent, *count, *rank;
UnionFind(ull n) {
parent = new ull[n+1];
count = new ull[n+1];
rank = new ull[n+1];
for (ull i = 0ULL; i < n+1; ++i) {
parent[i] = i;
count[i] = 1;
rank[i] = 0;
}
}
~UnionFind() {
delete rank;
delete count;
delete parent;
}
ull root(ull i) {
if (parent[i] == i) return i;
parent[i] = root(parent[i]);
return parent[i];
}
void unite(ull i, ull j) {
ull rooti = root(i);
ull rootj = root(j);
if (rooti == rootj) return;
if (rank[rootj] < rank[rooti]) {
parent[i] = parent[j] = parent[rootj] = rooti;
count[rooti] += count[rootj];
}
else {
parent[i] = parent[j] = parent[rooti] = rootj;
count[rootj] += count[rooti];
if (rank[rootj] == rank[rooti]) rank[rootj]++;
}
}
bool same(ull i, ull j) {
return root(i) == root(j);
}
};
struct UnionFindM
{
M<ull, ull> parent, count, rank;
ull root(ull i) {
ull parent_i = get_m(parent, i, i);
if (parent_i == i) return i;
return parent[i] = root(parent_i);
}
void unite(ull i, ull j) {
ull rooti = root(i);
ull rootj = root(j);
if (rooti == rootj) return;
if (get_m(rank, rootj, 0ULL) < get_m(rank, rooti, 0ULL)) {
parent[i] = parent[j] = parent[rootj] = rooti;
count[rooti] = get_m(count, rooti, 1ULL) + get_m(count, rootj, 1ULL);
}
else {
parent[i] = parent[j] = parent[rooti] = rootj;
count[rootj] = get_m(count, rootj, 1ULL) + get_m(count, rooti, 1ULL);
if (get_m(rank, rootj, 0ULL) == get_m(rank, rooti, 0ULL)) rank[rootj]++;
}
}
bool same(ull i, ull j) {
return root(i) == root(j);
}
};
struct BIT
{
ll *tree;
ll size;
BIT(ll n, ll init) {
tree = new ll[n+1];
size = n;
memset(tree, 0, sizeof(ll) * (n+1));
this->init(init);
}
void init(ll init) {
rep (i0, size) {
ll idx = i0 + 1LL;
while (idx <= size) {
tree[idx] += init;
idx += (idx & (-idx));
}
}
}
// idx is 1 origin
void add(ll idx, ll x) {
assert(idx > 0LL);
while (idx <= size) {
tree[idx] += x;
idx += (idx & (-idx));
}
}
// idx is 1 origin
ll sum(ll idx) {
assert(idx > 0LL);
ll ret = 0LL;
while (idx > 0LL) {
ret += tree[idx];
idx -= (idx & (-idx));
}
return ret;
}
};
struct MaxFlow {
V<ll> links[1005];
ll capacities[1005][1005];
ll nodes;
MaxFlow(ll nodes) {
// i == 0 --> S
// i == nodes+1 --> T
rep (i, nodes+2LL) links[i].clear();
memset(capacities, 0, sizeof(capacities));
this->nodes = nodes;
}
void add_path(ll a, ll b, ll capacity) {
links[a].pb(b);
links[b].pb(a);
capacities[a][b] = capacity;
capacities[b][a] = 0LL;
}
ll solve(void) {
deque<V<ll>> q;
ll ret = 0LL;
for ( ; ; q.clear()) {
V<ll> start;
start.pb(0);
q.push_front(start);
bool checked[nodes+2];
memset(checked, 0, sizeof(checked));
V<ll> found;
for ( ; !(q.empty()); ) {
V<ll> path = q.front(); q.pop_front();
ll last = path[path.size()-1];
if (checked[last]) continue;
if (last == nodes+1) {
found = path;
break;
}
checked[last] = true;
for (auto next : (links[last])) {
if (capacities[last][next] == 0) continue;
V<ll> newpath(path);
newpath.pb(next);
q.push_front(newpath);
}
}
if (found.size() == 0) {
break;
}
else {
ll flowcount = capacities[found[0]][found[1]];
rep (i, found.size()-1) {
ll src = found[i];
ll dst = found[i+1];
flowcount = min(flowcount, capacities[src][dst]);
}
rep (i, found.size()-1) {
ll src = found[i];
ll dst = found[i+1];
capacities[src][dst] -= flowcount;
capacities[dst][src] += flowcount;
}
ret += flowcount;
}
}
return ret;
}
};
template <typename T>
struct SegmentTree {
T *nodes;
t2 *ranges; // [start, end)
ll nodecount;
ll itemcount;
T unit;
T (*op)(T, T);
SegmentTree(ll itemcount, T unit, T op(T, T)) {
ll orig_itemcount = itemcount;
this->itemcount = 1LL;
while (this->itemcount < orig_itemcount) this->itemcount *= 2LL;
nodecount = this->itemcount * 2 - 1;
nodes = new T[nodecount];
ranges = new t2[nodecount];
this->unit = unit;
this->op = op;
ll start = 0LL;
ll end = this->itemcount;
ll len = this->itemcount;
rep (i, nodecount) {
nodes[i] = unit;
ranges[i] = t2(start, end);
if (end >= this->itemcount) {
len /= 2LL;
start = 0LL;
end = len;
}
else {
start = end;
end = start + len;
}
}
}
void update(ll k, T v) {
ll idx = k + itemcount - 1LL;
nodes[idx] = v;
idx = (idx - 1LL) / 2LL;
for ( ; idx >= 0; idx = (idx - 1LL) / 2LL) {
nodes[idx] = op(nodes[idx * 2LL + 1LL],
nodes[idx * 2LL + 2LL]);
if (!idx) break;
}
}
T query(ll start, ll end) const {
return _query(start, end, 0LL);
}
T _query(ll start, ll end, ll idx) const {
ll rstart = get<0>(ranges[idx]);
ll rend = get<1>(ranges[idx]);
if (start <= rstart && rend <= end) {
return nodes[idx];
}
if (rend <= start || end <= rstart) {
return unit;
}
T left = _query(start, end, idx * 2LL + 1LL);
T right = _query(start, end, idx * 2LL + 2LL);
return op(left, right);
}
};
void llin(ll &a)
{
CIN(a);
}
void llinl1(auto &v, ll count)
{
for (ll i = 0LL; i < count ; ++i) {
ll a;
CIN(a);
v.push_back(a);
}
}
void llinl2(auto &v, ll count)
{
for (ll i = 0LL; i < count ; ++i) {
ll a, b;
CIN(a >> b);
v.push_back(t2(a, b));
}
}
void llinl3(auto &v, ll count)
{
for (ll i = 0LL; i < count ; ++i) {
ll a, b, c;
CIN(a >> b >> c);
v.push_back(t3(a, b, c));
}
}
void llinl4(auto &v, ll count)
{
for (ll i = 0LL; i < count ; ++i) {
ll a, b, c, d;
CIN(a >> b >> c >> d);
v.push_back(t4(a, b, c, d));
}
}
void llina(auto &v, ll count)
{
llinl1(v, count);
}
template <typename T>
T min(const V<T> v)
{
T ret = v[0];
for (auto i : v) ret = min(ret, i);
return ret;
}
template <typename T>
T max(const V<T> v)
{
T ret = v[0];
for (auto i : v) ret = max(ret, i);
return ret;
}
ll absll(ll x)
{
if (x < 0) return -x;
return x;
}
ll mod_mlt(ll x, ll y, ll mod)
{
ll ret = 0LL;
x %= mod;
while (y) {
if (y & 1LL) {
ret += x;
ret %= mod;
}
y >>= 1;
x <<= 1;
x %= mod;
}
return ret;
}
// O(log(exp))
ll mod_pow(ll base, ll exp, ll mod)
{
ll ret = 1LL;
for ( ; exp; ) {
if (exp & 1LL) {
ret *= base;
ret %= mod;
}
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
// O(log(mod))
ll mod_inv(ll x, ll mod)
{
// available only when mod is prime
return mod_pow(x, mod - 2LL, mod);
}
ll gcm(ll x, ll y)
{
while (y != 0) {
ll z = x % y;
x = y;
y = z;
}
return x;
}
template <typename T>
void sort(V<T> &v)
{
sort(v.begin(), v.end());
}
template <typename T>
void sort_reverse(V<T> &v)
{
sort(v.begin(), v.end(), greater<T>());
}
void get_divisors(V<ll> &retlist, ll x)
{
for (ll i = 1LL; i < sqrt(x) + 3LL; ++i) {
if (x % i == 0LL) {
retlist.push_back(i);
retlist.push_back(x / i);
}
}
}
void get_factors(V<ll> &retlist, ll x)
{
for (ll i = 2LL; i < (ll)(sqrt(x)) + 3LL; ++i) {
while (x % i == 0LL) {
retlist.pb(i);
x /= i;
}
}
retlist.pb(x);
}
bool is_prime(ll x)
{
V<ll> factors, factors2;
get_factors(factors, x);
for (auto factor : factors) {
if (factor > 1) factors2.pb(factor);
}
return factors2.size() == 1 && x == factors2[0];
}
template <typename T>
void intersection(const set<T> &a, const set<T> &b,
set<T> &result)
{
set_intersection(ALL(a), ALL(b), inserter(result, result.end()));
}
ull combination(ll x, ll y)
{
if (y > x / 2LL) y = x - y;
ull ret = 1LL;
for (ll i = 0LL; i < y; ++i) {
ret *= x--;
ret /= (i + 1LL);
}
return ret;
}
ull mod_combination(ll x, ll y, ll mod)
{
if (y > x / 2LL) y = x - y;
ll ret = 1;
for (ll i = 0LL; i < y; ++i) {
ret = (ret * x--) % mod;
ret = (ret * mod_inv(i + 1LL, mod)) % mod;
}
return ret;
}
void make_linklist(const V<t2> &srclist, V<ll> dstlist[])
{
for (auto src : srclist) {
ll a = get<0>(src);
ll b = get<1>(src);
dstlist[a].pb(b);
dstlist[b].pb(a);
}
}
void make_parental_relation(const V<ll> linklist[], ll root, ll n,
ll parent[], V<ll> children[], ll level[])
{
queue<ll> q;
bool checked[n+1];
memset(checked, 0, sizeof(checked));
q.push(root);
checked[root] = true;
parent[root] = root;
level[root] = 0LL;
for ( ; !(q.empty()); ) {
ll now = q.front(); q.pop();
for (auto next : linklist[now]) {
if (checked[next]) continue;
q.push(next);
checked[next] = true;
parent[next] = now;
children[now].pb(next);
level[next] = level[now] + 1LL;
}
}
}
void make_subtree_sizes(const ll child_count[], const ll parents[],
ll subtree_sizes[], ll n)
{
ll remain_count[n+1LL];
memcpy(remain_count, child_count, sizeof(remain_count));
queue<ll> q;
srep (node, 1LL, n+1LL) {
subtree_sizes[node] = 1LL;
if (remain_count[node] > 0) continue;
q.push(node);
}
while (!q.empty()) {
ll node = q.front(); q.pop();
ll parent = parents[node];
if (node == parent) continue;
remain_count[parent]--;
subtree_sizes[parent] += subtree_sizes[node];
if (remain_count[parent] == 0LL) q.push(parent);
}
}
void get_centroids(const V<ll> children[], const ll subtree_sizes[],
ll root, ll n, V<ll> ¢roids)
{
queue<ll> q;
q.push(root);
while (!q.empty()) {
ll now = q.front(); q.pop();
bool is_centroid = true;
for (auto child : children[now]) {
q.push(child);
if (subtree_sizes[child] > n / 2LL) is_centroid = false;
}
if (n - subtree_sizes[now] > n / 2LL) is_centroid = false;
if (is_centroid) centroids.pb(now);
}
assert(centroids.size() == 1LL || centroids.size() == 2LL);
}
#define POW_ANCESTOR_MAXSIZE 20
// preprocess for get_common_ancestor()
void make_pow_ancestor(const ll parent[], ll n,
ll (*pow_ancestor)[POW_ANCESTOR_MAXSIZE])
{
rep (i, n) pow_ancestor[i+1][0] = parent[i+1];
for (int pow2 = 1; pow(2, pow2) <= n; ++pow2) {
rep (i0, n) {
int i = i0+1;
ll prev = pow_ancestor[i][pow2-1];
pow_ancestor[i][pow2] = pow_ancestor[prev][pow2-1];
}
}
}
ll get_common_ancestor(ll n, ll x, ll y,
const ll (*pow_ancestor)[POW_ANCESTOR_MAXSIZE],
const ll level[])
{
if (level[x] < level[y]) {
ll diff = level[y] - level[x];
for ( ; diff; ) {
ll bit = diff & -diff;
y = pow_ancestor[y][(int)log2(bit)];
diff -= bit;
}
}
else {
ll diff = level[x] - level[y];
for ( ; diff; ) {
ll bit = diff & -diff;
x = pow_ancestor[x][(int)log2(bit)];
diff -= bit;
}
}
if (x == y) return x;
rrep (i, (int)log2(n)+1) {
if (pow_ancestor[x][i] != pow_ancestor[y][i]) {
x = pow_ancestor[x][i];
y = pow_ancestor[y][i];
}
}
return pow_ancestor[x][0];
}
void kmp_init(const string &pattern, ll kmp_next[])
{
kmp_next[0] = -1LL;
ll plen = pattern.size();
ll prefix_end = -1;
rep (suffix_end, pattern.size()) {
while (prefix_end >= 0 && pattern[suffix_end] != pattern[prefix_end]) {
prefix_end = kmp_next[prefix_end];
}
kmp_next[suffix_end+1] = ++prefix_end;
}
kmp_next[0] = 0LL;
}
// founds ... list of text's idx of match position. start position idx.
void kmp_search(const string &text, const string &pattern, const ll kmp_next[],
V<ll> &founds)
{
ll text_size = text.size();
ll pattern_size = pattern.size();
ll text_start = 0LL;
ll pattern_idx = 0LL;
assert(pattern_size <= text_size);
for ( ; ; ) {
if (text_start + pattern_idx >= text_size) break;
if (pattern_idx >= pattern_size) break;
if (text[text_start+pattern_idx] == pattern[pattern_idx]) {
pattern_idx++;
if (pattern_idx == pattern_size) {
founds.pb(text_start);
pattern_idx = kmp_next[pattern_idx];
text_start += (pattern_size - pattern_idx);
}
}
else {
text_start += (pattern_idx - kmp_next[pattern_idx]);
pattern_idx = kmp_next[pattern_idx];
if (pattern_idx == 0LL && text[text_start] != pattern[0]) {
text_start++;
}
}
}
}
void _debug_print(auto x)
{
cout << x << endl;
}
void _debug_print(const t2 &x)
{
ll x1 = get<0>(x);
ll x2 = get<1>(x);
cout << "-- " << x1 << " -- " << x2 << endl;
}
void _debug_print(const t3 &x)
{
ll x1 = get<0>(x);
ll x2 = get<1>(x);
ll x3 = get<2>(x);
cout << "-- " << x1 << " -- " << x2 << " -- " << x3 << endl;
}
void _debug_print(const t4 &x)
{
ll x1 = get<0>(x);
ll x2 = get<1>(x);
ll x3 = get<2>(x);
ll x4 = get<3>(x);
cout << "-- " << x1 << " -- " << x2
<< " -- " << x3 << " -- " << x4 << endl;
}
template <typename T>
void _debug_print(T xarray[], ll n)
{
rep (i, n) _debug_print(xarray[i]);
}
template <typename T>
void _debug_print(const V<T> &xlist)
{
for (auto x : xlist) {
cout << "-- ";
_debug_print(x);
}
}
template <typename T>
void _debug_print(const set<T> &xset)
{
for (auto x : xset) {
cout << "-- ";
_debug_print(x);
}
}
template <typename S, typename T>
void _debug_print(const M<S, T> &xlist)
{
for (auto x : xlist) {
S k = x.first;
T v = x.second;
cout << "====" << endl;
cout << "K=";
_debug_print(k);
cout << "V=";
_debug_print(v);
}
}
int _main();
int main()
{
cout << setprecision(12);
return _main();
}
///////////////////////////////////////////////////////////////////////////////
void make_borders(V<ll> &borders, const V<ll> &alist, ll n)
{
ll left = ((n & 1LL) ? 0LL : 1LL);
ll right = n / 2LL;
for ( ; left < right && right < n; left += 2LL, right += 1LL) {
ll center = (alist[left] + alist[right]) / 2LL;
borders.pb(center + 1LL);
}
debug_printf("---- borders\n"); debug_print(borders);
}
void make_leftsum(V<ll> &leftsum, const V<ll> &alist, ll n)
{
ll sum = 0LL;
ll idx = ((n & 1LL) ? 0LL : 1LL);
leftsum.pb(sum);
for ( ; idx < n; idx += 2LL) {
sum += alist[idx];
leftsum.pb(sum);
}
debug_printf("---- leftsum\n"); debug_print(leftsum);
}
void make_rightsum(V<ll> &rightsum, const V<ll> &alist, ll n)
{
ll sum = 0LL;
rightsum.pb(sum);
rrep (idx, n) {
sum += alist[idx];
rightsum.pb(sum);
if (idx <= n/2LL) break;
}
reverse(ALL(rightsum));
debug_printf("---- rightsum\n"); debug_print(rightsum);
}
int _main()
{
ll n; llin(n);
ll qcount; llin(qcount);
V<ll> alist; llina(alist, n);
V<ll> xlist; llinl1(xlist, qcount);
V<ll> borders;
make_borders(borders, alist, n);
V<ll> leftsum;
make_leftsum(leftsum, alist, n);
V<ll> rightsum;
make_rightsum(rightsum, alist, n);
for (auto x : xlist) {
auto iter = upper_bound(ALL(borders), x);
ll idx = iter - borders.begin();
cout << leftsum[idx] + rightsum[idx] << endl;
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
|
p03158 | C++ | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#include <cstring>
#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define all(c) begin(c),end(c)
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; }
//改造
typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
using Int = long long int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 //デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007
//ここから編集する
class Solve {
public:
Int N, Q;
vector<Int> A;
vector<Int> rui;
vector<Int> odd_rui;
vector<Int> even_rui;
Int aokiR(Int x) {
//upper_bound(x) - 1を0としておく
Int lb = upper_bound(all(A), x) - A.begin() - 1;
Int ub = N;
while (ub - lb > 1) {
Int mid = (lb + ub) / 2;
// midを取るのは何ターン目?
Int val_m = A[mid];
Int lval = x - (A[mid] - x);
Int lpt = lower_bound(all(A), lval) - A.begin();
Int turn = mid - lpt + 1;
if (mid < N - turn) {
lb = mid;
} else {
ub = mid;
}
}
if (lb == N - 1) {
return lb - 1;
}
return lb;
}
Int aokiL(Int x) {
Int ub = upper_bound(all(A), x) - A.begin();
Int lb = -1;
while (ub - lb > 1) {
Int mid = (lb + ub) / 2;
Int val_m = A[mid];
Int rval = x + (x - A[mid]);
Int rpt = lower_bound(all(A), rval) - A.begin() - 1;
Int turn = rpt - mid + 1;
if (rpt < N - turn) {
ub = mid;
} else {
lb = mid;
}
}
return ub;
}
Int query(Int x) {
Int aL = aokiL(x);
Int aR = aokiR(x);
Int ans;
if (aL > aR) {
if ((N - 1) % 2 == 0) {
ans = even_rui[N - 1];
} else {
ans = odd_rui[N - 1];
}
return ans;
}
Int tL = aR + 1;
Int tR = N - 1;
aL = aR - (tR - tL + 1) + 1;
ans = rui[tR];
if (aR >= 0) ans -= rui[aR];
if ((aL - 1) >= 0) {
if ((aL - 1) % 2 == 0) {
ans += even_rui[aL - 1];
} else {
ans += odd_rui[aL - 1];
}
}
return ans;
}
void solve() {
cin >> N >> Q;
A.resize(N);
rui.resize(N);
odd_rui.resize(N);
even_rui.resize(N);
vector<Int> X(Q);
for (int i = 0; i < N; ++i) {
cin >> A[i];
if (i == 0) {
rui[i] = A[i];
even_rui[i] = A[i];
} else if (i == 1) {
rui[i] = rui[i - 1] + A[i];
odd_rui[i] = A[i];
} else if (i % 2 == 0) {
rui[i] = rui[i - 1] + A[i];
even_rui[i] = even_rui[i - 2] + A[i];
} else {
rui[i] = rui[i - 1] + A[i];
odd_rui[i] = odd_rui[i - 2] + A[i];
}
}
for (int i = 0; i < Q; ++i) {
cin >> X[i];
}
for (auto x : X) {
Int ans = query(x);
cout << ans << endl;
}
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Solve().solve();
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
using namespace std;
typedef long long int ll;
ll cnt[100100];
ll cnt2[100100];
int main(){
int n,q; cin >> n >> q;
vector<ll> a(n);
for(int i=0;i<n;i++){
cin >> a[i];
cnt[i+1]=a[i]+cnt[i];
}
cnt2[0]=a[0];
cnt2[1]=a[1];
for(int i=2;i<n;i++){
cnt2[i]=a[i]+cnt2[i-2];
}
for(int i=0;i<q;i++){
ll x; cin >> x;
int l=0,r=n;
while(r-l>1){
int mid=(l+r)/2;
if(n-2*mid+1<0||n-mid<0){
r=mid;
continue;
}
ll L=a[n-2*mid+1]; ll R=a[n-mid];
if(abs(L-x)<=abs(R-x)){
l=mid;
}
else{
r=mid;
}
}
ll ans=0;
if(n-2*l-1>=0)ans+=cnt2[n-2*l-1];
cout << ans+cnt[n]-cnt[n-l] << endl;
}
} |
p03158 | C++ | #include"bits/stdc++.h"
using namespace std;
#define REP(k,m,n) for(int (k)=(m);(k)<(n);(k)++)
#define rep(i,n) REP((i),0,(n))
using ll = long long;
bool isover(const vector<ll>& A, ll center, ll range) {
const ll N = A.size();
auto itrl = lower_bound(A.begin(), A.end(), center - range);
auto itrr = upper_bound(A.begin(), A.end(), center + range);
//if (itrr == A.begin())return false;// bug注意
ll l = itrl - A.begin();
ll r = (ll)(itrr - A.begin()) - 1;
ll aoki = r - l + 1;
ll takahasi = N - (r + 1);
return aoki >= takahasi - 1; // ?
}
int main()
{
ll N, Q;
cin >> N >> Q;
vector<ll> A(N), X(Q), imos, cross(N);
rep(i, N)cin >> A[i];
rep(i, Q)cin >> X[i];
imos = A;
rep(i, N - 1)imos[i + 1] += imos[i];
rep(i, N) {
if (N % 2 == 0) {
if (i % 2 == 1)cross[i] += A[i];
}
else {
if (i % 2 == 0)cross[i] += A[i];
}
}
rep(i, N - 1)cross[i + 1] += cross[i];
for (auto x : X) {
ll xl = -1, xr = A.back();
while (xr - xl > 1) {
ll mid = (xl + xr) / 2;
(isover(A, x, mid) ? xr : xl) = mid;
}
ll l = lower_bound(A.begin(), A.end(), x - xr) - A.begin();
ll r = (ll)(upper_bound(A.begin(), A.end(), x + xr) - A.begin()) - 1;
if (r - l == N - 1 - r)r--;
ll res = l == 0 ? 0 : cross[l - 1];
res += imos.back() - imos[r];
cout << res << endl;
}
return 0;
}
|
p03158 | C++ | #include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <algorithm>
#include <cstdlib>
#include <map>
#include <queue>
#include <utility>
#include <vector>
#include <set>
#include <memory.h>
#include <iomanip>
#include <bitset>
#include <list>
#include <stack>
#include <deque>
#include <numeric>
using namespace std;
#define mod 1000000007
int n;
long long int a[100001];
long long int sum[100001];
long long int sum_alternate[100001];
bool ok(int x, int range)
{
int i1 = lower_bound(a, a + n, x - range) - a;
int i2 = upper_bound(a, a + n, x + range) - a;
// [i1, i2)の範囲を青木くんが全てとることができるか？
// [i1, n)の範囲の個数から、高橋くんと青木くんの取るべき個数がわかる
// [i1, n)にある数の個数は偶数 -> それぞれ半分ずつ取るべき
// 奇数 -> 高橋くんが1枚多く取るべき
if(i2 == i1) return true;
// cout << range << " " << i1 << " " << i2 << endl;
int takahashinum = n - i2;
int aokinum = i2 - i1;
if(takahashinum >= aokinum) return true;
if(x - a[i1] == a[i2 - 1] - x){
// 青木くんの取る範囲を[i1, i2 - 1)にすることができる
takahashinum++;
aokinum--;
if(takahashinum >= aokinum) return true;
}
return false;
}
long long int solve(int x)
{
int l = 0, r = mod;
while(r - l > 1){
int mid = (l + r) / 2;
if(ok(x, mid)) l = mid;
else r = mid;
}
int i1 = lower_bound(a, a + n, x - l) - a;
int i2 = upper_bound(a, a + n, x + l) - a;
if(i1 == i2) i2++;
int takahashinum = n - i2;
int aokinum = i2 - i1;
// cout << takahashinum << " " << aokinum << endl;
if(takahashinum < aokinum){
// 青木くんの取る範囲を[i1, i2 - 1)にする
i2--;
}
// cout << l << " " << i1 << " " << i2 << endl;
// 答えは[i2, n)の範囲全てとi1 - 1から青木くんと交互にとった結果の値の和になる
long long int ans = sum[n - 1] - sum[i2 - 1];
if(i1 % 2 == n % 2) ans += sum_alternate[i1 - 1];
else ans += sum_alternate[i1 - 2];
return ans;
}
int main()
{
int q;
cin >> n >> q;
for(int i = 0; i < n; i++){
cin >> a[i];
if(i == 0) sum[i] = a[i];
else sum[i] = sum[i - 1] + a[i];
if(i < 2) sum_alternate[i] = a[i];
else sum_alternate[i] = sum_alternate[i - 2] + a[i];
}
for(int i = 0; i < q; i++){
int x;
cin >> x;
cout << solve(x) << endl;
}
} |
p03158 | C++ | #if __has_include("../library/Basic/Debug.hpp")
#include "../library/Basic/Debug.hpp"
#else
/* ----- Header Files ----- */
// IO
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm
#include <algorithm>
#include <cmath>
#include <numeric>
// container
#include <vector>
#include <string>
#include <tuple>
#include <complex>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
// others
#include <random>
#include <limits>
#include <functional>
#include <ctime>
#include <cassert>
#include <cstdint>
/* ----- Type Alias ----- */
using Bool = bool;
using Int = long long int;
using Real = long double;
using Char = char;
using String = std::string;
template <class T, class U>
using Pair = std::pair<T, U>;
template <class... Ts>
using Tuple = std::tuple<Ts...>;
template <class T>
using Vector = std::vector<T>;
template <size_t N>
using Bits = std::bitset<N>;
template <class T>
using Queue = std::queue<T>;
template <class T>
using Stack = std::stack<T>;
template <class T>
using Deque = std::deque<T>;
template <class T>
using MaxHeap = std::priority_queue<T>;
template <class T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T>
using Set = std::set<T>;
template <class T, class U>
using Map = std::map<T, U>;
template <class T, class... Us>
using Func = std::function<T(Us...)>;
template <class T>
T genv(T v) { return v; }
template <class T, class... Ts>
auto genv(size_t l, Ts... ts) {
return Vector<decltype(genv<T>(ts...))>(l, genv<T>(ts...));
}
template <class Cost = Int>
struct Edge {
Int src, dst;
Cost cost;
Edge(Int src = -1, Int dst = -1, Cost cost = 1)
: src(src), dst(dst), cost(cost){};
bool operator<(const Edge<Cost>& e) const { return this->cost < e.cost; }
bool operator>(const Edge<Cost>& e) const { return this->cost > e.cost; }
};
template <class Cost = Int>
using Edges = Vector<Edge<Cost>>;
template <class Cost = Int>
using Graph = Vector<Vector<Edge<Cost>>>;
#endif
/* ----- Misc ----- */
void fastio() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
}
struct Fout {
Int precision;
Fout(Int precision) : precision(precision) {}
};
std::ostream& operator<<(std::ostream& os, const Fout& fio) {
os << std::fixed << std::setprecision(fio.precision);
return os;
}
/* ----- Constants ----- */
constexpr Int INF = std::numeric_limits<Int>::max() / 3;
// constexpr Int MOD = 1000000007;
// constexpr Real PI = acos(-1);
// constexpr Real EPS = 1e-10;
// std::mt19937 mt(int(std::time(nullptr)));
int main() {
Int n, q;
std::cin >> n >> q;
Vector<Int> a(n);
for (auto& x : a) std::cin >> x;
a.insert(a.begin(), -INF);
Vector<Vector<Int>> psum(2, Vector<Int>(n + 1, 0));
for (Int i = 1; i <= n; ++i) {
for (Int p = 0; p < 2; ++p) {
psum[p][i] = psum[p][i - 1];
}
psum[0][i] += a[i];
if (n % 2 == i % 2) {
psum[1][i] += a[i];
}
}
for (Int t = 0; t < q; ++t) {
Int x;
std::cin >> x;
if (x >= a.back()) {
std::cout << psum[1][n] << std::endl;
continue;
}
Int r;
{
Int ok = 0, ng = n + 1;
// 青木: A_okは獲れてA_{ok+1}は獲られる
while (ng - ok > 1) {
Int mid = (ok + ng) / 2;
if (a[mid] <= x) {
ok = mid;
continue;
}
Int d = a[mid] - x;
Int l = std::lower_bound(a.begin(), a.end(), x - d) - a.begin();
Int tget = n - mid, aget = mid - l + 1;
(aget <= tget ? ok : ng) = mid;
}
r = ok;
}
Int d = n - r;
Int l = std::max(1LL, r - d + 1);
// [l, r]を獲られる
// std::cerr << x << ":(" << l << ',' << r << ")" << std::endl;
std::cout << (psum[0][n] - psum[0][r]) + psum[1][l - 1] << std::endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = long long;
using std::cout;
using std::endl;
using std::cin;
template<typename T>
std::vector<T> make_v(size_t a){return std::vector<T>(a);}
template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
return std::vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}
int main() {
int n, q; scanf("%d%d", &n, &q); std::vector<i64> a(n);
for(int i = 0; i < n; i++) scanf("%lld", &a[i]);
std::vector<i64> s(n + 1), s2(n + 1);
for(int i = 0; i < n; i++) s[i + 1] = s[i] + a[i];
for(int i = 0; i < n; i++) s2[i + 1] = s2[i] + (n % 2 != i % 2 ? a[i] : 0);
while(q--) {
int x; scanf("%d", &x);
int ok = 0, ng = n + 1;
while(std::abs(ok - ng) > 1) {
int mid = (ok + ng) >> 1;
int d = mid;
if(a[n - mid] < x) ng = mid;
else {
if(2 * d - 1 > n) ng = mid;
else {
if(a[n - d] - x < x - a[n - (2 * d - 1)]) ng = mid;
else ok = mid;
}
}
}
int d = ok;
i64 ans = (s[n] - s[n - d]);
if(n - 2 * d > 0) ans += s2[n - 2 * d];
printf("%lld\n", ans);
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=998244353,MAX=1<<18;
const ll INF=1LL<<50;
int main(){
int N,Q;cin>>N>>Q;
vector<ll> A(N),X(Q),rsum(N),oddsum(N,0);
for(int i=0;i<N;i++){
cin>>A[i];
}
for(int i=0;i<Q;i++){
cin>>X[i];
}
for(int i=N-1;i>=0;i--){
if(i==N-1) rsum[i]=A[i];
else rsum[i]=rsum[i+1]+A[i];
}
if(N%2==1){
for(int i=0;i<N;i++){
if(i==0) oddsum[i]=A[i];
else if(i%2==0) oddsum[i]=oddsum[i-2]+A[i];
else oddsum[i]=oddsum[i-1];
}
}else{
for(int i=1;i<N;i++){
if(i==1) oddsum[i]=A[i];
else if(i%2==1) oddsum[i]=oddsum[i-2]+A[i];
else oddsum[i]=oddsum[i-1];
}
}
for(int q=0;q<Q;q++){
ll left=0,right=INF;
while(right-left>1){
ll mid=(left+right)/2;
auto leftit=lower_bound(all(A),X[q]-mid),rightit=lower_bound(all(A),X[q]+mid);
if(distance(leftit,rightit)>distance(rightit,A.end())) right=mid;
else left=mid;
}
auto leftit=lower_bound(all(A),X[q]-left),rightit=lower_bound(all(A),X[q]+left);
int a=distance(A.begin(),leftit),b=distance(leftit,rightit),c=distance(rightit,A.end());
//cout<<left<<" "<<a<<" "<<b<<" "<<c<<endl;
if(N%2==0){
if(a==0) cout<<rsum[N-c]<<endl;
else if(b==c) cout<<oddsum[a-1]+rsum[N-c]<<endl;
else if(b+1==c) cout<<oddsum[N-1-b-c]+rsum[N-c]<<endl;
else cout<<oddsum[a-1]+rsum[N-(b+c)/2]<<endl;
}else{
if(a==0) cout<<rsum[N/2]<<endl;
else if(a==N) cout<<oddsum[a-1]<<endl;
else if((b+c)%2) cout<<oddsum[a-2]+rsum[N-c]<<endl;
else cout<<oddsum[a-1]+rsum[N-(b+c)/2]<<endl;
}
}
}
|
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+1);
for (int i = 1; i <= N; ++i) {
cin >> A[i];
}
vector<int>X(Q);
for (int i = 0; i < Q; ++i) {
cin >> X[i];
}
vector<pair<int, ll>> boundary; // 区間 [ ) の左, 答え
boundary.reserve(N);
ll sum = 0;
for (int i = N; i > 0; i -= 2) {
sum += A[i];
}
for (int i = 1; i <= (N-1)/2; ++i) {
int b = A[N-i] + A[N-2*i];
b = b / 2 + 1;
b *= -1;
boundary.push_back({b, sum});
sum -= A[N-2*i];
sum += A[N-i];
}
boundary.push_back({1, sum});
for (int i = 0; i < Q; ++i) {
pair<int, ll> p = {X[i]*-1, -1};
auto iter = upper_bound(boundary.begin(), boundary.end(), p);
p = *iter;
cout << p.second << "\n";
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i, m, n) for(int i = (int)(m); i < (int)(n); ++i)
// 長さを長くするべきかどうか
bool longer(int x, int length, vector<long long>& A, int N)
{
// 2*length が N 以上の時はこれ以上長くできない
if(N <= 2*length) return false;
/** 今、青木くんが右側で取れるのは N-1-length まで。
* まだ左側のものを取れる可能性がある (つまり、abs(A[N-1-2*length]-x) <= abs(A[N-1-length]-x))
* ときは長くし得るが、それ以外のときは短くしないとダメ
* -> つまり、length を長くしていくと、
*/
return abs(A[N-1-2*length]-x) <= abs(A[N-1-length]-x);
}
// 高橋くんがとる右側の数列の長さを二分探索
int searchLength(int x, vector<long long>& A, int N)
{
int l = 0;
int r = N;
while(r-l > 1){
int c = (l+r)/2;
if(longer(x, c, A, N)) l = c;
else r = c;
}
return r;
}
int main()
{
int N, Q;
cin >> N >> Q;
vector<long long> A(N), X(Q);
REP(i, N) cin >> A[i];
REP(i, Q) cin >> X[i];
vector<long long> cumsum_A(A), alt_A(A);
REP(i, N-1){
cumsum_A[i+1] += cumsum_A[i];
if(i < N-2) alt_A[i+2] += alt_A[i];
}
REP(i, Q){
int length = searchLength(X[i], A, N);
// cout << length << " ";
long long ans = cumsum_A[N-1]-cumsum_A[N-1-length];
if(N-1-2*length >= 0) ans += alt_A[N-1-2*length]; // 左の残りがあれば足す
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i, m, n) for(int i = (int)(m); i < (int)(n); ++i)
// 長さを長くするべきかどうか
bool longer(int x, int length, vector<long long>& A, int N)
{
// 2*length が N 以上の時はこれ以上長くできない
if(N <= 2*length) return false;
/** 今、青木くんが右側で取れるのは N-1-length まで。
* まだ左側のものを取れる可能性がある (つまり、abs(A[N-1-2*length]-x) <= abs(A[N-1-length]-x))
* ときは長くし得るが、それ以外のときは短くしないとダメ
* -> つまり、length を長くしていくと、
*/
return abs(A[N-1-2*length]-x) <= abs(A[N-1-length]-x);
}
// 高橋くんがとる右側の数列の長さを二分探索
int searchLength(int x, vector<long long>& A, int N)
{
int l = 0;
int r = N;
while(r-l > 1){
int c = (l+r)/2;
if(longer(x, c, A, N)) l = c;
else r = c;
}
return r;
}
int main()
{
int N, Q;
cin >> N >> Q;
vector<long long> A(N), X(Q);
REP(i, N) cin >> A[i];
REP(i, Q) cin >> X[i];
vector<long long> cumsum_A(A), alt_A(A);
REP(i, N-1){
cumsum_A[i+1] += cumsum_A[i];
if(i < N-2) alt_A[i+2] += alt_A[i];
}
REP(i, Q){
int length = searchLength(X[i], A, N);
// cout << length << " ";
long long ans = cumsum_A[N-1]-cumsum_A[N-1-length];
if(N-1-2*length >= 0) ans += alt_A[N-1-2*length]; // 左の残りがあれば足す
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i, m, n) for(int i = (int)(m); i < (int)(n); ++i)
// 長さを長くするべきかどうか
bool check(int x, int c, vector<long long>& A, int N)
{
if(N <= 2*c) return false;
return abs(A[N-1-2*c]-x) <= abs(A[N-1-c]-x);
}
// 高橋くんがとる右側の数列の長さを二分探索
int searchLength(int x, vector<long long>& A, int N)
{
int l = 0;
int r = N;
while(r-l > 1){
int c = (l+r)/2;
if(check(x, c, A, N)) l = c;
else r = c;
//if(x == 10) cout << left << " " << right << endl;
}
return r;
}
int main()
{
int N, Q;
cin >> N >> Q;
vector<long long> A(N), X(Q);
REP(i, N) cin >> A[i];
REP(i, Q) cin >> X[i];
vector<long long> cumsum_A(A), alt_A(A);
REP(i, N-1){
cumsum_A[i+1] += cumsum_A[i];
if(i < N-2) alt_A[i+2] += alt_A[i];
}
REP(i, Q){
int length = searchLength(X[i], A, N);
// cout << length << " ";
long long ans = cumsum_A[N-1]-cumsum_A[N-1-length];
if(N-1-2*length >= 0) ans += alt_A[N-1-2*length];
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define len(v) ll(v.size())
#define fi first
#define se second
template <class T>
void cout_vec(const vector<T> &vec){
for(auto itr:vec) cout<<itr<<' ';
cout<<endl;
}
typedef pair<ll,ll> P;
const ll mod=1e9+7;
const ll inf=1e15;
int n,q;
vector<ll> a(100010,inf),sum(100010,0),even(100010,0),odd(100010,0);
bool solve(ll x,ll kai){
if(kai<0 || kai>n) return false;
ll ind=lower_bound(begin(a)+1,begin(a)+n+1,x-(a[kai]-x))-begin(a);
//cout<<kai<<' '<<ind<<endl;
return (n-kai)>=(kai-ind+1);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin>>n>>q;
FOR(i,1,n+1){
cin>>a[i];
sum[i]=a[i]+sum[i-1];
if(i%2==0) even[i]=a[i]+even[i-2];
else odd[i]=a[i]+odd[max(0ll,i-2)];
}
vector<ll> ans1;
rep(loop,q){
ll x,ans=0;
cin>>x;
ll low=1,high=n+10,mid;
while(high-low>1){
mid=(high+low)/2;
//cout<<mid<<endl;
if(solve(x,mid)) low=mid;
else high=mid;
}
//cout<<low<<endl;
ans+=sum[n]-sum[low];
if(n%2==0) ans+=even[2*low-n];
else{
ans+=odd[max(0ll,2*low-n)];
}
ans1.push_back(ans);
}
cout_vec(ans1);
} |
p03158 | C++ | #include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef priority_queue<int> PQ;
#define fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
//vector<vector<int> > dp;
//vector<vector<vector<int> > > vvvi;
//dp=vector<vector<int> >(N, vector<int>(M,0));
//vector<pair<int,int> > v;
//v.push_back(make_pair(x,y));
//priority_queue<int,vector<int>, greater<int> > q2;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N, Q;
int S[100010], Sdiv[100010], ans[100010];
int A[100010], X[100010];
cin >> N >> Q;
eFOR(i,1, N) {
cin >> A[i];
S[i] = S[i - 1] + A[i];
Sdiv[i] = A[i];
if (i - 2 > 0) {
Sdiv[i] += Sdiv[i - 2];
}
}
REP(i, Q) {
cin >> X[i];
}
REP(q, Q) {
int ng = 0;
int ok = N;
while (ok - ng > 1) {
int mid = (ng + ok) / 2;
if (A[mid] < X[q]) {
ng = mid;
}else {
int upper = N - mid + 1;
int lower = mid - (lower_bound(A, A + N + 1, max(1LL, 2 * X[q] - A[mid])) - A) + 1;
(upper > lower ? ng : ok) = mid;
}
}
int res = S[N] - S[ok - 1];
int tf = N - (N - ok + 1) * 2;
if (tf > 0)res += Sdiv[tf];
ans[q] = res;
}
REP(i, Q) {
cout << ans[i] << endl;
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef priority_queue<int> PQ;
#define fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
//vector<vector<int> > dp;
//vector<vector<vector<int> > > vvvi;
//dp=vector<vector<int> >(N, vector<int>(M,0));
//vector<pair<int,int> > v;
//v.push_back(make_pair(x,y));
//priority_queue<int,vector<int>, greater<int> > q2;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N, Q;
int64_t S[100010], Sdiv[100010], ans[100010];
int A[100010], X[100010];
cin >> N >> Q;
eFOR(i,1, N) {
cin >> A[i];
S[i] = S[i - 1] + A[i];
Sdiv[i] = A[i];
if (i - 2 > 0) {
Sdiv[i] += Sdiv[i - 2];
}
}
REP(i, Q) {
cin >> X[i];
}
REP(q, Q) {
int ng = 0;
int ok = N;
while (ok - ng > 1) {
int mid = (ng + ok) / 2;
if (A[mid] < X[q]) {
ng = mid;
}else {
int upper = N - mid + 1;
int lower = mid - (lower_bound(A, A + N + 1, max(1LL, 2 * X[q] - A[mid])) - A) + 1;
(upper > lower ? ng : ok) = mid;
}
}
int64_t res = S[N] - S[ok - 1];
int tf = N - (N - ok + 1) * 2;
if (tf > 0)res += Sdiv[tf];
ans[q] = res;
}
REP(i, Q) {
cout << ans[i] << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using ull=unsigned long long;
using uint=unsigned int;
using pcc=pair<char,char>;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using pdd=pair<double,double>;
using tuplis=pair<ll,pll>;
using tuplis2=pair<pll,ll>;
template<class T> using pq=priority_queue<T,vector<T>,greater<T>>;
const ll LINF=0x1fffffffffffffff;
const ll MINF=0x7fffffffffff;
const int INF=0x3fffffff;
const ll MOD=1000000007;
const ll MODD=998244353;
const ld DINF=numeric_limits<ld>::infinity();
const ld EPS=1e-9;
const vector<ll>four{0,1,0,-1,0};
#define _overload4(_1,_2,_3,_4,name,...) name
#define _overload3(_1,_2,_3,name,...) name
#define _rep1(n) for(ll i=0;i<n;++i)
#define _rep2(i,n) for(ll i=0;i<n;++i)
#define _rep3(i,a,b) for(ll i=a;i<b;++i)
#define _rep4(i,a,b,c) for(ll i=a;i<b;i+=c)
#define rep(...) _overload4(__VA_ARGS__,_rep4,_rep3,_rep2,_rep1)(__VA_ARGS__)
#define _rrep1(n) for(ll i=(n)-1;i>=0;i--)
#define _rrep2(i,n) for(ll i=(n)-1;i>=0;i--)
#define _rrep3(i,a,b) for(ll i=(b)-1;i>=a;i--)
#define _rrep4(i,a,b,c) for(ll i=a+(b-a-1)/c*c;i>=a;i-=c)
#define rrep(...) _overload4(__VA_ARGS__,_rrep4,_rrep3,_rrep2,_rrep1)(__VA_ARGS__)
#define each(i,a) for(auto &i:a)
#define sum(...) accumulate(range(__VA_ARGS__),0LL)
#define dsum(...) accumulate(range(__VA_ARGS__),double(0))
#define _range(i) (i).begin(),(i).end()
#define _range2(i,k) (i).begin(),(i).begin()+k
#define _range3(i,a,b) (i).begin()+a,(i).begin()+b
#define range(...) _overload3(__VA_ARGS__,_range3,_range2,_range)(__VA_ARGS__)
#define _rrange(i) (i).rbegin(),(i).rend()
#define _rrange2(i,k) (i).rbegin(),(i).rbegin()+k
#define _rrange3(i,a,b) (i).rbegin()+a,(i).rbegin()+b
#define rrange(...) _overload3(__VA_ARGS__,_rrange3,_rrange2,_rrange)(__VA_ARGS__)
#define elif else if
#define unless(a) if(!(a))
#define mp make_pair
#define mt make_tuple
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__;in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__;in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__;in(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__;in(__VA_ARGS__)
#define vec(type,name,...) vector<type> name(__VA_ARGS__)
#define VEC(type,name,size) vector<type> name(size);in(name)
#define vv(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define VV(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__));in(name)
#define vvv(type,name,h,w,...) vector<vector<vector<type>>>name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))
inline constexpr ll gcd(ll a,ll b){if(!a||!b)return 0;while(b){ll c=b;b=a%b;a=c;}return a;}
inline constexpr ll lcm(ll a,ll b){if(!a||!b)return 0;return a*b/gcd(a,b);}
template<class T> inline constexpr T min(vector<T> &v){return *min_element(range(v));}
inline char min(string &v){return *min_element(range(v));}
template<class T> inline constexpr T max(vector<T> &v){return *max_element(range(v));}
inline char max(string &v){return *max_element(range(v));}
inline constexpr ll intpow(ll a,ll b){ll ans=1;for(ll i=1;b;i*=2){if(b&i){b^=i;ans*=a;}a*=a;}return ans;}
template<typename T>
inline constexpr bool chmin(T &mn,const T &cnt){if(mn>cnt){mn=cnt;return 1;}else return 0;}
template<typename T>
inline constexpr bool chmax(T &mx,const T &cnt){if(mx<cnt){mx=cnt;return 1;}else return 0;}
template<class T> unordered_map<T,ll> press(vector<T> &a){ auto b = a; sort(range(b)); b.erase(unique(range(b)), b.end()); unordered_map<T,ll> ans; rep(b.size()) ans[b[i]] = i; each(i, a) i = ans[i]; return ans; }
template<class T> map<T,ll> press_map(vector<T> &a){ auto b = a; sort(range(b)); b.erase(unique(range(b)), b.end()); map<T,ll> ans; rep(b.size()) ans[b[i]] = i; each(i, a) i = ans[i]; return ans; }
inline int scan(){ return getchar(); }
inline void scan(int &a){ scanf("%d", &a); }
inline void scan(unsigned &a){ scanf("%u", &a); }
inline void scan(long &a){ scanf("%ld", &a); }
inline void scan(long long &a){ scanf("%lld", &a); }
inline void scan(unsigned long long &a){ scanf("%llu", &a); }
inline void scan(char &a){ cin >> a; }
inline void scan(float &a){ scanf("%f", &a); }
inline void scan(double &a){ scanf("%lf", &a); }
inline void scan(long double &a){ scanf("%Lf", &a); }
inline void scan(vector<bool> &vec){ for(unsigned i = 0; i < vec.size(); i++) { int a; scan(a); vec[i] = a; } }
inline void scan(string &a){ cin >> a; }
template<class T> inline void scan(vector<T> &vec);
template<class T, size_t size> inline void scan(array<T, size> &vec);
template<class T, class L> inline void scan(pair<T, L> &p);
template<class T, size_t size> inline void scan(T (&vec)[size]);
template<class T> inline void scan(vector<T> &vec){ for(auto &i : vec) scan(i); }
template<class T, size_t size> inline void scan(array<T, size> &vec){ for(auto &i : vec) scan(i); }
template<class T, class L> inline void scan(pair<T, L> &p){ scan(p.first); scan(p.second); }
template<class T, size_t size> inline void scan(T (&vec)[size]){ for(auto &i : vec) scan(i); }
template<class T> inline void scan(T &a){ cin>>a; }
inline void in(){}
template <class Head, class... Tail> inline void in(Head &head, Tail&... tail){ scan(head); in(tail...); }
inline void print(){ putchar(' '); }
inline void print(const bool &a){ printf("%d", a); }
inline void print(const int &a){ printf("%d", a); }
inline void print(const unsigned &a){ printf("%u", a); }
inline void print(const long &a){ printf("%ld", a); }
inline void print(const long long &a){ printf("%lld", a); }
inline void print(const unsigned long long &a){ printf("%llu", a); }
inline void print(const char &a){ printf("%c", a); }
inline void print(const char a[]){ printf("%s", a); }
inline void print(const float &a){ printf("%.10f", a); }
inline void print(const double &a){ printf("%.10f", a); }
inline void print(const long double &a){ printf("%.10Lf", a); }
template<class T> void print(const vector<T> &vec);
template<class T, size_t size> void print(const array<T, size> &vec);
template<class T, class L> void print(const pair<T, L> &p);
template<class T, size_t size> inline void print(const T (&vec)[size]);
template<class T> void print(const vector<T> &vec){ if(vec.empty()) return; print(vec[0]); for(auto i = vec.begin(); ++i != vec.end(); ){ putchar(' '); print(*i); } }
template<class T, size_t size> void print(const array<T, size> &vec){ print(vec[0]); for(auto i = vec.begin(); ++i != vec.end(); ){ putchar(' '); print(*i); } }
template<class T, class L> void print(const pair<T, L> &p){ print(p.first); putchar(' '); print(p.second); }
template<class T, size_t size> inline void print(const T (&vec)[size]){ print(vec[0]); for(auto i = vec; ++i != end(vec); ){ putchar(' '); print(*i); } }
template<class T> inline void print(const T &a){ cout << a; }
inline int out(){ putchar('\n'); return 0; }
template<class T> inline int out(const T &t){ print(t); putchar('\n'); return 0; }
template<class Head, class... Tail> inline int out(const Head &head, const Tail&... tail){ print(head); putchar(' '); out(tail...); return 0; }
template <class T> inline void err(T t){cerr<<t<<'\n';}
inline void err(){cerr<<'\n';}
inline int first(const bool &i){return out(i?"first":"second");}
inline int yes(const bool &i){return out(i?"yes":"no");}
inline int Yes(const bool &i){return out(i?"Yes":"No");}
inline int YES(const bool &i){return out(i?"YES":"NO");}
inline int Yay(const bool &i){return out(i?"Yay!":":(");}
inline int Possible(const bool &i){return out(i?"Possible":"Impossible");}
inline int POSSIBLE(const bool &i){return out(i?"POSSIBLE":"IMPOSSIBLE");}
inline void Case(ll i){printf("Case #%lld: ",i);}
signed main(){
LL(n,q);
VEC(ll,a,n);
vec(ll,b,(n+3)/2);
b[0]=LINF;
rep(i,1,(n+1)/2){
b[i]=(a[n-1-i]+a[n-1-i*2])/2+1;
}
reverse(range(b));
vec(ll,s,n+1);
vec(ll,s2,n+2);
rep(n)s[i+1]=s[i]+a[i];
rep(n)s2[i+2]=s2[i]+a[i];
rep(q){
LL(x);
x=b.end()-upper_bound(range(b),x);
if(x*2>n)out(s.back()-(s[n/2]-s[0]));
else out(s.back()-(s[n-x]-s[n-x*2]+s2[n-x*2]));
}
}
|
p03158 | C++ | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <cmath>
#include <tuple>
#include <cstdio>
#include <bitset>
#include <sstream>
#include <iterator>
#include <numeric>
#include <map>
#include <cstring>
#include <set>
#include <functional>
#include <iomanip>
using namespace std;
#define DEBUG_ //!!提出時にコメントアウト!!
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
//#define int long long
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T>
std::string printVector(const std::vector<T> &data)
{
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9+7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
signed main(int argc, char const *argv[])
{
cin.tie(0);
ios::sync_with_stdio(false);
int N,Q; cin >> N >> Q;
VL A(N); REP(i,N) cin >> A[i];
reverse(A.begin(),A.end());
VL sum(N+1), evensum(N+1);
REP(i,N){
sum[i+1] = sum[i] + A[i];
evensum[i+1] = evensum[i] + (i%2 == 0 ? A[i] : 0);
}
VL ths, vals;
REP(i,(N-1)/2){
LL th = (A[i+1] + A[i*2+2])/2 + 1;
LL val = (sum[i+1] - sum[0]) + (evensum[N] - evensum[i*2+2]);
ths.eb(th); vals.eb(val);
}
reverse(ths.begin(),ths.end());
reverse(vals.begin(),vals.end());
REP(_,Q){
LL x; cin >> x;
int it = upper_bound(ths.begin(),ths.end(),x) - ths.begin();
if(it == 0) cout << sum[(N+1)/2] - sum[0] << endl;
else cout << vals[it-1] << endl;
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
using ll = long long;
using ld = long double;
constexpr ll inf = static_cast<ll>(1e17);
constexpr int iinf = static_cast<int>(1e9);
constexpr ll mod = static_cast<ll>(1e9 + 7);
int n, q;
ll a[100005];
ll sum[100005], sum2[100005];
int main()
{
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> n >> q;
for (int i = 1; i <= n; ++i) {
std::cin >> a[i];
sum[i] = sum[i - 1] + a[i];
sum2[i] = sum2[i - 1];
if (i % 2 == 1)
sum2[i] += a[i];
}
for (int i = 0; i < q; ++i) {
ll x;
std::cin >> x;
int l = 1, r = n;
while (r - l > 0) {
auto aa = (l + r) / 2;
auto bb = (aa + n) / 2;
auto aval = std::abs(x - a[aa]);
auto bval = std::abs(x - a[bb]);
if (aval < bval) {
r = aa;
}
else if (aval > bval) {
if (l == aa)
l = aa + 1;
else
l = aa;
}
else {
l = r = aa;
}
}
r = l + (n - l + 1) / 2 - 1;
ll ans = sum[n] - sum[r];
if (n - r == r - l + 1) {
if ((l - 1) % 2 == 1)
ans += sum2[l - 1];
else
ans += sum[l - 1] - sum2[l - 1];
}
else if (l > 1) {
if ((l - 2) % 2 == 1)
ans += sum2[l - 2];
else
ans += sum[l - 2] - sum2[l - 2];
}
std::cout << ans << std::endl;
}
return 0;
}
|
p03158 | C++ | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
const int iINF = 2147483647 / 2;
const long long int llINF = 9223372036854775807 / 2;
using namespace std;
using ll = long long int;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
typedef pair<ll, ll> pll;
bool paircomp(const pll &a, const pll &b) {
if (a.first == b.first)
return a.second < b.second;
return a.first < b.first;
}
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end())
#define MIN(vec) *std::min_element(vec.begin(), vec.end())
#define ARGMAX(vec) \
std::distance(vec.begin(), std::max_element(vec.begin(), vec.end()))
#define ARGMIN(vec) \
std::distance(vec.begin(), std::min_element(vec.begin(), vec.end()))
#define REV(T) greater<T>()
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define VVL(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define VVVL(a, b, c, d) \
vector<vector<vector<ll>>>(a, vector<vector<ll>>(b, vector<ll>(c, d)))
#define SP(a) setprecision(a)
#define SQRT(a) sqrt((long double)(a))
#define DPOW(a, b) pow((long double)(a), (long double)(b))
#define UNIQUE(vec) \
do { \
sort(ALL((vec))); \
(vec).erase(std::unique(ALL((vec))), (vec).end()); \
} while (0)
ll POW(ll n, ll m) {
if (m == 0) {
return 1;
} else if (m % 2 == 0) {
ll tmp = POW(n, m / 2);
return (tmp * tmp);
} else {
return (n * POW(n, m - 1));
}
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N, Q;
cin >> N >> Q;
vl A(N, 0), X(Q, 0);
vl sum(N + 1, 0);
vl evensum(N + 1, 0);
REP(i, N) cin >> A[i];
REP(i, Q) cin >> X[i];
reverse(ALL(A));
REP(i, N) {
sum[i + 1] = sum[i] + A[i];
if (i % 2 == 0)
evensum[i + 1] = evensum[i] + A[i];
else
evensum[i + 1] = evensum[i];
}
vl ths, vals;
REP(i, (N - 1) / 2) {
ll th = ((A[i + 1] + A[(i * 2) + 2]) / 2) + 1;
ll val = (sum[i + 1] - sum[0]) + (evensum[N] - evensum[(i * 2) + 2]);
ths.push_back(th);
vals.push_back(val);
}
reverse(ALL(ths));
reverse(ALL(vals));
REP(q, Q) {
int i = upper_bound(ALL(ths), X[q]) - ths.begin();
if (i == 0)
cout << sum[(N + 1) / 2] - sum[0] << endl;
else
cout << vals[i - 1] << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
*/
const int NMAX = 1e5+7;
int n, q;
vector<ll> A(NMAX, 0), esum(NMAX, 0), osum(NMAX, 0), sum(NMAX, 0);
bool check(int x, int a, int b){
// t <= 1
if(a == b) return true;
ll d1 = abs(x - A[a]);
ll d2 = abs(x - A[b]);
if(d1 <= d2) return true;
else return false;
}
ll calc(int l, int r, int d){
if(l > r) return 0;
if(d == 0){
return esum[r] - esum[l-1];
}
else if(d == 1){
return osum[r] - osum[l-1];
}
else{
return sum[r] - sum[l-1];
}
}
ll query(ll x){
ll left = 0, right = n+1;
ll mid;
while(left+1 < right){
mid = (left+right)/2;
int a = (mid+1)/2;
int b = mid/2;
int r = n+1-a;
int l = n+1-mid;
if(check(x, l, r)) left = mid;
else right = mid;
}
int t = left;
int a = (t+1)/2;
int d = n%2;
ll ans = calc(1, n-t, d) + calc(n+1-a, n, -1);
return ans;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
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];
esum[i] += esum[i-1] + (i%2 == 0? A[i]:0);
osum[i] += osum[i-1] + (i%2 == 1? A[i]:0);
}
for(int i=0; i<q; ++i){
int x; cin >> x;
ll ans = query(x);
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <vector>
#include <iostream>
#include <cmath>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <fstream>
#include <unistd.h>
#include <string.h>
#include <string>
#include <numeric>
#include <queue>
#include <deque>
#include <sstream>
#include <iomanip>
#include <set>
#include <stack>
#include <cassert>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vvb> vvvb;
typedef vector<vvvb> vvvvb;
typedef vector<string> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<vvd> vvvd;
typedef pair<ll, ll> PL;
typedef vector<PL> vpl;
typedef vector<vector<PL>> vvpl;
const int INF = 1001001001;
const ll LINF = 1e17;
const double pi = 3.1415926535897932;
const string endstr = "\n";
#define FOR(i, a, b) for(ll i = (a); i < b; i++)
#define RFOR(i, a, b) for(ll i = (a); i > b; i--)
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rrep(i, n) for(ll i = n-1; i > -1; i--)
#define FORMAP(it, m) for(auto it = m.begin(); it != m.end(); it++)
#define ff first
#define ss second
#define pb push_back
#define epb emplace_back
#define ALL(X) (X).begin(),(X).end()
template <typename T>
T gcd(T a, T b) {
return (a == 0) ? b : gcd(b%a, a);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
bool p_comp_fs(const PL p1, const PL p2){ return p1.first < p2.first;};
bool p_comp_fg(const PL p1, const PL p2){ return p1.first > p2.first;};
bool p_comp_ss(const PL p1, const PL p2){ return p1.second < p2.second;};
bool p_comp_sg(const PL p1, const PL p2){ return p1.second > p2.second;};
template <typename T>
vector<T> uniquen(vector<T> vec){
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
inline ll popcnt(ll x){return __builtin_popcountll((unsigned long long)x);};
template<class T> bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
int main(){
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll N, Q; cin >> N >> Q;
vl A(N+1, 0); rep(i, N) cin >> A[i+1];
vl sum(N+1, 0), ssum(N+1, 0);
FOR(i, 1, N+1){
sum[i] = sum[i-1] + A[i];
ssum[i] = A[i];
if(i-2>0) ssum[i] += ssum[i-2];
}
rep(_, Q){
ll x; cin >> x;
ll ng = 0, ok = N;
while(abs(ok-ng) > 1){
ll mid = (ng+ok)/2;
if(A[mid] < x){
ng = mid;
}
else{
ll upper = N-mid+1;
auto l_it = lower_bound(A.begin(), A.end(), max(2*x-A[mid], 1ll));
ll lower = mid - (l_it - A.begin()) + 1;
if(upper <= lower) ok = mid;
else ng = mid;
}
}
ll res = sum[N] - sum[ok-1];
ll lidx = N-2*(N-ok+1);
if(lidx >= 0) res += ssum[lidx];
cout << res << endstr;
}
return 0;
}
|
p03158 | C++ | #include <vector>
#include <iostream>
#include <cmath>
#include <map>
#include <algorithm>
#include <fstream>
#include <unistd.h>
#include <string>
#include <numeric>
#include <queue>
#include <deque>
#include <sstream>
#include <iomanip>
#include <set>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<vector<string>> vvs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
typedef vector<P> vp;
typedef vector<PL> vpl;
typedef vector<vector<P>> vvp;
typedef vector<vector<PL>> vvpl;
const int INF = 1001001001;
const ll LINF = 1e18;
const double pi = 3.1415926535897932;
const string endstr = "\n";
#define FOR(i, a, b) for(ll i = (a); i < b; i++)
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rrep(i, n) for(ll i = n; i >= 0; i--)
#define FORMAP(it, m) for(auto it = m.begin(); it != m.end(); it++)
#define ff first
#define ss second
#define pb push_back
template <typename T>
T gcd(T a, T b) {
return (a == 0) ? b : gcd(b%a, a);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
bool p_comp_fs(const PL p1, const PL p2){ return p1.first < p2.first;};
bool p_comp_fg(const PL p1, const PL p2){ return p1.first > p2.first;};
bool p_comp_ss(const PL p1, const PL p2){ return p1.second < p2.second;};
bool p_comp_sg(const PL p1, const PL p2){ return p1.second > p2.second;};
template <typename T>
vector<T> uniquen(vector<T> vec){
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
template<class T> bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
int main(){
ll N, Q; cin >> N >> Q;
vl A(N+1, 0); rep(i, N) cin >> A[i+1];
vl sum(N+1, 0), ssum(N+1, 0);
FOR(i, 1, N+1){
sum[i] = sum[i-1] + A[i];
ssum[i] = A[i];
if(i-2>0) ssum[i] += ssum[i-2];
}
rep(_, Q){
ll x; cin >> x;
ll ng = 0, ok = N;
while(ok-ng > 1){
ll mid = (ng+ok)/2;
if(A[mid] < x){
ng = mid;
}
else{
ll upper = N-mid+1;
auto l_it = lower_bound(A.begin(), A.end(), max(2*x-A[mid], 1ll));
ll lower = mid - (l_it - A.begin()) + 1;
if(upper > lower) ng = mid;
else ok = mid;
}
}
ll res = sum[N] - sum[ok-1];
ll lidx = N-2*(N-ok+1);
if(lidx >= 0) res += ssum[lidx];
cout << res << endstr;
}
return 0;
}
|
p03158 | C++ | #include <vector>
#include <iostream>
#include <cmath>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <fstream>
#include <unistd.h>
#include <string.h>
#include <string>
#include <numeric>
#include <queue>
#include <deque>
#include <sstream>
#include <iomanip>
#include <set>
#include <stack>
#include <cassert>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vvb> vvvb;
typedef vector<vvvb> vvvvb;
typedef vector<string> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<vvd> vvvd;
typedef pair<ll, ll> PL;
typedef vector<PL> vpl;
typedef vector<vector<PL>> vvpl;
const int INF = 1001001001;
const ll LINF = 1e17;
const double pi = 3.1415926535897932;
const string endstr = "\n";
#define FOR(i, a, b) for(ll i = (a); i < b; i++)
#define RFOR(i, a, b) for(ll i = (a); i > b; i--)
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rrep(i, n) for(ll i = n-1; i > -1; i--)
#define FORMAP(it, m) for(auto it = m.begin(); it != m.end(); it++)
#define ff first
#define ss second
#define pb push_back
#define epb emplace_back
#define ALL(X) (X).begin(),(X).end()
template <typename T>
T gcd(T a, T b) {
return (a == 0) ? b : gcd(b%a, a);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
bool p_comp_fs(const PL p1, const PL p2){ return p1.first < p2.first;};
bool p_comp_fg(const PL p1, const PL p2){ return p1.first > p2.first;};
bool p_comp_ss(const PL p1, const PL p2){ return p1.second < p2.second;};
bool p_comp_sg(const PL p1, const PL p2){ return p1.second > p2.second;};
template <typename T>
vector<T> uniquen(vector<T> vec){
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
inline ll popcnt(ll x){return __builtin_popcountll((unsigned long long)x);};
template<class T> bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
int main(){
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll N, Q; cin >> N >> Q;
vl A(N); rep(i, N) cin >> A[i];
reverse(ALL(A));
vl sum(N+1, 0), esum(N+1, 0);
rep(i, N){
sum[i+1] = sum[i] + A[i];
esum[i+1] = esum[i] + (i%2 == 0 ? A[i] : 0);
}
vl th, val;
for(ll i = 0; 2*i+1 < N; i++){
th.pb((A[i+1]+A[2*i+2])/2+1);
val.pb(sum[i+1] + esum[N]-esum[2*i+2]);
}
reverse(ALL(th)); reverse(ALL(val));
rep(_, Q){
ll x; cin >> x;
ll idx = upper_bound(ALL(th), x) - th.begin();
if(idx == 0) cout << sum[(N+1)/2] << endstr;
else cout << val[idx-1] << endstr;
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <cmath>
#include <deque>
#include <iterator>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)
#define REP(i, n) rep(i, 0, n)
template<class T> inline bool chmax(T& a, T b) {if (a<b) {a=b; return true;} return false;}
template<class T> inline bool chmin(T& a, T b) {if (a>b) {a=b; return true;} return false;}
const ll MOD = 1000000007;
const ll HIGHINF = (ll)1e18;
ll n;
vll a, esum, osum, sum;
bool lt(ll x, ll ai, ll bi) {
if (bi<0 || bi>=n) return true;
if (ai<0 || ai>=n) return false;
ll d1 = abs(x-a[ai]);
ll d2 = abs(x-a[bi]);
if (d1 < d2) return true;
if (d1 == d2) return ai<bi;
return false;
}
ll calc(ll r, ll d) {
if (r<0) return 0;
if (d==0) return esum[r];
else if (d==1) return osum[r];
else return sum[r];
}
ll calc(ll l, ll r, ll d) {
if (l>r) return 0;
return calc(r, d) - calc(l-1, d);
}
ll query(ll x) {
ll lb=1, ub=n+1;
while(ub-lb>1) {
ll mid = (lb+ub) / 2;
ll ai = mid / 2;
ll bi = mid / 2;
if (ai + bi < mid) ai++;
ll l = n - mid;
ll r = n - ai - 1;
if (lt(x, r+1, l)) ub = mid;
else lb = mid;
}
ll ai = (lb+1)/2;
ll d = n % 2;
ll ans = calc(0, n-lb-1, d) + calc(n-lb, n-ai-1, -1);
return sum[n-1] - ans;
}
int main() {
ll q; cin >> n >> q;
a.resize(n), esum.resize(n), osum.resize(n), sum.resize(n);
REP(i, n) cin >> a[i];
sum[0] = a[0];
rep(i, 1, n) sum[i] = sum[i-1] + a[i];
esum[0] = a[0];
rep(i, 1, n) esum[i] = esum[i-1] + (i%2==0? a[i]: 0);
osum[0] = 0;
rep(i, 1, n) osum[i] = osum[i-1] + (i%2==1? a[i]: 0);
REP(_, q) {
ll x; cin >> x;
ll ans = query(x);
cout << ans << endl;
}
return 0;
}
|
p03158 | C++ | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long ll;
//typedef pair<int,int> Pint;
//typedef pair<ll, ll> P;
//typedef pair<ll, pair<ll, ll>> P;
//typedef tuple<int,int,int> T;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define revrep(i, n) for(ll i = n-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
const ll INFL = 1LL << 60;//10^18 = 2^60
const int INF = 1 << 30;//10^9
const ll MOD = 1e9 + 7;
//ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
x %= MOD; x += MOD; x %= MOD;
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){return x / gcd(x, y) * y;};
int main(void){
ll N, Q;
cin >> N >> Q;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<ll> S(N+1, 0);
vector<ll> evenS(N+1, 0);
rep(i, N) S[i+1] = S[i] + A[i];
rep(i, N){
if(i % 2){
evenS[i+1] = evenS[i] + A[i];
}else{
evenS[i+1] = evenS[i];
}
}
ll sum = 0;
rep(i, N) sum += A[i];
if(N % 2){
rep(i, N){
if(i % 2){
evenS[i+1] = evenS[i] + A[i];
}else{
evenS[i+1] = evenS[i];
}
}
vector<ll> canGet(N/2+1);
//x <= canGet[i] の時 i個以上連続
canGet[0] = -((A[N-3] + A[N-2]) / 2 + 1);
canGet[1] = -((A[N-3] + A[N-2]) / 2 + 1);
for(int i = 2; i <= N / 2; i++){
canGet[i] = -(A[N-i*2-1] + A[N-i-1]) / 2;
}
rep(i, Q){
ll x;
cin >> x;
x = -x;
if(x >= canGet.back()){
cout << sum - S[N/2] << endl;
continue;
}
if(x <= canGet[1]){
cout << sum - evenS[N] << endl;
continue;
}
ll AOKI = 0;
ll soeji = upper_bound(canGet.begin(), canGet.end(), x) - canGet.begin();
AOKI += S[N-soeji] - S[N-soeji * 2];
AOKI += evenS[N-soeji * 2];
cout << sum - AOKI << endl;
}
}else{
rep(i, N){
if(i % 2){
evenS[i+1] = evenS[i];
}else{
evenS[i+1] = evenS[i] + A[i];
}
}
vector<ll> canGet(N/2+1);
//x <= canGet[i] の時 i個以上連続
canGet[0] = -((A[N-3] + A[N-2]) / 2 + 1);
canGet[1] = -((A[N-3] + A[N-2]) / 2 + 1);
for(int i = 2; i < N / 2; i++){
canGet[i] = -(A[N-i*2-1] + A[N-i-1]) / 2;
}
canGet[N / 2] = 0;
rep(i, Q){
ll x;
cin >> x;
x = -x;
if(x <= canGet[1]){
cout << sum - evenS[N] << endl;
continue;
}
if(x >= canGet.back()){
cout << sum - S[N/2] << endl;
continue;
}
ll AOKI = 0;
ll soeji = upper_bound(canGet.begin(), canGet.end(), x) - canGet.begin();
AOKI += S[N-soeji] - S[N-soeji * 2];
AOKI += evenS[N-soeji * 2];
cout << sum - AOKI << endl;
}
}
}
|
p03158 | C++ | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <set>
#include <map>
#include <queue>
using namespace std;
#define rep(i,n) for(int i = 0;i<n;i++)
const long long MOD = 1000000007LL;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int main(){
int n,q;
cin >> n >> q;
long long a[n];
long long tem = 0;
rep(i,n){
cin >> a[i];
}
sort(a,a+n,greater<long long>());
vector<long long> border;
map<long long,long long> mp,mp2;
border.push_back(a[0]);
for(int i = 0;i<n;i+=2){
tem+=a[i];
}
mp[a[0]]=tem;
mp2[a[0]]=0;
for(int i = 2;i<n;i+=2){
border.push_back((a[i]+a[i-(i/2)])/2);
mp[(a[i]+a[i-(i/2)])/2]=mp[border[(i/2)-1]]-a[i-2];
mp2[(a[i]+a[i-(i/2)])/2]=i/2;
}
/*rep(i,border.size()){
cout << "border: " << border[i] << " mp: " << mp[border[i]] << " mp2: " << mp2[border[i]] << endl;
}*/
mp[0]=0;
mp2[0]=(n+1)/2;
border.push_back(0);
long long tsum[n+1];
tsum[0]=0;
rep(i,n){
tsum[i+1]=tsum[i]+a[i];
}
vector<long long> ans;
long long x;
sort(border.begin(),border.end());
rep(i,q){
cin >> x;
auto itr = lower_bound(border.begin(),border.end(),x);
itr--;
ans.push_back(mp[*itr]+tsum[mp2[*itr]]);
}
rep(i,q){
cout << ans[i] << endl;
}
} |
p03158 | C++ | #include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const double EPS=1e-10;
const double INF=1e+10;
const double PI=acos(-1.0);
const int C_SIZE = 210000;
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
long long C(int a,int b){
if(a<b||b<0)return 0;
return fact[a]*finv[b]%mod*finv[a-b]%mod;
}
void init_C(int n){
fact[0]=finv[0]=inv[1]=1;
for(int i=2;i<n;i++){
inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
}
for(int i=1;i<n;i++){
fact[i]=fact[i-1]*i%mod;
finv[i]=finv[i-1]*inv[i]%mod;
}
}
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
double ABS(double a){return max(a,-a);}
// ここから編集しろ
int p[110000];
long long sum[110000];
long long Rsum[110000];
int main(){
int a,b;scanf("%d%d",&a,&b);
for(int i=0;i<a;i++)scanf("%d",p+i);
long long now=0;
for(int i=0;i<a;i++){
if((a+i)%2==1)now+=p[i];
sum[i]=now;
}
for(int i=a-1;i>=0;i--){
Rsum[i]=p[i]+Rsum[i+1];
}
for(int i=0;i<b;i++){
int c;scanf("%d",&c);
long long left=-3;
long long right=mod*2;
while(left<right){
long long M=(left+right)/2;
int lat=lower_bound(p,p+a,c-(M+1)/2)-p;
int rat=upper_bound(p,p+a,c+M/2)-p-1;
int ko=rat-lat+1;
int ch=a-rat-1;
// printf("%lld %d %d\n",M,ko,ch);
if(ko==ch||ko+1==ch){
long long ret=Rsum[rat+1];
if(lat)ret+=sum[lat-1];
printf("%lld\n",ret);
break;
}else if(ko<ch){
left=M;
}else{
right=M;
}
}
}
} |
p03158 | C++ | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<unsigned char, unsigned char> pcc;
typedef pair<double, double> pdd;
typedef vector<vector<ll>> matrix;
int l[100005];
ll pref[100005];
ll firstOdd[100005];
ll firstEven[100005];
int n, q;
void solve(int x) {
int lhs = 0;
int rhs = (n+1)/2;
while(lhs != rhs) {
int mid = (lhs+rhs+1)/2;
int lastTaken = l[n-mid];
if(lastTaken < x) {
rhs = mid-1;
continue;
}
int otherTaken = l[n-mid-(mid-1)];
if(abs(x-otherTaken) > abs(x-lastTaken)) rhs = mid-1;
else lhs = mid;
}
ll ret = 0;
ret += pref[n] - pref[n-lhs];
if(n%2) ret += firstEven[(n+1)/2-lhs];
else ret += firstOdd[(n+1)/2-lhs];
cout << ret << "\n";
}
void solve() {
cin >> n >> q;
for(int i = 0; i < n; i++) {
cin >> l[i];
pref[i+1] = pref[i] + l[i];
}
for(int i = 1; i < n; i += 2) {
firstOdd[i/2+1] = firstOdd[i/2] + l[i];
}
for(int i = 0; i < n; i += 2) {
firstEven[i/2+1] = firstEven[i/2] + l[i];
}
while(q--) {
int x;
cin >> x;
solve(x);
}
}
void casesolve() {
int t;
cin >> t;
for(int i = 1; i <= t; i++) {
cout << "Case #" << i << ":" << "\n";
solve();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
solve();
// casesolve();
}
|
p03158 | C++ | #include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(){
ll n,q,x;
cin >> n >> q;
ll a[n];
for(int i=0;i<n;i++) cin >> a[i];
ll m=(n+1)/2;
ll sum[m];
sum[m-1]=0;
for(int i=n-1;i>=0;i-=2) sum[m-1]+=a[i];
for(int i=m-2;i>=0;i--){
sum[i]=sum[i+1]-a[n-1-2*(m-1-i)]+a[n-1-(m-1-i)];
}
ll dis[m+1];
dis[0]=-1e10,dis[m]=1e10;
for(int i=m-1;i>=1;i--){
dis[i]=(a[n-1-(m-i)*2]+a[n-1-(m-i)])/2+1;
}
for(int i=0;i<q;i++){
cin >> x;
ll p=upper_bound(dis,dis+m+1,x)-dis;
cout << sum[p-1] << endl;
}
} |
p03158 | C++ | #include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAX_N = 1e+5 + 10;
const ll INF = 1LL << 50;
ll A[MAX_N], X[MAX_N];
ll sum[MAX_N], even_sum[MAX_N];
int main() {
int N, Q;
cin >> N >> Q;
for (int i = 1; i <= N; i++) {
cin >> A[i];
sum[i] = A[i] + sum[i - 1];
even_sum[i] = even_sum[i - 1];
if (i % 2 == 0) even_sum[i] += A[i];
}
A[N + 1] = INF;
for (int i = 0; i < Q; i++) cin >> X[i];
for (int i = 0; i < Q; i++) {
int ng = 0, ok = N;
while (ok - ng > 1) {
int mid = (ng + ok) / 2;
if (A[mid] < X[i]) ng = mid;
else {
int takahashi = N - mid + 1;
int aoki = mid - (lower_bound(A + 1, A + N + 2, X[i] - (A[mid] - X[i])) - A) + 1;
if (takahashi <= aoki) ok = mid;
else ng = mid;
}
}
int cnt = N - ok + 1;
int idx = ok - cnt;
ll ans = sum[N] - sum[ok - 1];
if ((idx - 1) % 2 == 0) ans += even_sum[idx - 1];
else ans += sum[idx - 1] - even_sum[idx - 1];
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAX_N = 1e+5 + 10;
const ll INF = 1LL << 50;
ll A[MAX_N], X[MAX_N];
ll sum[MAX_N], even_sum[MAX_N];
int main() {
int N, Q;
cin >> N >> Q;
for (int i = 1; i <= N; i++) {
cin >> A[i];
sum[i] = A[i] + sum[i - 1];
even_sum[i] = even_sum[i - 1];
if (i % 2 == 0) even_sum[i] += A[i];
}
A[N + 1] = INF;
for (int i = 0; i < Q; i++) cin >> X[i];
for (int i = 0; i < Q; i++) {
int left = 0, right = N;
while (right - left > 1) {
int mid = (left + right) / 2;
// mid番目が境界となるか調べる
// mid番目を高橋くんが最後にとるところとする
int takahashi = N - mid + 1;
int sub = abs(X[i] - A[mid]);
int low = lower_bound(A + 1, A + N + 2, X[i] - sub) - A;
int high = upper_bound(A + 1, A + N + 2, X[i] + sub) - A;
int aoki = high - low;
if (low == mid) aoki--;
if (takahashi <= aoki) right = mid;
else left = mid;
}
int cnt = N - right + 1;
int idx = right - cnt;
ll ans = sum[N] - sum[right - 1];
if ((idx - 1) % 2 == 0) ans += even_sum[idx - 1];
else ans += sum[idx - 1] - even_sum[idx - 1];
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <queue>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <string>
#include <vector>
#include <map>
#include <functional>
#include <set>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pint;
const ll inf = (1LL << 60);
const ll mod = 1000000007;
ll max(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll min(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
vector<pll> zahyou;
ll esum[100005], osum[100005], sum[100005];
int main() {
ll N, Q;
vector<ll> A;
cin >> N >> Q;
rep(i, N) {
ll a;
cin >> a;
A.push_back(a);
if (i % 2 == 1) {
esum[i] = esum[i-1] + a;
osum[i] = osum[i - 1];
}
else {
if (i != 0)
osum[i] += osum[i - 1] + a;
else
osum[i] = a;
esum[i] = esum[i - 1];
}
if (i != 0)
sum[i] = sum[i - 1] + a;
else
sum[i] = a;
}
rep(i, Q) {
ll X;
cin >> X;
ll r = N, l = 0;
while (r - l > 1) {
ll mid = (r + l) / 2;
if (A[mid] < X || 2*mid - N + 1 < 0 || abs(A[2*mid-N + 1] - X) > abs(A[mid] - X)) {
l = mid;
}
else if (abs(A[2 * mid - N + 1] - X) <= abs(A[mid] - X)) {
r = mid;
}
}
cerr << l << endl;
ll ans = 0;
ans += sum[N - 1] - sum[l];
if ((2 * l - N + 1) % 2 == 0 && 2 * l - N + 1 >= 0)
ans += osum[2 * l - N + 1];
else if((2 * l - N + 1) >= 0)
ans += esum[2 * l - N + 1];
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
#define int long long
using namespace std;
int N,Q;
int a[100010];
bool check(int i,int x)
{
if(a[i]<x) return false;
int first=N-i;
int second=i-(lower_bound(a,a+N,2*x-a[i])-a)+1;
return first<=second;
}
signed main()
{
cin>>N>>Q;
for(int i=0;i<N;i++){
cin>>a[i];
}
vector<int> S(N+1),T(N+1);
for(int i=0;i<N;i++){
S[i+1]+=S[i]+a[i];
T[i+1]=(i>=1? T[i-1]:0)+a[i];
}
while(Q--){
int x; cin>>x;
int ng=0,ok=N;
while(ok-ng>1){
int mid=(ok+ng)/2;
if(check(mid,x)){
ok=mid;
}else{
ng=mid;
}
}
int ans=(S[N]-S[ok])+T[max(0LL,N-(N-ok)*2)];
cout<<ans<<endl;
}
}
|
p03158 | C++ | #include<iostream>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<stack>
using namespace std;
#define MOD 1000000007
#define REP(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {//グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to; cap = _cap; rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph& G, ll from, ll to, ll cap, bool revFlag, ll revCap) {//最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));//最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph & G, ll v, ll t, ll f, vector<bool> & used)
{
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph & G, ll s, ll t)
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size())used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph& G, ll s, Array& d, Array &negative) {//O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size())d[i] = INF;
REP(i, d.size())negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph& G, ll s, Array& d) {//O(|E|log|V|)
d.resize(G.size());
REP(i, d.size())d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph& G, Matrix& d) {
d.resize(G.size());
REP(i, d.size())d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) {
d[i][j] = INF;
}
}
REP(i, G.size()) {
d[i][i] = 0;
}
REP(i, G.size()) {
REP(j, G[i].size()) {
d[i][G[i][j].to] = G[i][j].cap;
}
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) {
chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
class UnionFind {
vector<int> data;
public:
UnionFind(int size) : data(size, -1) { }
bool unionSet(int x, int y) {
x = root(x); y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y]; data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) {
return root(x) == root(y);
}
int root(int x) {
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) {
return -data[root(x)];
}
};
//約数求める //約数
void divisor(ll n, vector<ll>& ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
//nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
}
ll nPr(ll n, ll r) {
return (fact[n] * inv[n - r]) % mod;
}
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
inv.resize(n + 1);
REP(i, n + 1) {
inv[i] = mod_inv(fact[i]);
}
}
};
ll gcd(ll m, ll n) {
if (n == 0)return m;
return gcd(n, m % n);
}//gcd
ll lcm(ll m, ll n) {
return m / gcd(m, n) * n;
}
int main() {
ll n, q;
cin >> n >> q;
Array a(n);
REP(i, n)cin >> a[i];
Array sum(n + 1, 0);
Array odd(n + 1, 0);
REP(i, n) {
sum[i + 1] = sum[i] + a[i];
if ((i + 1) % 2 == 1)odd[i + 1] = a[i];
odd[i + 1] += odd[i];
}
REP(i, q) {
ll x;
cin >> x;
ll l = -1, r = (ll)1e9+1;
while (r - l > 1) {
ll mid = (r + l) / 2;
auto secl = lower_bound(all(a), x - mid);
auto secr = upper_bound(all(a), x + mid);
if (secr - secl > a.end() - secr) {
r = mid;
}
else {
l = mid;
}
}
ll mid = (r + l) / 2;
auto secl = lower_bound(all(a), x - mid);
auto secr = upper_bound(all(a), x + mid);
ll taka = a.end() - secr;
if (secr - secl > taka) {
taka++;
}
ll ans = sum[n] - sum[n - taka];
if (taka * 2 >= n) {
cout << ans << endl;
continue;
}
if (n % 2 == 1) {
ans += odd[n - taka * 2];
}
else {
ans += sum[n - taka * 2] - odd[n - taka * 2];
}
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include<iostream>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<stack>
using namespace std;
#define MOD 1000000007
#define REP(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {//グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to; cap = _cap; rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph& G, ll from, ll to, ll cap, bool revFlag, ll revCap) {//最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));//最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph & G, ll v, ll t, ll f, vector<bool> & used)
{
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph & G, ll s, ll t)
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size())used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph& G, ll s, Array& d, Array &negative) {//O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size())d[i] = INF;
REP(i, d.size())negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph& G, ll s, Array& d) {//O(|E|log|V|)
d.resize(G.size());
REP(i, d.size())d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph& G, Matrix& d) {
d.resize(G.size());
REP(i, d.size())d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) {
d[i][j] = INF;
}
}
REP(i, G.size()) {
d[i][i] = 0;
}
REP(i, G.size()) {
REP(j, G[i].size()) {
d[i][G[i][j].to] = G[i][j].cap;
}
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) {
chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
class UnionFind {
vector<int> data;
public:
UnionFind(int size) : data(size, -1) { }
bool unionSet(int x, int y) {
x = root(x); y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y]; data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) {
return root(x) == root(y);
}
int root(int x) {
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) {
return -data[root(x)];
}
};
//約数求める //約数
void divisor(ll n, vector<ll>& ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
//nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
}
ll nPr(ll n, ll r) {
return (fact[n] * inv[n - r]) % mod;
}
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
inv.resize(n + 1);
REP(i, n + 1) {
inv[i] = mod_inv(fact[i]);
}
}
};
ll gcd(ll m, ll n) {
if (n == 0)return m;
return gcd(n, m % n);
}//gcd
ll lcm(ll m, ll n) {
return m / gcd(m, n) * n;
}
int main() {
ll n, q;
cin >> n >> q;
Array a(n);
REP(i, n)cin >> a[i];
Array sum(n + 1, 0);
Array odd(n + 1, 0);
REP(i, n) {
sum[i + 1] = sum[i] + a[i];
if ((i + 1) % 2 == 1)odd[i + 1] = a[i];
odd[i + 1] += odd[i];
}
REP(i, q) {
ll x;
cin >> x;
ll l = -1, r = (ll)1e9+1;
while (r - l > 1) {
ll mid = (r + l) / 2;
auto secl = lower_bound(all(a), x - mid);
auto secr = upper_bound(all(a), x + mid);
if (abs(secr - secl - (a.end() - secr)) < 2);/* {
break;
}
else*/ if (secr - secl > a.end() - secr) {
r = mid;
}
else {
l = mid;
}
}
ll mid = (r + l) / 2;
auto secl = lower_bound(all(a), x - mid);
auto secr = upper_bound(all(a), x + mid);
ll taka = a.end() - secr;
if (secr - secl > taka) {
// if(secr==a.end()||x-a[secl-a.begin()]<=a[secr-a.begin()]-x)taka++;
taka++;
}
ll ans = sum[n] - sum[n - taka];
if (taka * 2 >= n) {
cout << ans << endl;
continue;
}
if (n % 2 == 1) {
ans += odd[n - taka * 2];
}
else {
ans += sum[n - taka * 2] - odd[n - taka * 2];
}
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
long a[n];
for (auto &ai:a) cin >> ai;
int i = (n+1)%2,
j = n/2;
long border[n], sum[n];
sum[j] = 0;
for (int k=j; k<n; k++) sum[j] += a[k];
for ( ; j<n-1; j++) {
sum[j+1] = sum[j] - a[j] + a[i];
border[j] = (a[i] + a[j]) / 2;
i += 2;
}
border[n-1] = (long)1e9 + 1;
for (int k=0; k<q; k++) {
long x;
cin >> x;
long ans = lower_bound(border+n/2, border+n, x) - border;
cout << sum[ans] << '\n';
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <iomanip>
#include <ios>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
#include <queue>
#include <stack>
#include <set>
#include <cmath>
#include <bitset>
#include <map>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define sz(c) ((int)(c).size())
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
const int MAX=1e5+5;
int main(){
int N,Q;
cin>>N>>Q;
ll B[MAX];
rep1(i,N){
cin>>B[N+1-i];
}
if(N%2==0){
int h=N/2;
ll sm[MAX];
sm[1]=0;
rep1(i,N)if(i%2==1)sm[1]+=B[i];
for(int i=2;i<=h;i++){
sm[i]=sm[i-1]+B[i]-B[2*i-1];
}
ll pos[MAX];
pos[h]=0;
rep1(i,h-1)pos[i]=1+((B[i+1]+B[2*i+1])/2);
rep(i,Q){
ll x;
cin>>x;
int lb=0, ub=h;
while(ub-lb>1){
int mid=((ub+lb)/2);
if(pos[mid]<=x)ub=mid;
else lb=mid;
}
cout<<sm[ub]<<endl;
}
}
else{
int h=N/2;
ll sm[MAX];
sm[1]=0;
rep1(i,N)if(i%2==1)sm[1]+=B[i];
for(int i=2;i<=h+1;i++){
sm[i]=sm[i-1]+B[i]-B[2*i-1];
}
ll pos[MAX];
pos[h+1]=0;
rep1(i,h)pos[i]=1+((B[i+1]+B[2*i+1])/2);
rep(i,Q){
ll x;
cin>>x;
int lb=0, ub=h+1;
while(ub-lb>1){
int mid=((ub+lb)/2);
if(pos[mid]<=x)ub=mid;
else lb=mid;
}
cout<<sm[ub]<<endl;
}
}
} |
p03158 | C++ | #include<bits/stdc++.h>
#define X first
#define Y second
#define pb emplace_back
#define FOR(i,a,b) for(int (i)=(a);i<(b);++(i))
#define EFOR(i,a,b) for(int (i)=(a);i<=(b);++(i))
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define REP rep
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define all(X) (X).begin(),(X).end()
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef ll LL;
typedef pii PII;
typedef pll PLL;
const ll MOD=1e9+7;
#define rall(X) (X).rbegin(),(X).rend()
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rreps(X,S,Y) for (int (X) = (Y)-1;(X) >= (S);--(X))
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
int N;
int Q;
LL A[114514];
LL imos[2][114514];
LL rimos[114514];
signed main(){
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(0);
cin >> N >> Q;
rep(i, N) {
cin >> A[i];
}
imos[0][0] = imos[0][1] = A[0];
imos[1][0] = 0;
imos[1][1] = A[1];
reps(i, 2, N) {
rep(j, 2) {
imos[j][i] = imos[j][i-1];
}
imos[i%2][i] += A[i];
}
rrep(i, N) {
rimos[i] = rimos[i+1] + A[i];
}
rep(i, Q) {
LL X;
cin >> X;
if (A[N-2] <= X) {
//cout << "here\n";
cout << imos[1-N%2][N-1] << "\n";
continue;
}
LL low = -1;
LL high = int(1e9)+1;
while (high - low > 1) {
LL mid = (high+low)/2;
int r = upper_bound(A, A+N, X+mid) - A;
int l = lower_bound(A, A+N, X-mid) - A;
if (r-l <= N-r) low = mid;
else high = mid;
}
LL low2 = -1;
LL high2 = int(1e9)+1;
while (high2 - low2 > 1) {
LL mid = (high2+low2)/2;
int r = lower_bound(A, A+N, X+mid) - A;
int l = lower_bound(A, A+N, X-mid) - A;
if (r-l <= N-r) low2 = mid;
else high2 = mid;
}
if (low < low2) {
int r = lower_bound(A, A+N, X+low2) - A;
int l = lower_bound(A, A+N, X-low2) - A;
LL ans = rimos[r];
//assert(r-l == N-r);
//if (l >= 1) {
// ans += imos[(l-1)%2][l-1];
//}
if (r-l < N-r) {
assert(r-l+1 == N-r);
if (l >= 2) {
ans += imos[(l-2)%2][l-2];
}
} else {
assert(r-l == N-r);
if (l >= 1) {
ans += imos[(l-1)%2][l-1];
}
}
cout << ans << "\n";
} else {
int r = upper_bound(A, A+N, X+low) - A;
int l = lower_bound(A, A+N, X-low) - A;
LL ans = rimos[r];
if (r-l < N-r) {
assert(r-l+1 == N-r);
if (l >= 2) {
ans += imos[(l-2)%2][l-2];
}
} else {
assert(r-l == N-r);
if (l >= 1) {
ans += imos[(l-1)%2][l-1];
}
}
cout << ans << "\n";
}
}
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(a); (i)<(b); ++(i))
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
int n, q;
lint a[100010];
bool check(int mid, int x){
if(2*mid-n+1 < 0) return false;
return abs(a[2*mid-n+1] - x) <= abs(a[mid] - x);
}
int main(){
scanf("%d%d", &n, &q);
lint asum[n+1], evsum[(n+1)/2+1];
asum[0] = evsum[0] = 0;
rep(i, n){
scanf("%d", &a[i]);
asum[i+1] = asum[i] + a[i];
if(i%2 == 0) evsum[i/2+1] = evsum[i/2] + a[i];
}
rep(i, q){
int x;
scanf("%d", &x);
int ok = n-1;
int ng = 0;
while(ok - ng > 1){
int mid = (ok + ng) / 2;
if(check(mid, x)) ok = mid;
else ng = mid;
}
lint score = asum[n] - asum[ok];
int m = 2*ok-n-1;
if(m >= 0){
if(m%2 == 0) score += evsum[m/2+1];
else score += asum[m+1] - evsum[m/2+1];
}
printf("%lld\n", score);
}
} |
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 | C++ | /*
[aising2019] D - Nearest Card Game
*/
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int MAX_N = 1e5;
const int MAX_Q = 1e5;
int N, Q;
int A[MAX_N];
int X[MAX_Q];
ll s1[MAX_N + 1], s2[MAX_N + 1];
ll query(int x) {
int ng = -1;
int ok = N;
while (ok - ng > 1) {
int m = (ok + ng) / 2;
if (A[N - (m + 1) / 2 - 1] - x < x - A[N - m - 1]) {
ok = m;
} else {
ng = m;
}
}
return s1[N] - s1[N - (ok + 1) / 2] +
(N % 2 == 0 ? s1[N - ok] - s2[N - ok] : s2[N - ok]);
}
void solve() {
s1[0] = s2[0] = 0;
for (int i = 0; i < N; i++) {
s1[i + 1] += s1[i] + A[i];
s2[i + 1] += s2[i] + (i % 2 == 0 ? A[i] : 0);
}
for (int i = 0; i < Q; i++) {
cout << query(X[i]) << endl;
}
}
int main() {
cin >> N >> Q;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < Q; i++) {
cin >> X[i];
}
solve();
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#define NDEBUG
#define SHOW(...) static_cast<void>(0)
//!===========================================================!//
//! dP dP dP !//
//! 88 88 88 !//
//! 88aaaaa88a .d8888b. .d8888b. .d888b88 .d8888b. 88d888b. !//
//! 88 88 88ooood8 88' '88 88' '88 88ooood8 88' '88 !//
//! 88 88 88. ... 88. .88 88. .88 88. ... 88 !//
//! dP dP '88888P' '88888P8 '88888P8 '88888P' dP !//
//!===========================================================!//
template <typename T, typename A>
std::istream& operator>>(std::istream& is, std::vector<T, A>& v)
{
for (auto& e : v) { is >> e; }
return is;
}
template <typename T>
T read()
{
T v;
return std::cin >> v, v;
}
template <typename T>
std::vector<T> readVec(const std::size_t l)
{
std::vector<T> v(l);
for (auto& e : v) { std::cin >> e; }
return v;
}
using ld = long double;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr unsigned int MOD = 1000000007;
template <typename T>
constexpr T INF = std::numeric_limits<T>::max() / 4;
template <typename F>
constexpr F PI = static_cast<F>(3.1415926535897932385);
std::mt19937 mt{std::random_device{}()};
template <typename T>
bool chmin(T& a, const T& b) { return a = std::min(a, b), a == b; }
template <typename T>
bool chmax(T& a, const T& b) { return a = std::max(a, b), a == b; }
template <typename T>
std::vector<T> Vec(const std::size_t n, T v) { return std::vector<T>(n, v); }
template <class... Args>
auto Vec(const std::size_t n, Args... args) { return std::vector<decltype(Vec(args...))>(n, Vec(args...)); }
template <typename T>
constexpr T popCount(const T u)
{
#ifdef __has_builtin
return u == 0 ? T(0) : (T)__builtin_popcountll(u);
#else
unsigned long long v = static_cast<unsigned long long>(u);
return v = (v & 0x5555555555555555ULL) + (v >> 1 & 0x5555555555555555ULL), v = (v & 0x3333333333333333ULL) + (v >> 2 & 0x3333333333333333ULL), v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL, static_cast<T>(v * 0x0101010101010101ULL >> 56 & 0x7f);
#endif
}
template <typename T>
constexpr T log2p1(const T u)
{
#ifdef __has_builtin
return u == 0 ? T(0) : T(64 - __builtin_clzll(u));
#else
unsigned long long v = static_cast<unsigned long long>(u);
return v = static_cast<unsigned long long>(v), v |= (v >> 1), v |= (v >> 2), v |= (v >> 4), v |= (v >> 8), v |= (v >> 16), v |= (v >> 32), popCount(v);
#endif
}
template <typename T>
constexpr T clog(const T v) { return v == 0 ? T(0) : log2p1(v - 1); }
template <typename T>
constexpr T msbp1(const T v) { return log2p1(v); }
template <typename T>
constexpr T lsbp1(const T v)
{
#ifdef __has_builtin
return __builtin_ffsll(v);
#else
return v == 0 ? T(0) : popCount((v & (-v)) - T(1)) + T(1);
#endif
}
template <typename T>
constexpr bool ispow2(const T v) { return popCount(v) == 1; }
template <typename T>
constexpr T ceil2(const T v) { return v == 0 ? T(1) : T(1) << log2p1(v - 1); }
template <typename T>
constexpr T floor2(const T v) { return v == 0 ? T(0) : T(1) << (log2p1(v) - 1); }
//!============================================!//
//! 8888ba.88ba oo !//
//! 88 '8b '8b !//
//! 88 88 88 .d8888b. dP 88d888b. !//
//! 88 88 88 88' '88 88 88' '88 !//
//! 88 88 88 88. .88 88 88 88 !//
//! dP dP dP '88888P8 dP dP dP !//
//!============================================!//
int main()
{
const int N = read<int>(), Q = read<int>();
const auto A = readVec<ll>(N);
auto S1 = A, S2 = A;
for (int i = 1; i < N; i++) { S1[i] += S1[i - 1]; }
for (int i = 2; i < N; i++) { S2[i] += S2[i - 2]; }
for (int q = 0, x; q < Q; q++) {
std::cin >> x;
int inf = 0, sup = N; // 高橋君がA[sup,N)を取る
while (sup - inf > 1) {
const int mid = (sup + inf) / 2;
const ll D = A[mid] - x;
const int in = std::upper_bound(A.begin(), A.end(), x + D) - std::lower_bound(A.begin(), A.end(), x - D);
(in >= N - mid ? sup : inf) = mid;
}
const int U = N - sup;
const int M = inf - U;
ll ans = S1[N - 1] - S1[inf] + (M < 0 ? 0LL : S2[M]);
std::cout << ans << std::endl;
}
return 0;
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<int, pii> pipii;
typedef vector<vector<int> > mati;
typedef vector<vector<double> > matd;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
#define FOR(i,x,y) for(ll i=(ll)x; i<(ll)y; ++i)
#define REP(i,y) FOR(i, 0, y)
#define RFOR(i,x,y) for(ll i=(ll)x; i>=(ll)y; --i)
#define RREP(i,x) RFOR(i, x, 0)
inline void IN(void){
return;
}
template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){
cin >> first;
IN(rest...);
return;
}
inline void OUT(void){
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest){
cout << first << " ";
OUT(rest...);
return;
}
template <typename T>
void vec_print(vector<T> VEC){
REP(i, VEC.size()){
cout << VEC[i] << " ";
}
cout << "\n";
};
template <typename T>
void mat_print(vector<vector<T> > MAT){
REP(i, MAT.size()){
REP(j, MAT[i].size()){
cout << MAT[i][j] << " ";
}
cout << "\n";
}
};
template <typename CLASS1, typename CLASS2>
class HOGE{
public:
CLASS1 key;
CLASS2 value;
HOGE(void){
return;
};
HOGE(CLASS1 key, CLASS2 value){
this->key = key;
this->value = value;
};
~HOGE(void){
return;
};
void print(void){
cout << "key : " << key << ", value : " << value << "\n";
return;
};
bool operator==(const HOGE &obj){
return (this->value == obj.value);
};
bool operator<(const HOGE &obj){
return (this->value < obj.value);
};
bool operator>(const HOGE &obj){
return (this->value > obj.value);
};
};
template <typename CLASS1, typename CLASS2>
bool operator==(const HOGE<CLASS1, CLASS2> &hoge1, const HOGE<CLASS1, CLASS2> &hoge2){
return hoge1.value == hoge2.value;
};
template <typename CLASS1, typename CLASS2>
bool operator<(const HOGE<CLASS1, CLASS2> &hoge1, const HOGE<CLASS1, CLASS2> &hoge2){
return hoge1.value < hoge2.value;
};
template <typename CLASS1, typename CLASS2>
bool operator>(const HOGE<CLASS1, CLASS2> &hoge1, const HOGE<CLASS1, CLASS2> &hoge2){
return hoge1.value > hoge2.value;
};
constexpr int INF = (1<<30);
constexpr ll INFLL = 1LL<<62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9)+7);
int main(){
cin.tie(0); // cut the cin and cout (default, std::flush is performed after std::cin)
ios::sync_with_stdio(false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N, Q;
IN(N, Q);
vll A(N);
REP(i, N) IN(A[i]);
vll X(Q);
REP(i, Q) IN(X[i]);
sort(A.begin(), A.end());
ll noc = (N+1)/2;
vll sum1(noc), sum2(noc);
sum1[0] = A[A.size()-1];
FOR(i, 1, noc){
sum1[i] = sum1[i-1] + A[N-1-i];
}
sum2[0] = A[(N+1)%2];
FOR(i, 1, noc){
sum2[i] = sum2[i-1] + A[2*i+(N+1)%2];
}
vll B;
ll j_begin = 2;
ll j_end = 3;
while(N-j_end>=0){
B.push_back((A[N-j_begin]+A[N-j_end])/2);
j_begin++;
j_end+=2;
}
sort(B.begin(), B.end());
REP(i, Q){
if(X[i]<=(A[0]+A[N/2])/2){
cout << sum1[noc-1] << "\n";
continue;
}
if(X[i]>(A[N-2]+A[N-3])/2){
cout << sum2[noc-1] << "\n";
continue;
}
auto itr = lower_bound(B.begin(), B.end(), X[i]);
ll pos = (ll)(itr - B.begin());
if(pos>=noc){
cout << sum2[noc-1] << "\n";
}else if(pos<=0){
cout << sum1[noc-1] << "\n";
}else{
cout << sum1[noc-1-pos] + sum2[pos-1] << "\n";
}
}
return 0;
} |
p03158 | C++ | #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include<map>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include<fstream>
#include <unordered_map>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000000000000000000000001
#define LONG_INF 10000000000000000LL
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353
#define REP(i,n) for(long long i = 0;i < n;++i)
#define int long long
vector<int>a;
int solve(int now,int cnter) {
if (cnter == 0) return 1;
int tmp = a[a.size() - cnter] - now;
auto bobo = lower_bound(a.begin(), a.end(), now - tmp);
int geko = bobo - a.begin();
int cnt = a.size() - geko;
cnt -= cnter;
if (cnt+1 < cnter) {
return 0;
}
else if (cnt+1 == cnter) {
return 1;
}
else if (cnt+1 > cnter) {
return 2;
}
}
long long ruiseki[200000];
long long bobo_ruiseki[200000];
#undef int
int main(){
#define int long long
int n, query;
cin >> n >> query;
REP(i, n) {
int tmp;
cin >> tmp;
a.push_back(tmp);
ruiseki[i + 1] = ruiseki[i];
ruiseki[i + 1] += tmp;
bobo_ruiseki[i + 1] = bobo_ruiseki[i];
if ((n + 1) % 2 == i % 2) {
bobo_ruiseki[i + 1] += tmp;
}
}
sort(a.begin(), a.end());
REP(tea, query) {
int b;
cin >> b;
int bot = 0;
int top = a.size();
while (top - bot > 1) {
int mid = (top + bot) / 2LL;
if (solve(b, mid) != 0) {
bot = mid;
}
else {
top = mid;
}
}
int ans = 0;
ans += ruiseki[n];
ans -= ruiseki[n - bot];
ans += bobo_ruiseki[n - bot * 2];
cout << ans << endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<ll,pll> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-9;
const ll mod=1e9+7;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll n,q,N;
vl a,b,c;
bool f(ll m,ll x){;
int L=a[N-2*m+1],R=a[N-m-1];
return x-abs(x-a[N-m])<=L&&R<=a[N-m];
}
int main(){
cin>>n>>q;
N=3*n;
a=vl(N,-inf);
b=c=vl(N);
for(int i=2*n;i<N;i++){
cin>>a[i];
b[i]=c[i]=a[i];
}
for(int i=2*n;i<N;i++) b[i]+=b[i-2];
for(int i=N-2;i>=0;i--) c[i]+=c[i+1];
for(int i=0;i<q;i++){
ll x,l=0,r=n;
cin>>x;
while(r-l>1){
int m=(l+r)/2;
if(f(m,x)) l=m;
else r=m;
}
cout<<b[N-2*l-1]+c[N-l]<<endl;
}
} |
p03158 | C++ | #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#define rep(i,a,b) for (int i = (a); i < (b); i++)
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> P;
typedef complex<double> com;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const int inf = 2e9;
int main() {
int n,q; cin>>n>>q;
vector<int> a(n);
rep(i,0,n) cin>>a[i];
reverse(a.begin(),a.end());
vector<ll> sum(n+1,0),even(n+1,0);
rep(i,0,n){
sum[i+1]=sum[i]+a[i];
even[i+1]=even[i]+(i%2==0?a[i]:0);
}
vector<ll> idx,val;
rep(i,0,(n-1)/2){
ll j=(a[i+1]+a[2*i+2])/2+1;
ll k=(sum[i+1]-sum[0])+(even[n]-even[2*i+2]);
idx.push_back(j);
val.push_back(k);
}
reverse(idx.begin(),idx.end());
reverse(val.begin(),val.end());
rep(i,0,q){
ll x; cin>>x;
int ite=upper_bound(idx.begin(),idx.end(),x)-idx.begin();
if(ite==0) printf("%lld\n",sum[(n+1)/2]-sum[0]);
else printf("%lld\n",val[ite-1]);
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
#define chmin(a, b) ((a)=min((a), (b)))
#define chmax(a, b) ((a)=max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
const ll MOD=1e9+7;
const ll INF=1e18;
const double pi=acos(-1);
const double eps=1e-10;
int dx[]={1, 0, -1, 0};
int dy[]={0, -1, 0, 1};
int main(){
int n, q; cin>>n>>q;
vector<int> a(n);
vector<ll> sum(n+10, 0), divsum(n+10, 0);
for(int i=0; i<n; i++){
cin>>a[i];
sum[i+1] = sum[i] + a[i];
divsum[i+1] = a[i];
if(2 <= i) divsum[i+1] += divsum[i-1];
}
for(int i=0; i<q; i++){
int x; cin>>x;
int ng = 0, ok = n - 1;
int ub, lb;
while(ok - ng > 1){
int mid = (ng + ok) / 2;
if(a[mid] < x){
ng = mid;
}
else{
ub = n - mid;
lb = lower_bound(a.begin(), a.end(), a[mid]) - lower_bound(a.begin(), a.end(), 2 * x - a[mid]) + 1;
if(lb < ub) ng = mid;
else ok = mid;
}
}
ll ans = sum[n] - sum[ok];
int Tturn = n - (n - ok) * 2;
ans += divsum[max(Tturn, 0)];
cout << ans << endl;
}
} |
p03158 | C++ | #include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
#define chmin(a, b) ((a)=min((a), (b)))
#define chmax(a, b) ((a)=max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
const ll MOD=1e9+7;
const ll INF=1e18;
const double pi=acos(-1);
const double eps=1e-10;
int dx[]={1, 0, -1, 0};
int dy[]={0, -1, 0, 1};
int main(){
int n, q; cin>>n>>q;
vector<int> a(n);
vector<ll> sum(n+10, 0), divsum(n+10, 0);
for(int i=0; i<n; i++){
cin>>a[i];
sum[i+1] = sum[i] + a[i];
divsum[i+1] = a[i];
if(2 <= i) divsum[i+1] += divsum[i-1];
}
for(int i=0; i<q; i++){
int x; cin>>x;
int ng = 0, ok = n;
int ub, lb;
while(ok - ng > 1){
int mid = (ng + ok) / 2;
if(a[mid] < x){
ng = mid;
}
else{
ub = n - mid;
lb = lower_bound(a.begin(), a.end(), a[mid]) - lower_bound(a.begin(), a.end(), 2 * x - a[mid]) + 1;
if(lb < ub) ng = mid;
else ok = mid;
}
}
ll ans = sum[n] - sum[ok];
int Tturn = n - (n - ok) * 2;
ans += divsum[max(Tturn, 0)];
cout << ans << endl;
}
} |
p03158 | C++ | #include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
#include <iomanip>
//#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>
const int MAX_N = 100050;
const int MAX_Q = 100050;
int N, Q;
long long A[MAX_N];
long long X[MAX_Q];
long long ac[MAX_N] = {};
long long half_ac[MAX_N] = {};
int num_lesser(long long val) {
if (val <= A[1]) {
return 0;
}
if (A[N] < val) {
return N;
}
int lb = 1;
int ub = N;
while (lb + 1 < ub) {
int mid = (lb + ub) / 2;
if (A[mid] < val) {
lb = mid;
} else {
ub = mid;
}
}
return lb;
}
long long cal_rad(long long center) {
long long lb = 0;
long long ub = A[N];
while (lb + 1 < ub) {
int mid = (lb + ub) / 2;
if (num_lesser(center + mid) - num_lesser(center - mid) <= N - num_lesser(center + mid)) {
lb = mid;
} else {
ub = mid;
}
}
return lb;
}
long long solve(long long center) {
if (A[N-1] <= center) {
return half_ac[N];
}
long long ret = 0;
long long rad = cal_rad(center);
//std::cout << "check:" << center << " " << rad << " " << num_lesser(center + rad) << " " << num_lesser(center - rad) << std::endl;
int aoki_get_num = num_lesser(center + rad) - num_lesser(center - rad);
int aoki_not_get_idx = num_lesser(center + rad) + 1;
int takahashi_get_idx = N - aoki_get_num + 1;
int half_begin = num_lesser(center - rad);
//std::cout << rad << " " << aoki_get_num << " " << aoki_not_get_idx << " " << takahashi_get_idx << " " << half_begin << std::endl;
if (aoki_not_get_idx < takahashi_get_idx) {
takahashi_get_idx--;
if (aoki_not_get_idx == takahashi_get_idx) {
half_begin--;
}
}
//assert(takahashi_get_idx == aoki_not_get_idx);
half_begin = std::max(0, half_begin);
return ac[N] - ac[takahashi_get_idx-1] + half_ac[half_begin];
}
int main(int argc, char **argv) {
std::cin >> N >> Q;
for (int i = 1; i <= N; i++) {
std::cin >> A[i];
}
for (int i = 1; i <= Q; i++) {
std::cin >> X[i];
}
ac[1] = A[1];
half_ac[1] = A[1];
for (int i = 2; i <= N; i++) {
ac[i] = ac[i-1] + A[i];
half_ac[i] = half_ac[i-2] + A[i];
}
for (int i = 1; i <= Q; i++) {
std::cout << solve(X[i]) << std::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 + 1, 0);
vector<ll> x(Q);
for (int i = 1; i <= N; ++i) { cin >> a[i]; }
for (int i = 0; i < Q; ++i) { cin >> x[i]; }
vector<ll> dr(N + 1, 0);
dr[N] = a[N];
for (int i = N - 1; i > 0; --i) { dr[i] += dr[i + 1] + a[i]; }
vector<ll> dc(N + 1, 0);
for (int i = 1; i <= N; ++i) {
if (N % 2 == 1) {
dc[i] = (i % 2 == 1 ? a[i] : 0);
} else {
dc[i] = (i % 2 == 0 ? a[i] : 0);
}
}
for (int i = 1; i <= N; ++i ) { dc[i] += dc[i - 1]; }
for (int q = 0; q < Q; ++q) {
ll X = x[q];
int l = 1, r = N;
while (r - l > 1) {
int mid = (l + r) / 2;
int tl = mid, tr = (N - mid + 1) / 2 + mid - 1;
if ((abs(a[tl - 1] - X) > abs(a[tl] - X)) && (abs(a[tl - 1] - X) > abs(a[tr] - X))) {
l = mid;
} else {
r = mid;
}
}
int idx = (N - l + 1) / 2 + l;
ll res = dc[l - 1] + dr[idx];
cout << res << endl;
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <algorithm>
using namespace std;
long A[100000];
long sum_all[100001];
long sum_odd[100001];
long sum_even[100001];
int main(){
int N, Q;
cin >> N >> Q;
for(int i = 0; i < N; i++) {
cin >> A[i];
sum_all[i+1] = sum_all[i]+A[i];
if(i == 0) sum_even[0] = A[0];
if(i%2 == 0 && i-2 >= 0) sum_even[i] = sum_even[i-2]+A[i];
if(i == 1) sum_odd[1] = A[1];
if(i%2 == 1 && i-2 >= 0) sum_odd[i] = sum_odd[i-2]+A[i];
}
for(int i = 0; i < Q; i++) {
long X;
cin >> X;
long l = 1; long r = N;
while(r-l > 1){
long c = (l+r)/2;
long n = A[N-c];
long *p = lower_bound(A, A+N, 2*X-n);
if(&A[N-c]-p >= c-1) l = c;
else r = c;
}
//cout << l << ' ' << N-2*l-1 << endl;
long ans = sum_all[N]-sum_all[N-l];
if(N-2*l-1 >= 0){
if(N%2 == 0) ans += sum_odd[N-2*l-1];
else ans += sum_even[N-2*l-1];
}
cout << ans << endl;
}
} |
p03158 | C++ | #include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <queue>
#include <string>
#include <set>
#include <map>
#include <cassert>
#include <fstream>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
vector<long long> a(n);
vector<long long> a_o(n);
vector<long long> a_e(n);
vector<long long> a_s(n);
for (int i = 0; i < n; ++i)
{
cin >> a[i];
if ((i + 1) % 2)
{
a_o[i] += a[i];
}
else
{
a_e[i] += a[i];
}
a_s[i] += a[i];
if (i > 0)
{
a_o[i] += a_o[i - 1];
a_e[i] += a_e[i - 1];
a_s[i] += a_s[i - 1];
}
}
for (int query = 0; query < q; ++query)
{
long long x;
cin >> x;
auto itr = lower_bound(a.begin(), a.end(), x);
if (*itr != x && itr != a.begin())
{
itr--;
}
int startpos = itr - a.begin();
int endpos = n - 1;
while (endpos - startpos > 1)
{
int mid = (startpos + endpos) / 2;
auto itr = lower_bound(a.begin(), a.end(), (2 * x - a[mid]));
int pos = itr - a.begin();
if (mid - pos + 1 > n - 1 - mid)
{
endpos = mid;
}
else if (mid - pos + 1 < n - 1 - mid)
{
startpos = mid;
}
else
{
startpos = mid;
break;
}
}
long long right = 0;
long long left = 0;
right = a_s[n - 1] - a_s[startpos];
int num = n - 1 - startpos;
if (startpos - num > -1)
{
if (n % 2)
{
left = a_o[startpos - num];
}
else
{
left = a_e[startpos - num];
}
}
long long ret = left + right;
cout << ret << endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
int main(){
int n, q; cin >> n >> q; n++;
vector<long long> a(n), sum_odd(n), sum_even(n), sum(n);
for(int i = 1; i < n; i++){
int x; cin >> x;
a[i] = x;
sum_odd[i] = (i&1)*a[i] + sum_odd[i - 1];
sum_even[i] = ((i&1)^1)*a[i] + sum_even[i - 1];
sum[i] = a[i] + sum[i - 1];
}
for(int i = 0; i < q; i++){
int x; cin >> x;
int l = 1, r = n;
while(r - l > 1){
int m = (l + r)/2;
if(a[n - m] <= x) r = m;
else if(2*m - 1 > n - 1) r = m;
else if(a[n - m]-x >= x-a[n-2*m+1]) l = m;
else r = m;
}
long long res = sum[n - 1] - sum[n - l - 1];
int l1 = n - 2*l - 1;
if(l1 > 0)
res += (l1&1)*sum_odd[l1] + ((l1&1)^1)*sum_even[l1];
cout << res << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll<<50;
template<typename T>
void printv(const vector<T>& s) {
for(int i=0;i<(int)(s.size());++i) {
cout << s[i];
if(i == (int)(s.size())-1) cout << endl;
else cout << " ";
}
}
int main () {
cin.tie(0);
cout << fixed << setprecision(10);
int n, q; cin >> n >> q;
vector<ll> a(n);
for(int i=0;i<n;++i) {
cin >> a[i];
}
reverse(a.begin(), a.end());
vector<ll> sum(n+1), evensum(n+1);
for(int i=0;i<n;++i) {
sum[i+1] = sum[i] + a[i];
evensum[i+1] = evensum[i] + (i % 2 == 0 ? a[i] : 0);
}
vector<ll> ths, vals;
for(int i=0;i<(n-1)/2;++i) {
ll th = (a[i+1] + a[i*2+2])/2 + 1;
ll val = (sum[i+1] - sum[0]) + (evensum[n] - evensum[i*2+2]);
ths.push_back(th);
vals.push_back(val);
}
reverse(ths.begin(), ths.end());
reverse(vals.begin(), vals.end());
for(int i=0;i<q;++i) {
ll x; cin >> x;
int it = upper_bound(ths.begin(), ths.end(), x) - ths.begin();
if(it == 0) cout << sum[(n+1)/2] - sum[0] << endl;
else cout << vals[it-1] << endl;
}
}
|
p03158 | C++ | #include <cstdio>
#include <unordered_map>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
const int N = 1e5 + 1;
int a[N];
long long f[N], g[N];
int L, R;
int n, q;
void get(int l, int r, int ll, int rr)
{
if (a[r] < ll || rr < a[l]) return;
if (ll <= a[l] && a[r] <= rr) {
L = min(L, l), R = max(R, r);
return;
}
get(l, (l + r) / 2, ll, rr);
get((l + r) / 2 + 1, r, ll, rr);
}
int check(int mid, int r)
{
if (mid >= a[n])
{
printf("%lld\n", g[n]);
return 0;
}
if (mid <= a[1])
{
printf("%lld\n", f[n] - f[n / 2]);
return 0;
}
L = n, R = 1;
get(1, n , mid - r, mid + r);
if (n - (R - L) == R + 1)
{
printf("%lld\n", g[L - 1] + f[n] - f[R]);
return 0;
}
if (n - (R - L) > R + 1) {
if (L == 1)
{
int rr = n - (R - L) - 1, ll = R + 1;
printf("%lld\n", f[rr] - f[(ll + rr - 1) / 2] + f[n] - f[rr]);
return 0;
}
return 1;
}
if (abs(a[L] - mid) <= abs(a[R] - mid))
R --;
else
L ++;
if (n - (R - L) == R + 2)
{
if (L - 2 >= 0)
printf("%lld\n", f[n] - f[R] + g[L - 2]);
else
printf("%lld\n", f[n] - f[R]);
return 0;
}
if (n - (R - L) > R + 1)
return 1;
if (n - (R - L) == R + 1)
{
printf("%lld\n", g[L - 1] + f[n] - f[R]);
return 0;
}
return -1;
}
int main()
{
scanf("%d %d", &n, &q);
for (int i = 1; i <= n ; i ++) {
scanf("%d", &a[i]);
f[i] = f[i - 1] + a[i];
if (i == 1) g[i] = a[i];
else
g[i] = g[i - 2] + a[i];
}
while (q --)
{
int x ;
scanf("%d", &x);
int l = 0, r = 1e9, mid, s;
while (l <= r)
{
int sig = check(x, mid = (l + r) / 2);
if (sig > 0)
l = mid + 1;
else
if (sig < 0)
r = mid - 1;
else
break;
}
}
return 0;
} |
p03158 | C++ | #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>
#include<bitset>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define m0(x) memset(x,0,sizeof(x))
#define print(x) cout<<x<<endl;
#define pe(x) cout<<x<<" ";
#define lb(v,n) lower_bound(v.begin(), v.end(), n);
#define ub(v,n) upper_bound(v.begin(), v.end(), n);
#define int long long
#define all(x) (x).begin(), (x).end()
using namespace std;
const int MAX = 1010;
const int MOD = (ll)1000000000 + 7;
const ll INF = 1e17;
const double pi = acos(-1);
const double EPS = 1e-10;
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
typedef pair<int, int>P;
int dx[4] = { 1,0,-1,0 };//D,R,U,L
int dy[4] = { 0,1,0,-1 };
int N, Q;
int a[100010], x[100010], cum2[100010];
vector<int>sum, bor, vec,cum;
signed main() {
m0(cum2);
cum.pb(0);
cin >> N >> Q;
REP(i, N) {
cin >> a[i];
cum2[i + 1] = a[i];
if (N % 2 != i % 2) {
cum.pb(a[i]);
vec.pb(a[i]);
}
}
REP(i, Q)cin >> x[i];
REP(i, N) {
cum2[i + 1] += cum2[i];
}
REP(i, (N + 1) / 2) {
cum[i + 1] += cum[i];
}
bor.pb(-1 * INF); bor.pb(INF);
int cnt = 0;
while (cnt < (N - 1) / 2) {
int r = N - 2 - cnt;
int l = N - 3 - 2 * cnt;
bor.pb((a[l] + a[r]) / 2);
cnt++;
}
REP(i, (N + 1) / 2) {
int res = cum[i] + cum2[N] - cum2[N - (N+1)/2+i];
sum.pb(res);
}
VSORT(sum); VREVERSE(sum);
VSORT(bor);
REP(i, Q) {
auto itr = lb(bor,x[i]);
int it = itr - bor.begin();
print(sum[it-1]);
}
/*for (auto y : bor) {
pe(y);
}cout << endl;
for (auto y : sum) {
pe(y);
}cout << endl;
REP(i, N)pe(cum2[i + 1]); cout << endl;
REP(i, (N + 1) / 2)pe(cum[i + 1]); cout << endl;*/
}
|
p03158 | C++ | #include <bits/stdc++.h>
#define FOR(v, a, b) for(int v = (a); v < (b); ++v)
#define FORE(v, a, b) for(int v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for(int v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for(auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for(auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c,x) ((c).find(x) != (c).end())
#define LLI long long int
#define fst first
#define snd second
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(x) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n){return m/gcd(m,n)*n;}
template <typename I> void join(ostream &ost, I s, I t, string d=" "){for(auto i=s; i!=t; ++i){if(i!=s)ost<<d; ost<<*i;}ost<<endl;}
template <typename T> istream& operator>>(istream &is, vector<T> &v){for(auto &a : v) is >> a; return is;}
template <typename T, typename U> istream& operator>>(istream &is, pair<T,U> &p){is >> p.first >> p.second; return is;}
template <typename T, typename U> bool chmin(T &a, const U &b){return (a>b ? a=b, true : false);}
template <typename T, typename U> bool chmax(T &a, const U &b){return (a<b ? a=b, true : false);}
template <typename T, size_t N, typename U> void fill_array(T (&a)[N], const U &v){fill((U*)a, (U*)(a+N), v);}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N,Q;
while(cin >> N >> Q){
vector<LLI> a(N); cin >> a;
vector<LLI> xs(Q); cin >> xs;
vector<LLI> sum_odd(N+2);
vector<LLI> sum_even(N+2);
REP(i,N) sum_even[i+1] += sum_even[i] + (i%2==1?a[i]:0);
REP(i,N) sum_odd[i+1] += sum_odd[i] + (i%2==0?a[i]:0);
// assert(N%2==0);
vector<LLI> sum(N+1);
REP(i,N) sum[i+1] += sum[i] + a[i];
for(auto x : xs){
auto f = [&](LLI k){return abs(a[N-(k+1)/2-1]-x) < abs(a[N-k-1]-x);};
int lb=0, ub=N, mid;
while(abs(lb-ub) > 1){
mid = (lb+ub)/2;
if(f(mid)){
ub = mid;
}else{
lb = mid;
}
}
int t = ub;
dump(t);
LLI ans = sum[N]-sum[N-(t+1)/2];
if(N%2==0) ans += sum_even[N-t] - sum_even[0];
else ans += sum_odd[N-t] - sum_odd[0];
cout << ans << endl;
}
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i,n) for(int i=0;i<(int)n;++i)
//debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class S, class T> ostream& operator << (ostream& os, const pair<S, T> v){
os << "(" << v.first << ", " << v.second << ")"; return os;
}
template<class T> ostream& operator << (ostream& os, const vector<T> v){
for(int i = 0; i < v.size(); i++){if(i > 0){os << " ";} os << v[i];} return os;
}
template<class T> ostream& operator << (ostream& os, const vector<vector<T>> v){
for(int i = 0; i < v.size(); i++){if(i > 0){os << endl;} os << v[i];} return os;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N, Q;
cin >> N >> Q;
vector<ll> A(N);
REP(i, N) cin >> A[i];
vector<ll> S(N+1, 0), O(N+1, 0), E(N+1, 0);
REP(i, N){
S[i+1] = S[i] + A[i];
if(i%2 == 0){
E[i+1] = E[i] + A[i];
O[i+1] = O[i];
}else{
E[i+1] = E[i];
O[i+1] = O[i] + A[i];
}
}
//cout << endl;
//cout << A << endl;
//cout << S << endl;
//cout << E << endl;
//cout << O << endl;
REP(i, Q){
ll X;
cin >> X;
ll res = 0;
if(N%2 == 0){
ll l = 0;
ll u = N/2;
while(u-l > 1){
ll m = (u+l)/2;
if(abs(A[N-2*m-1] - X) > abs(A[N-m-1] - X)){
u = m;
}else{
l = m;
}
}
res += (S[N] - S[N-u]);
res += (O[N-2*u] - O[0]);
}else{
ll l = 0;
ll u = N/2 + 1;
while(u-l > 1){
ll m = (u+l)/2;
if(abs(A[N-2*m-1] - X) > abs(A[N-m-1] - X)){
u = m;
}else{
l = m;
}
}
if(u == N/2+1){
res += (S[N] - S[N/2]);
}else{
res += (S[N] - S[N-u]);
res += (E[N-2*u] - E[0]);
}
}
cout << res << endl;
}
return 0;
} |
p03158 | C++ | #include <iostream>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <queue>
#include <map>
#include <numeric>
#include <unordered_map>
#include <iomanip>
#include <functional>
#include <bitset>
#include <complex>
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);i++)
#define all(x) (x).begin(),(x).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 (b<a) { a=b; return 1; } return 0; }
typedef long long ll;
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n,q;
cin>>n>>q;
vector<ll>a(n),sa(n),sa2(n);
rep(i,n)cin>>a[i];
sa[0]=a[0];
sa2[0]=a[0];
sa2[1]=a[1];
rep(i,n-1)
{
sa[i+1]+=sa[i]+a[i+1];
}
repi(i,2,n)
{
sa2[i]+=sa2[i-2]+a[i];
}
auto fsa=[&](ll i){if(i<0)return 0LL;return sa[i];};
auto fsa2=[&](ll i){if(i<0)return 0LL;return sa2[i];};
//cout<<endl;
auto check=[&](ll idx,ll x){auto id=lower_bound(all(a),2*x-a[idx])-a.begin();return id+n-1-idx>idx;};
rep(i,q)
{
ll x;
cin>>x;
ll ix=lower_bound(all(a),x)-a.begin();
if(ix>0)
{
if(a[ix]-x>=x-a[ix-1])ix--;
}
if(ix>=n-1){cout<<sa2[n-1]<<"\n";continue;}
if(ix==0){cout<<sa[n-1]-sa[(n-2)/2]<<"\n";continue;}
ll ng=n-1,ok=ix;
while(ng-ok>1)
{
ll mid=(ok+ng)/2;
if(check(mid,x))ok=mid;
else ng=mid;
}
ll l=min(ix,(ll)(lower_bound(all(a),2*x-a[ok])-a.begin())),r=ok,rr=l+n-1-r;
//cout<<x<<"lr"<<l<<r<<rr<<endl;
ll res=fsa(n-1)-fsa(rr-1);
//cout<<res<<endl;
while(r!=rr)
{
rr--;
if(r==rr){res+=fsa2(l-1);break;}
res+=a[rr];
if(l-1>=0&&x-a[l-1]<=a[r+1]-x)l--;
else r++;
if(r==rr){res+=fsa2(l-2);break;}
}
cout<<res<<"\n";
}
cout<<flush;
return 0;
}
|
p03158 | C++ |
#include <queue>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <map>
#include <stdio.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for(int i = (a); i < (int)(b); i++)
#define MAX(a, b) ((ll)(a) > (ll)(b)) ? (a) : (b)
#define MIN(a, b) ((ll)(a) > (ll)(b)) ? (b) : (a)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vint;
typedef vector<string> vstr;
typedef pair<ll, ll> pint;
unsigned long long inf = (1LL << 62);
ll mod = 1000000007;
pint dx[4] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1}};
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;
if (2 * a < mid) a++;
int l = N - mid;
int r = N - a;
// take [l, r]
if (lt(x, r, 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;
cin >> N >> Q;
for (int i = 0; i < N; ++i) cin >> 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;
cin >> x;
long long ans = query(x);
printf("%lld\n", ans);
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define dump(x) cout << (x) << '\n';
typedef int64_t Int;
Int mod = 1e9+7;
Int INF = 1e9+18;
Int n, q;
Int a[100005];
Int x[100001];
int main() {
ios::sync_with_stdio(false);
cin >> n >> q;
a[0] = -INF;
a[n + 1] = INF;
for (Int i = 1; i <= n; i++) cin >> a[i];
for (Int i = 0; i < q; i++) cin >> x[i];
vector<Int> c(n + 1, 0), d(n + 1, 0);
for (Int i = 1; i <= n; i++) c[i] = a[i];
for (Int i = n; i > 1; i--) c[i - 1] += c[i];
if (n % 2 == 1) {
for (Int i = 1; i <= n; i++) d[i] = i % 2 == 1 ? a[i] : a[i - 1];
}
else {
for (Int i = 2; i <= n; i++) d[i] = i % 2 == 0 ? a[i] : a[i - 1];
}
for (Int i = 1; i <= n - 2; i++) d[i + 2] += d[i];
for (Int i = 0; i < q; i++) {
Int l = 0;
Int r = n + 1;
while (abs(r - l) > 1) {
Int mid = (l + r) / 2;
Int cur = mid;
Int A = (n + cur) / 2;
Int B = cur + 1;
// cout << l << " " << r << endl;
if (abs(x[i] - a[cur]) <= abs(a[A] - x[i])) {
r = mid;
}
else {
l = mid;
}
//cout << endl;
}
//cout << l << " " << r << endl;
//cout << c[r + (n - l) / 2] << " " << d[l] << endl;
dump(c[r + (n - l) / 2] + d[l]);
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, Q;
cin >> N >> Q;
vector<int> A(N);
for(int i=0; i<N; ++i) cin >> A[i];
vector<long long> sum(N + 1, 0), sumeven(N + 1, 0);
for(int i=0; i<N; ++i) {
sum[i + 1] = sum[i] + A[i];
sumeven[i + 1] = sumeven[i];
if(i % 2 == 0) sumeven[i + 1] += A[i];
}
for(int q=0; q<Q; ++q) {
int x;
cin >> x;
auto itx = upper_bound(begin(A), end(A), x);
if(itx == end(A)) {
if(N % 2) cout << sumeven[N] << endl;
else cout << sum[N] - sumeven[N] << endl;
continue;
}
--itx;
int left = itx - begin(A);
int right = N;
while(right - left > 1) {
int mid = (left + right) / 2;
auto itr = lower_bound(begin(A), end(A), 2 * x - A[mid]);
int cnt = mid + 1 - (itr - begin(A));
if(N - cnt > mid) left = mid;
else right = mid;
}
long long res = sum[N] - sum[left + 1];
if(N % 2 == 0) res += sum[max(0, 2 * left - N + 2)] - sumeven[max(0, 2 * left - N + 2)];
else res += sumeven[max(0, 2 * left - N + 2)];
cout << res << endl;
}
} |
p03158 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
#define INF (1<<30)
using namespace std;
int main(){
int N,Q;cin>>N>>Q;
vector<int> nos(N);
for(int i=0;i<N;i++) cin>>nos[i];
reverse(nos.begin(),nos.end());
vector<pair<int,int>> queries(Q);
for(int i=0;i<Q;i++) cin>>queries[i].first;
for(int i=0;i<Q;i++) queries[i].second = i;
sort(queries.begin(),queries.end());
vector<pair<int,int>> intervals;
for(int i=0;i<nos.size();i++){
int l = -INF, r = INF;
if(2*i < nos.size()) l = (nos[i] + nos[2*i])/2 + 1;
if(i%2 == 0) r = (nos[i/2] + nos[i])/2;
intervals.push_back(make_pair(l,nos[i]));
intervals.push_back(make_pair(r+1,-nos[i]));
}
sort(intervals.begin(), intervals.end());
long long total = 0;
vector<long long> ans(Q);
for(int i=0,j=0;i<queries.size();i++){
int x = queries[i].first;
while(intervals[j].first <= x) total += intervals[j++].second;
ans[queries[i].second] = total;
}
total = 0;
for(int i=0;i<N;i++) total += nos[i];
for(int i=0;i<Q;i++) cout<<total - ans[i]<<endl;
return 0;
} |
p03158 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
#define all(c) c.begin(), c.end()
using namespace std;
typedef long long ll;
int main() {
int n,m;
cin >> n >> m;
vector<int> a(n+1, -(1 << 30));
for(int i=1;i<=n;++i) cin >> a[i];
int max_a = *max_element(all(a));
vector<vector<ll>> total(2, vector<ll>(n+1, 0)); // インデックスが偶数の累積和，インデックスが奇数の累積和
total[1][1] = a[1];
for(int j=2;j<=n;++j) {
total[j%2][j] = total[j%2][j-2] + a[j];
total[1-j%2][j] = total[1-j%2][j-1];
}
int q;
for(int i=0;i<m;++i) {
cin >> q;
// 青木くんが最初に取るカードのインデックス
int nearest_i = distance(a.begin(), lower_bound(all(a), q));
if(abs(a[nearest_i-1]-q ) <= abs(a[nearest_i]-q)) {
--nearest_i;
}
// 青木くんと高橋くんの戦略が一致
if(nearest_i >= n) {
cout << total[n%2][n] << endl;
continue;
}
// 高橋くん区間の開始インデックスを探索
int ng = nearest_i, ok = n;
int mid = n;
while(ok-ng > 1) {
mid = (ng+ok)/2;
// 青木くんと高橋くんそれぞれから見た a[mid] の優先順位
int aoki_rank = mid - distance(a.begin(), lower_bound(all(a), q - (a[mid]-q))) + 1;
int takahashi_rank = n - mid + 1;
if(aoki_rank < takahashi_rank) {
ng = mid;
} else {
ok = mid;
}
}
int aoki_left = n - (n-ok+1)*2 + 1;
cout << (aoki_left?total[1-aoki_left%2][aoki_left-1]:0) + total[0][n]+total[1][n]-total[0][ok-1]-total[1][ok-1] << endl;
}
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<ll,ll> P;
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define fr(i,n) for(int i=0;i<n;i++)
#define Fr(i,n) for(int i=0;i++<n;)
#define ifr(i,n) for(int i=n-1;i>=0;i--)
#define iFr(i,n) for(int i=n;i>0;i--)
ll n,q,a[100010],x,s[100010]={},s2[100010]={};
void init(){
ifr(i,n) s[i]=s[i+1]+a[i];
fr(i,n) s2[i+2]=s2[i]+a[i];
}
ll solve(ll x){
ll l=-1,r=1e9,m,i1,i2,i3,i4;
while(r-l>1){
m=(l+r)/2;
i1=lb(a,a+n,x-m)-a;
i2=lb(a,a+n,x+m)-a-1;
i3=ub(a,a+n,x+m)-a-1;
if(2*i3-i1+3<n) l=m;
else if(2*i3-i1+3==n) return s[i3+1]+s2[i1];
else if(2*i3-i1+2==n) return s[i3+1]+s2[i1+1];
else if(2*i2-i1+3==n) return s[i2+1]+s2[i1];
else if(2*i3-i1+2==n) return s[i3+1]+s2[i1+1];
else r=m;
}
}
int main(){
cin>>n>>q;
fr(i,n) cin>>a[i];
init();
fr(i,q){
cin>>x;
cout<<solve(x)<<endl;
}
} |
p03158 | C++ | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int b_s(long key, vector<long> &V){
int ok=0, ng=V.size();
while(ok+1<ng){
int mid=(ok+ng)/2;
if(V[mid]<key) ok=mid;
else ng=mid;
}
return ng;
}
int main() {
int N, Q;
long A[100010];
cin >> N >> Q;
for(int i=0; i<N; ++i) cin >> A[i];
sort(A, A+N);
long cnt=0;
for(int i=N/2; i<N; ++i) cnt += A[i];
int le=1-N%2, ri=N/2;
vector<long> v(1, 0), ans(1, cnt);
while(le<ri){
v.push_back((A[le]+A[ri])/2);
ans.push_back(cnt);
cnt -= A[ri]-A[le];
le += 2;
++ri;
}
v.push_back(1e10);
ans.push_back(cnt);
for(int i=0; i<Q; ++i){
long X; cin >> X;
cout << ans[b_s(X, v)] << endl;
}
// for(int i=0; i<v.size(); ++i) cout << v[i] << ' ' << ans[i] << endl;
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <bits/stdc++.h>
#include <time.h>
#include <sys/timeb.h>
#include <cstdio>
#include <sys/time.h>
using namespace std;
#define ll long long
#define uint unsigned int
#define ulong unsigned long long int
#define Vec vector
Vec<ll> A;
Vec<ll> X;
Vec<Vec<ll>> S(2);
template<typename T> bool InRange(T t, T l, T r){ return l <= t && t < r; }
bool possible(int c, int idx, ll x, Vec<ll> &a){
// 高橋君が右側c個取れる．青木君はidxから始まる
// atatataaAatttT c == 4
int N = a.size();
if(c == 1) return true;
if(N - c <= idx) return false;
if(2 * c - 2 >= N) return false;
// 高橋君が右側c-1個取り終わっていて，
// 青木君がc-1個目としてA[N-c]を必ず取らなければいけない場合はfalse，
// それ以外はtrue
// 右にまだ余裕がある
if(idx + (c - 2) < N - c) return true;
// 右はN-c-1まで取っているとして，N-cを取るより左側をとる方が理にかなっている
int nl = N - c - 1 - (c - 2);
if(nl < 0) return false;
if(abs(a[nl] - x) <= abs(a[N - c] - x)) return true;
return false;
}
int main(){
int N,Q;
cin >> N >> Q;
A.resize(N);
X.resize(Q);
for(int i=0;i<N;i++) scanf("%d",&A[i]);
for(int i=0;i<Q;i++) scanf("%d",&X[i]);
;
for(int i=0;i<2;i++) S[i].resize(N + 1);
for(int i=0;i<N;i++){
for(int j=0;j<2;j++){
S[j][i + 1] = S[j][i] + (i % 2 == j ? A[i] : 0);
}
}
Vec<ll> ans(Q);
for(int i=0;i<Q;i++){
ll x = X[i];
auto itr = lower_bound(A.begin(), A.end(), x);
int idx = itr - A.begin();
if(idx >= N) idx = N - 1;
if(idx > 0 && abs(x - A[idx - 1]) <= abs(A[idx] - x)) idx--;
int l = 1, r = N;
while(r - l > 1){
// 高橋君が右側c個取れる
// atatataaAatttT c == 4
int c = (r + l) / 2;
if(possible(c, idx, x, A)){
l = c;
} else {
r = c;
}
}
ll taka = (S[0][N] - S[0][N - l]) + (S[1][N] - S[1][N - l]);
int rest = N - l - (l - 1);
if(rest % 2 == 1){
taka += S[1][rest];
} else {
taka += S[0][rest];
}
ans[i] = taka;
}
for(int i=0;i<Q;i++) printf("%lld\n",ans[i]);
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef long double ld;
typedef vector<ld> vd;
typedef bool bl;
typedef vector<bl> vb;
typedef unordered_map<ll,unordered_map<ll,ll>> graph;
const ll e5 = 1 << 21;
const ll mod = 1000000007;
const ll e3 = 1 << 13;
const ll INF = 1ll << 62;
ll n,q;
ll a[e5];
ll x[e5];
ll arg_x[e5];
ll b[e5]; // 0 --- takahashi, 1 --- aoki
ll ans[e5];
ll mem;
int main(){
cin >> n >> q;
for(ll i = 1;i <= n;i++) cin >> a[i];
for(ll i = 1;i <= q;i++) cin >> x[i];
iota(arg_x,arg_x+q+1,0ll);
sort(arg_x+1,arg_x+q+1,[](ll a,ll b){
return x[a] < x[b];
});
// for(ll i = 1;i <= q;i++) cerr << x[arg_x[i]] << " ";
// cerr << endl;
for(ll i = n/2+1;i <= n;i++) mem += a[i];
ll l = n%2 ? 1 : 2;
ll r = n/2+1;
for(ll i = 1;i <= q;i++){
while(r < n && abs(a[l]-x[arg_x[i]]) > abs(a[r]-x[arg_x[i]])){
mem -= a[r];
mem += a[l];
r++;
l += 2;
}
ans[arg_x[i]] = mem;
}
for(ll i = 1;i <= q;i++) cout << ans[i] << endl;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n, a[100010], q;
ll v[100010], w[100010], u[100010];
ll func(ll x){
int l = 0, r = n;
while(l+1 != r){
int m = (l + r) / 2;
ll c = abs(x - (n-1-2*m<0?1e18:a[n-1-2*m]));
ll d = abs(x - a[n-1-m]);
// cout << m << " " << c << " " << d << " " << c - d << "\n";
if(c - d > 0) r = m;
else l = m;
}
// cout << x << " " << r << "\n";
return u[n-1] - (n-r-1<0?0:u[n-r-1]) + (n-1-2*r<0?0:(n-1-2*r)%2==0?v[n-1-2*r]:w[n-1-2*r]);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> q;
for(int i=0; i<n; ++i) cin >> a[i];
v[0] = a[0];
for(int i=1; i<n; ++i){
v[i] = v[i-1];
w[i] = w[i-1];
if(i % 2 == 0) v[i] += a[i];
else w[i] += a[i];
}
u[0] = a[0];
for(int i=1; i<n; ++i)
u[i] = u[i-1] + a[i];
// for(int i=0; i<n; ++i)
// cout << i << " " << v[i] << " " << w[i] << " " << u[i] << "\n";
while(q--){
ll x;
cin >> x;
cout << func(x) << "\n";
}
} |
p03158 | C++ | #include"bits/stdc++.h"
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
const long long mod = 1000000007;
const long long inf = 11451419198109130;
typedef pair<int, int> P;
typedef pair<P, int> PP;
typedef pair<int, PP> PPP;
struct edge { int to; int to2; int cost; };
int a[100006], x[100006];
int rwa[100006], ro[100005], re[100005];
signed main() {
int n, q; cin >> n >> q;
rep(i, n)cin >> a[i];
rep(i, n) {
rwa[i + 1] += a[i];
if (i & 1)ro[i + 1] += a[i];
else re[i + 1] += a[i];
}
rep(i, n) {
rwa[i + 1] += rwa[i];
ro[i + 1] += ro[i];
re[i + 1] += re[i];
}
rep(i, n)a[i] = a[i] * 3 + 1;
rep(i, q) {
cin >> x[i];
x[i] *= 3;
int lb = -1, ub = mod*4;
while (ub - lb > 1) {
int mi = (ub + lb) / 2;
int i1 = lower_bound(a, a + n, x[i]- mi)-a;
int i2 = upper_bound(a, a + n, x[i] + mi)-a-1;
int tkhs = n-i2-1;
int aok = i2 - i1 + 1;
if (tkhs - aok > 1)lb = mi;
else ub = mi;
}
//cout << ub << endl;
int T = 0;
int i1 = lower_bound(a, a + n, x[i] - ub)-a;
int i2 = upper_bound(a, a + n, x[i] + ub)-a-1;
T += rwa[n] - rwa[i2+ 1];
int A1 = ro[i1], A2 = re[i1];
if (i2 - i1 + 1 == n - i2-1) {
if (i1 & 1) {
T += A2;
}
else {
T += A1;
}
}
else {
if (i1 & 1) {
T += A1;
}
else {
T += A2;
}
}
cout << T << endl;
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
int main() {
int n, q; cin >> n >> q;
vector<ll> a(n);
vector<vector<ll>> sum(n + 1, vector<ll>(2));
for(int i = 0; i < n; ++i) {
cin >> a[i];
sum[i + 1] = sum[i];
sum[i + 1][i & 1] += a[i];
}
auto tsum = [&sum] (int l, int r) { // 偶奇を無視した累積和
return sum[r][0] + sum[r][1] - (sum[l][0] + sum[l][1]);
};
vector<pii> qs(q);
for(int i = 0; i < q; ++i) {
cin >> qs[i].first;
qs[i].second = i;
}
sort(begin(qs), end(qs));
int it = n - 1;
vector<ll> ans(q);
for(int lp = 0; lp < q; ++lp) {
const int x = qs[lp].first;
auto check = [&] (int w) { // 末尾からいくつ取れるか
auto check2 = [&] (int y) { // 衝突するかどうか
const int idx = upper_bound(begin(a), end(a), x + y) - begin(a);
return n - w <= idx;
};
int lb = -1, ub = 1'000'000'001;
while(ub - lb > 1) {
const int mid = (ub + lb) >> 1;
(check2(mid) ? ub : lb) = mid;
}
const int cnt = upper_bound(begin(a), end(a), x + ub) - lower_bound(begin(a), end(a), x - ub);
return cnt > w; // cnt > w なら、青木くんがとりすぎ
};
while(!check(it)) {
--it;
}
ans[qs[lp].second] = tsum(n - it - 1, n) + sum[max(0, n - 2 * (it + 1))][n % 2 == 0];
}
for(int i = 0; i < q; ++i) {
cout << ans[i] << endl;
}
} |
p03158 | C++ | #pragma once
#include <stdio.h>
#include <sstream>
#include <string>
#include <string.h>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include <utility>
#include <set>
#include <cctype>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <deque>
#include <limits>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define bit(x,v) ((ll)x << v)
const ll INF = 1000000007;
const int MAX = 210000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int pr[100010];
void uini(int n) {
for (size_t i = 0; i <= n; i++)
{
pr[i] = i;
}
}
int parent(int x) {
if (x == pr[x]) return x;
return pr[x] = parent(pr[x]);
}
bool unit(int x, int y) {
int px = parent(x);
int py = parent(y);
if (px == py) return false;
if (px < py) {
pr[py] = px;
}
else {
pr[px] = py;
}
return true;
}
// res[i][c] := i 文字目以降で最初に文字 c が登場する index (存在しないときは n)
vector<vector<int> > calcNext(const string& S) {
int n = (int)S.size();
vector<vector<int> > res(n + 1, vector<int>(26, n));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) res[i][j] = res[i + 1][j];
res[i][S[i] - 'a'] = i;
}
return res;
}
// mod 1000000007 の世界で a += b する関数
void add(long long& a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
ll slide(vector<ll>& v, ll a, ll b) {
ll azv = abs(v[0] - a);
ll bzv = abs(v[0] - b);
ll aov = abs(v[1] - a);
ll bov = abs(v[1] - b);
v[0] = a;
v[1] = b;
return max((azv + bov), (bzv + aov));
}
ll a[100010];
ll ac[100010];
ll as[100010];
int n, q;
ll calc(ll x) {
ll high = a[n - 1];
ll low = x;
int hi = 0;
int li = 0;
int in = 0;
if (x >= a[n - 1]) {
return ac[n - 1];
}
while (in < 50)
{
ll mid = (high + low) / 2;
ll *hp = lower_bound(a, a + n, mid);
if (mid < *hp && hp != a) {
hp--;
}
ll *lp = lower_bound(a, a + n, x - (mid - x));
if (*lp > *hp) {
lp--;
}
ll c = (hp - a) - (lp - a) + 1;
ll tc = (n - ((hp - a) + 1));
in++;
if (c + tc > n) {
high = mid;
continue;
}
hi = hp - a;
li = lp - a;
if (c == tc) {
break;
}
if (c > tc) {
high = mid;
}
else {
low = mid;
}
}
int ptc = n - ((hi - li) + 1);
int thi = hi;
int turn = 0;
while (hi < ptc)
{
if (turn % 2 == 0) {
if (ptc - 1 == hi) break;
ptc--;
}
else {
if (hi + 1 == ptc) {
li--;
}
else if (li - 1 < 0){
if (hi + 1 == ptc) {
break;
}
hi++;
}
else {
ll hv = a[hi + 1];
ll lv = a[li - 1];
if (hv - x >= lv - x) {
li--;
}
else hi++;
}
}
turn++;
}
return (as[n - 1] - as[hi]) + (li <= 0 ? 0 : ac[li - 1]);
}
void solv() {
cin >> n >> q;
for (size_t i = 0; i < n; i++)
{
cin >> a[i];
as[i] = a[i];
if (i > 0) as[i] += as[i - 1];
}
sort(a, a + n);
ac[0] = a[0];
ac[1] = a[1];
for (size_t i = 2; i < n; i++)
{
ac[i] = a[i] + ac[i - 2];
}
ll x[100010];
for (size_t i = 0; i < q; i++)
{
cin >> x[i];
}
for (size_t i = 0; i < q; i++)
{
cout << calc(x[i]) << endl;
}
}
int main() {
//COMinit();
solv();
return 0;
}
|
p03158 | C++ | #include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<string>
#include<cmath>
#include<cstring>
#include<queue>
#include<map>
#include<climits>
#include<set>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef pair<ll, ll> pll;
//int dx[4] = { 1,0,0,-1 };
//int dy[4] = { 0,1,-1,0 };
#define MOD 1000000007
#define ARRAY_MAX 100005
const int INF = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, q;
cin >> n >> q;
vector<ll> A(ARRAY_MAX, 0), S(ARRAY_MAX, 0), Sdiv(ARRAY_MAX, 0);
vector<pll> X(ARRAY_MAX);
vector<ll> ans(ARRAY_MAX, 0);
for (int i = 1; i <= n; i++)
{
cin >> A[i];
S[i] = S[i - 1] + A[i];
Sdiv[i] = A[i];
if (i >= 3)
{
//奇数、偶数番号分けて累積和を取る
Sdiv[i] += Sdiv[i - 2];
}
}
for (ll i = 0; i < q; i++)
{
cin >> X[i].first;
X[i].second = i;
}
sort(X.begin(), X.begin() + q);
ll y = 1;//高橋君が上から取れる要素番号
for (ll i = 0; i < q; i++)
{
ll x = X[i].first;
while (y <= n)
{
if (A[y] < x)
{
//xより大きい要素の取り方を調べるのでx未満のものは無視
//x以下についてはまだ考えない
y++;
}
else
{
ll upper = n - y + 1;//高橋君がy番目のカードを何枚目に取るか
ll lower = y - (lower_bound(A.begin(), A.begin()+ n + 1, max(1LL, 2LL * x - A[y])) - A.begin()) + 1;//青木君y番目のカードを何枚目に取るか
if (lower < upper)
{
y++;
}
else
{
//y番目のカードを取る時の枚数が逆転してしまうのでここが境界となる
break;
}
}
}
ll cnt = S[n] - S[y - 1];//高橋君が上から取る部分
ll first = n - (n - y + 1) * 2;//交互に取る場所へ移動（上から取る）[
if (first > 0)
{
cnt += Sdiv[first];
}
ans[X[i].second] = cnt;
}
for (int i = 0; i < q; i++)
{
cout << ans[i] << endl;
}
return 0;
}
|
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){os << "["; for (const auto &v : vec) {os << v << ","; } os << "]"; return os; }
template <typename T, typename U> ostream &operator<<(ostream &os, const pair<T, U> &p) {os << "(" << p.first << ", " << p.second << ")"; return os;}
vector<ll> acc;
vector<ll> acc_e;
ll solve(ll x, vector<ll> &A) {
ll ok = 0, ng = 1e18 + 120;
int N = A.size();
while(ng - ok > 1) {
ll c = (ok + ng) / 2;
ll k1 = lower_bound(all(A), x - c) - A.begin();
ll k2 = upper_bound(all(A), x + c) - A.begin();
if (k2 - k1 <= N - k2) {
ok = c;
} else {
ng = c;
}
}
ll k1 = lower_bound(all(A), x - ok) - A.begin();
ll k2 = upper_bound(all(A), x + ok) - A.begin();
return (acc[N] - acc[k2]) + (((k1 % 2) ^ (N - k2 > k2 - k1)) ? acc_e[k1] : (acc[k1] - acc_e[k1]));
}
void solve() {
int N, Q;
cin >> N >> Q;
vector<ll> A(N);
acc.resize(N + 1);
acc_e.resize(N + 1);
for (int i = 0; i < N; i++) {
cin >> A[i];
A[i] *= 4;
acc[i + 1] = acc[i] + A[i];
acc_e[i + 1] = acc_e[i] + ((i % 2 == 0) ? A[i] : 0);
}
for (int q = 0; q < Q; q++) {
ll x; cin >> x;
cout << solve(x * 4 - 1, A) / 4 << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
int cal(long long x, long long mid, vector<long long> &a) {
int s = upper_bound(a.begin(), a.end(), x+mid) - lower_bound(a.begin(), a.end(), x-mid);
int t = a.end() - upper_bound(a.begin(), a.end(), x + mid);
return t - s;
}
int lowerindex(long long x, vector<long long> &a) {
int ret = lower_bound(a.begin(), a.end(), x) - a.begin();
return ret;
}
int upperindex(long long x, vector<long long> &a) {
int ret = upper_bound(a.begin(), a.end(), x) - a.begin();
return ret;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, q; cin >> n >> q;
vector<long long> a(n), sum(n+1, 0), sum2(n+1, 0);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
sum[i+1] = sum[i] + a[i];
sum2[i+1] = sum2[max(0, i-1)] + a[i];
}
for (int qi = 0; qi < q; qi++) {
long long x; cin >> x;
if (a[n-2] <= x) {
cout << sum2[n] << "\n";
continue;
}
long long left = 0; long long right = 1e9;
long long mid; int s;
while (right - left > 1) {
mid = (left + right) / 2;
s = cal(x, mid, a);
if (s < 0) right = mid;
else if (s > 1) left = mid;
else {
left = mid;
break;
}
}
s = cal(x, left, a);
int u = lowerindex(x-left, a);
int v = upperindex(x+left, a);
if (s == 2) {
u--; s--;
}
long long ans = sum[n] - sum[v];
if (s == 1) ans += sum2[max(0, u-1)];
else if (s == 0) ans += sum2[max(0, u)];
cout << ans << "\n";
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
#define mx 100005
using namespace std;
int n, q, a[mx], ans, x;
long long ac[mx], ac1[mx];
int main(){
scanf("%d%d", &n, &q);
for(int i = 0; i < n; i++){
scanf("%d", a+i);
ac[i+1] = a[i] + ac[i];
if(i+n&1) ac1[i/2+1] = a[i] + ac1[i/2];
}
for(int i = 0; i < q; i++){
scanf("%d", &x);
int l = 1, r = (n+1)/2+1;
while(r-l > 1){
int mid = (l + r) / 2;
(a[n+1 - mid*2] + a[n - mid] < x*2 ? r : l) = mid;
}
printf("%lld\n", ac[n]-ac[n-l]+ac1[(n-l*2+1)/2]);
}
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define all(x) (x).begin(),(x).end()
#define foreach(u,v) for(auto (u) : (v))
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
const int inf = 1e9;
const ll linf = 1LL<<60;
const ll mod = 1e9 + 7;
const double eps = 1e-9;
/*
*/
int main()
{
int n, q;
cin >> n >> q;
vi a(n);
rep(i, n) cin >> a[i];
vl s(n+1), se(n+1);
rep(i, n){
s[i+1] = s[i] + a[i];
se[i+1] = se[i];
if(i%2 == 0) se[i+1] += a[i];
}
while(q--){
int x; cin >> x;
int i = upper_bound(all(a), x) - a.begin();
int l = i-1, r = n;
// 全部交互にとる
if(l >= n-1){
if(n%2){
cout << se[n] << endl;
}else{
cout << s[n]-se[n] << endl;
}
continue;
}
// (交互)(青木)(高橋)
while(r-l > 1){
int m = (l+r)/2;
int d = a[m] - x;
int j = lower_bound(all(a), x-d) - a.begin();
int cnt = m - j + 1;
if(n-cnt <= m) r = m;
else l = m;
}
l += 1;
int cnt = n-l;
if(n%2){
cout << (s[n]-s[l]) + se[max(l-cnt, 0)] << endl;
}else{
cout << (s[n]-s[l]) + (s[max(l-cnt, 0)]-se[max(l-cnt, 0)]) << endl;
}
}
/*
rep(i, n+1){
cout << s[i] << " ";
}
cout << endl;
rep(i, n+1){
cout << se[i] << " ";
}
cout << endl;
*/
return 0;
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
using i64 = int64_t;
i64 cumsum[100005]={0}, stepsum[2][100005]={0};
i64 bsearch(i64 ok, i64 ng, vector<i64> &v, i64 x){
i64 n = v.size();
while(abs(ok-ng) > 1){
i64 mid = (ok + ng) / 2;
if(abs(v[n-mid-1] - x) < abs(v[n-2*mid-1] - x))ok = mid;
else ng = mid;
}
return ok;
}
int main(){
int n, q;
cin >> n >> q;
vector<i64> v;
for(int i=0;i<n;++i){
i64 a;
cin >> a;
v.push_back(a);
}
for(int i=1;i<=n;++i){
cumsum[i] = cumsum[i-1] + v[i-1];
stepsum[0][i] = stepsum[0][i-1];
stepsum[1][i] = stepsum[1][i-1];
stepsum[i%2][i] += v[i-1];
}
for(int i=0;i<q;++i){
i64 x;
cin >> x;
i64 p = bsearch(n/2+(n%2), 0, v, x);
i64 ans = cumsum[n] - cumsum[n-p];
ans += stepsum[n%2][n-2*p];
cout << ans << endl;
}
return 0;
}
|
p03158 | C++ | #include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstring>
#include<utility>
#include<cmath>
#include<assert.h>
#include<set>
#define int long long
using namespace std;
#define rep(i, n) for(int i=0;i<(n);++i)
typedef pair<int, int> pii;
const int INF = 1l << 60;
#define u_b upper_bound
#define l_b lower_bound
int N;
int A[100100];
int Aeven[100100];
int Aodd[100100];
int Asum[100100];
int solve(int x) {
//青木くんがxより大きい数をm枚とるとすると左から取る枚数の最小値を決められる
//その和が右に残っている枚数以上ならok
int ok = 0;
int ng = N;
int midi = l_b(A, A + N, x) - A;//A[midi],A[midi+1],...,A[midi+m-1]を取る
while (ng - ok > 1) {
int m = (ok + ng) / 2;
if (midi + m - 1 >= N) {
ng = m;
continue;
}
int dist = A[midi + m - 1] - x;
int leftIdx = l_b(A, A + N, x - dist) - A;
int n = midi + m - leftIdx;
//A[midi+m],A[midi+m+1],...,A[midi+m+n-1]
if (midi + m + n - 1 < N)ok = m;
else ng = m;
}
//高橋くんはA[midi+ok],A[midi+ok+1],...,A[N-1]と
//A[N-2n-1],A[N-2n-3],...,A[0or1]を取る
//ただしn=N-(midi+ok)
int res = Asum[N - 1] - Asum[midi + ok - 1];
int n = N - (midi + ok);
if ((N - 2 * n - 1) % 2 == 0) {
res += Aeven[N - 2 * n - 1];
} else {
res += Aodd[N - 2 * n - 1];
}
return res;
}
void pre() {
Aeven[0] = A[0];
Aodd[1] = A[1];
Asum[0] = A[0];
Asum[1] = Asum[0] + A[1];
for (int i = 2; i < N; ++i) {
if (i % 2 == 0)Aeven[i] = Aeven[i - 2] + A[i];
else Aodd[i] = Aodd[i - 2] + A[i];
Asum[i] = Asum[i - 1] + A[i];
}
rep(i, N) {
A[i] = 4 * A[i] + 1;
}
}
signed main() {
int Q;
cin >> N >> Q;
rep(i, N) {
cin >> A[i];
}
pre();
rep(i, Q) {
int X;
cin >> X;
cout << solve(4 * X) << endl;
}
return 0;
}
|
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(x) x.begin(),x.end()
#define dbg(x) cout<<#x<<":"<<x<<endl
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,P> PP;
int main(){
ll n,q;
cin>>n>>q;
vector<int> a(n);
ll tsum=0;
for(int i=0;i<n;i++){
cin>>a[i];
if(i>=n/2)tsum+=a[i];
}
reverse(all(a));
ll suma[111111]={};
ll sump[111111]={};
suma[0]=a[0];
sump[n-1]=a[n-1];
sump[n-2]=a[n-2];
for(int i=1;i<n;i++){
suma[i]=suma[i-1]+a[i];
if(i>1)sump[n-1-i]=sump[n+1-i]+a[n-1-i];
}
for(int i=0;i<q;i++){
ll x;
cin>>x;
if(abs(x-a[n-1])<=abs(x-a[n-2])){
cout<<tsum<<endl;
continue;
}
if(abs(x-a[0])<abs(x-a[1])){
cout<<sump[0]<<endl;
continue;
}
ll ok=(n-1)/2,ng=-1,mid;
while(ok-ng>1){
mid=(ok+ng)/2;
// dbg(mid);
ll l=abs(x-a[mid+1]);
ll r=abs(x-a[mid*2+2]);
if(l<r)ok=mid;
else ng=mid;
}
// dbg(ok);
cout<<suma[ok]+sump[ok*2+2]<<endl;
}
return 0;
}
|
p03158 | C++ | #include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#define MAX_N (100000L)
#define MAX_Q (100000L)
#define INF (1000000000000000000L)
using namespace std;
int main() {
// read inputs
long N, Q, as[MAX_N], xs[MAX_Q];
scanf("%ld %ld", &N, &Q);
for (long i = 0; i < N; i++) {
scanf("%ld", &as[i]);
}
for (long q = 0; q < Q; q++) {
scanf("%ld", &xs[q]);
}
// pre-calculation
long acceos[MAX_N + 2] = {}, accs[MAX_N + 1] = {};
for (long i = 0; i < N; i++) {
acceos[i + 2] = acceos[i] + as[i];
}
for (long i = 0; i < N; i++) {
accs[i + 1] = accs[i] + as[i];
}
// solve
for (long q = 0; q < Q; q++) {
const long x = xs[q];
long le = 0, re = N + 1;
while (re - le > 1) {
const long m = (re + le) / 2;
const long d = abs(as[N - m] - x);
// count the number of elements (excluding as[N - m]) as[i] that satisfy
// |as[i] - x| <= |as[N - m] - x| = d
const long min_i = lower_bound(as, as + N, x - d) - as, max_i = N - m - 1;
const long md = max_i - min_i + 1;
// printf("le = %ld, re = %ld, m = %ld, min_i = %ld, max_i = %ld\n", le, re,
// m, min_i, max_i);
if (md == m || md == m - 1) {
le = m - 1;
re = m + 1;
break;
} else if (md < m - 1) {
re = m;
} else {
le = m;
}
}
const long K = (le + re) / 2;
const long ans = accs[N] - accs[N - K] + acceos[N - 2 * K + 1] -
acceos[(N - 2 * K + 1) % 2];
// printf("x = %ld, K = %ld\n", x, K);
printf("%ld\n", ans);
}
} |
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
int n;
vector<long long> a, sum, osum, esum;
bool check(int mid, long long x){
int l = lower_bound(a.begin(), a.end(), x * 2LL - a[mid]) - a.begin();
l = max(l, 1);
return mid - l + 1 <= n - mid;
}
int meguru_search(int ok, int ng, long long x){
while(abs(ok - ng) > 1){
int mid = (ok + ng) / 2;
if(check(mid, x)){
ok = mid;
}else{
ng = mid;
}
}
return ok;
}
long long query(long long x){
int ar = meguru_search(0, n, x);
int al = max(ar * 2 - n, 0);
long long res = sum[n] - sum[ar] + (al % 2 == 0 ? esum[al] : osum[al]);
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> n >> q;
a.resize(n + 1);
for(int i = 1 ; i <= n ; ++i){
cin >> a[i];
}
sum.resize(n + 1);
osum.resize(n + 1);
esum.resize(n + 1);
for(int i = 1 ; i <= n ; ++i){
sum[i] = sum[i - 1] + a[i];
osum[i] = osum[i - 1] + (i % 2 == 1 ? a[i] : 0);
esum[i] = esum[i - 1] + (i % 2 == 0 ? a[i] : 0);
}
for(int i = 0 ; i < q ; ++i){
long long x;
cin >> x;
long long ans = query(x);
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
#define lint long long
#define P pair<int, int>
#define LLP pair<long long, long long>
#define REP(i, x, n) for(int i = (x), i##_len = (int)(n) ; i < i##_len ; ++i)
#define rep(i, n) for(int i = 0, i##_len = (int)(n) ; i < i##_len ; ++i)
#define repr(i, n) for(int i = (int)(n) - 1 ; i >= 0 ; --i)
#define SORT(x) sort((x).begin(), (x).end())
#define SORT_INV(x) sort((x).rbegin(), (x).rend())
const int IINF = 1e9 + 100;
const long long LLINF = 2e18 + 129;
const long long MOD = 1e9 + 7;
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, 1, 0, -1};
const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};
const double EPS = 1e-8;
int n;
vector<lint> a, sum, osum, esum;
bool check(int mid, lint x){
int l = lower_bound(a.begin(), a.end(), x * 2LL - a[mid]) - a.begin();
l = max(l, 1);
return mid - l + 1 <= n - mid;
}
int meguru_search(int ok, int ng, lint x){
while(abs(ok - ng) > 1){
int mid = (ok + ng) / 2;
if(check(mid, x)){
ok = mid;
}else{
ng = mid;
}
}
return ok;
}
lint query(lint x){
int ar = meguru_search(0, n, x);
int al = max(ar * 2 - n, 0);
lint res = sum[n] - sum[ar] + (al % 2 == 0 ? esum[al] : osum[al]);
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> n >> Q;
a.resize(n + 1);
REP(i, 1, n + 1){
cin >> a[i];
}
sum.resize(n + 1);
osum.resize(n + 1);
esum.resize(n + 1);
REP(i, 1, n + 1){
sum[i] = sum[i - 1] + a[i];
osum[i] = osum[i - 1] + (i % 2 == 1 ? a[i] : 0);
esum[i] = esum[i - 1] + (i % 2 == 0 ? a[i] : 0);
}
rep(q, Q){
lint x;
cin >> x;
lint ans = query(x);
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
#define PI 3.14159265358979323846
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
int n, q;
vi in;
vector<ll> s0, s1;
vector<ll> sum;
ll Sum(int l, int r){
return sum[r] - (l == 0 ? 0 : sum[l - 1]);
}
int Fge(int to){
return lower_bound(all(in), to) - in.begin();
}
pii Bounds(int x, int bp){
if(bp == 0) return mp(0, 0);
if(in[bp] <= x) return mp(0, 0);
int re = bp - 1, le_need, le_poss;
if(in[re] < x){
le_poss = Fge(x - (in[bp] - x));
return mp(0, re - le_poss + 1);
} else {
le_need = Fge(x - (in[re] - x));
le_poss = Fge(x - (in[bp] - x));
return mp(re - le_need + 1,
re - le_poss + 1);
}
}
const int LESS = 0;
const int MORE = 1;
const int FINE = 2;
int Side(int x, int bp){
int me = n - bp;
auto lo_hi = Bounds(x, bp);
if(lo_hi.fi > me) return MORE;
if(lo_hi.se < me - 1) return LESS;
return FINE;
}
ll Solve(int x){
if(x >= in[n - 1]) return s0[n - 1];
int lo = 0, mid, hi = n - 1;
while(true){
if(lo + 1 >= hi){
if(Side(x, lo) == FINE) mid = lo;
else mid = hi;
break;
}
mid = (lo + hi) / 2;
int sd = Side(x, mid);
if(sd == FINE) break;
if(sd == LESS) lo = mid;
else hi = mid;
}
ll me = Sum(mid, n - 1);
int me_take = n - mid;
int he_take = n - mid;
if(he_take > Bounds(x, mid).se) --he_take;
mid -= he_take + 1;
if(mid >= 0){
if((me_take + he_take) % 2 == 0)
me += s0[mid];
else
me += s1[mid];
}
return me;
}
int main(){
scanf("%d%d", &n, &q);
in.resize(n);
for(int& e : in) scanf("%d", &e);
s0.resize(n);
s1.resize(n);
s0[0] = in[0];
s1[0] = 0;
for(int i = 1;i < n;++i)
s0[i] = in[i] + s1[i - 1],
s1[i] = s0[i - 1];
sum.resize(n);
sum[0] = in[0];
for(int i = 1;i < n;++i)
sum[i] = sum[i - 1] + in[i];
for(int i = 0;i < q;++i){
int x;
scanf("%d", &x);
printf("%lld\n", Solve(x));
}
return 0;
}
|
p03158 | C++ | #include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <cassert>
#include <cstdarg>
#include <sys/time.h>
#include <fstream>
//#include "cout.h"
using namespace std;
#define SZ(x) ((int)x.size())
#define MSET(x,a) memset(x, a, (int)sizeof(x))
#define PB push_back
#define VI vector < int >
#define PII pair < int, int >
#define LL long long
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(), (v).end()
#define FIT(it,v) for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
#define OUT(A) cout << #A << " = "<< (A) << endl
#define OUT2(A, B) cout << "(" << #A << ", " << #B << ") = (" << (A) << ", "<< (B) << ")" << endl
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
#define present(c, e) ((c).find((e)) != (c).end())
#define cpresent(c, e) (find(ALL(c), (e)) != (c).end())
LL n, q, a[100010], x[100010];
vector<LL> bound;
LL sum[100010], sumHalf[100010];
void init() {
}
void input() {
cin >> n >> q;
REP(i, n) cin >> a[i];
REP(i, q) cin >> x[i];
}
void solve() {
bound.clear();
bound.push_back((1LL<<50)*-1);
for(LL i = 1; ; i++) {
LL r = n-1-i;
LL l = n-1-i*2;
if (l < 0) break;
bound.push_back((a[l]+a[r])/2*-1);
}
sum[0] = 0;
sumHalf[0] = 0;
FOR(i, 1, n+1) {
sum[i] = sum[i-1] + a[i-1];
if (i==1) sumHalf[i] = a[i-1];
else sumHalf[i] = sumHalf[i-2] + a[i-1];
}
REP(i, q) {
LL b = upper_bound(bound.begin(), bound.end(), -x[i]) - bound.begin();
// cout << b << endl;
LL s = sum[n] - sum[n-b];
LL remain = n-b*2;
if (remain > 0) s += sumHalf[remain];
cout << s << endl;
}
}
int main() {
init();
input();
solve();
return 0;
}
|
p03158 | C++ | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
using namespace std;
int MOD = 1000000007;
signed main(){
int n,q;
cin >> n >> q;
vector<int> a(n);
rep(i,n)cin >> a[i];
int s[100010] = {0};
for(int i = 1;i < n;i++){
s[i] = s[i-1] + a[n-i];
}
int s_m[100010] = {0};
for(int i = 1;2*i-1 < n;i++){
if(n%2 == 0){
s_m[i] = s_m[i-1] + a[2*i-1];
}else{
s_m[i] = s_m[i-1] + a[2*i-2];
}
}
vector<int> k;
for(int i = 1;i <= n - n/2 - 1;i++){
int r = a[n-1-i];
int l = a[n-1-2*i];
k.pb((r+l)/2);
}
SORT(k);
rep(i,q){
int x;
cin >> x;
int num = k.end() - lower_bound(k.begin(),k.end(),x) + 1;
int ans = s[num] + s_m[n-n/2-num];
cout << ans << endl;
}
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl https://ddcc2019-final.contest.atcoder.jp/tasks/ddcc2019_final_a
// rm -r -f test;oj dl http://aising2019.contest.atcoder.jp/tasks/aising2019_d |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef gp_hash_table<long long, long long> umap;
#define fr(i,a,b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i,a,b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i,n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i,n) for (long long i = (n) - 1; i >= 0; i--)
#define foreach(it,ar) for ( typeof(ar.begin()) it = ar.begin(); it != ar.end(); it++ )
#define fill(ar,val) memset(ar, val, sizeof(ar))
#define fill0(ar) fill((ar), 0)
#define fillinf(ar, n) fr(i,0,(n)) ar[i] = INF
#define debug(x) cout<<#x<<": "<<x<<endl
#define arr1d(a,n) cout << #a << " : "; fr(_,1,n) cout << a[_] << ' '; cout << endl;
#define arr1d0(a,n) cout << #a << " : "; rep(_,n) cout << a[_] << ' '; cout << endl;
#define arr2d(a,n,m) cout << #a << " :" << endl; fr(_,1,n) {fr(__,1,m) cout << a[_][__] << ' '; cout << endl;}
#define arr2d0(a,n,m) cout << #a << " :" << endl; rep(_,n) {rep(__,m) cout << a[_][__] << ' '; cout << endl;}
/*Author Ritick Goenka || ritick(codechef) ||ritick(codeforces) */
/*IIT Roorkee = <3 */
#define ull unsigned long long
#define ll long long
#define ld double
#define ui unsigned int
#define all(ar) ar.begin(), ar.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define y0 yyyyyy0
#define y1 yyyyyy1
#define sot(bello) bello.begin(),bello.end()
#define BIT(n) (1<<(n))
#define SQR(x) ((x) * (x))
#define CUBE(x) ((x) * (x) * (x))
#define LSOne(S) (S) & (-S)
inline bool EQ(double a, double b) {return fabs(a - b) < 1e-9;}
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<string> vs;
template<typename T>inline T gcd(T a, T b){if (b == 0)return a;else return gcd(b, a % b);}
template<typename T>inline T lcm(T a, T b){return (a * b) / gcd(a, b);}
template<typename T> string toStr(T x) {stringstream st; st << x; string s; st >> s; return s;}
template<class T>
void splitStr(const string &s, vector<T> &out)
{
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
inline int two(int n) {return 1 << n;}
inline int isOnBit(int n, int b) {return (n >> b) & 1;}
inline void onBit(int & n, int b) {n |= two(b);}
inline void offBit(int & n, int b) {n &= ~two(b);}
inline int lastBit(int n) {return n & (-n);}
inline int cntBit(int n) {int res = 0; while(n && ++res) n -= n &(-n); return res;}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
#define INP "test.inp"
#define OUT "test.out"
#define PI 3.1415926535897932385
#define INF 1000000000000000
#define EPS 1e-7
#define MAXN 100000
#define MOD 1000000007
#define dec decr
//END OF COMPETITVE PROGRAMMING TEMPLATE
ll gcd(ll a, ll b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
ll modexp(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
char c[405][405];
int mark[405][405];
pair<ll,ll> dfs(ll i,ll j, ll k)
{
// debug(i);
// debug(j);
mark[i][j]=1;
ll ans1=0,ans2=0;
if(k==1)
{
if(c[i-1][j]=='#'&&mark[i-1][j]==0)
{
pair<ll,ll> kk=dfs(i-1,j,0);
ans2+=kk.ss;
ans1+=kk.ff;
}
if(c[i+1][j]=='#'&&mark[i+1][j]==0)
{
pair<ll,ll> kk=dfs(i+1,j,0);
ans2+=kk.ss;
ans1+=kk.ff;
}
if(c[i][j-1]=='#'&&mark[i][j-1]==0)
{
pair<ll,ll> kk=dfs(i,j-1,0);
ans2+=kk.ss;
ans1+=kk.ff;
}
if(c[i][j+1]=='#'&&mark[i][1+j]==0)
{
pair<ll,ll> kk=dfs(i,j+1,0);
ans2+=kk.ss;
ans1+=kk.ff;
}
return mp(ans1,ans2+1);
}
else
{
if(c[i-1][j]=='.'&&mark[i-1][j]==0)
{
pair<ll,ll> kk=dfs(i-1,j,1);
ans2+=kk.ss;
ans1+=kk.ff;
}
if(c[i+1][j]=='.'&&mark[i+1][j]==0)
{
pair<ll,ll> kk=dfs(i+1,j,1);
ans2+=kk.ss;
ans1+=kk.ff;
}
if(c[i][j-1]=='.'&&mark[i][j-1]==0)
{
pair<ll,ll> kk=dfs(i,j-1,1);
ans2+=kk.ss;
ans1+=kk.ff;
}
if(c[i][j+1]=='.'&&mark[i][1+j]==0)
{
pair<ll,ll> kk=dfs(i,j+1,1);
ans2+=kk.ss;
ans1+=kk.ff;
}
return mp(ans1+1,ans2);
}
}
ll ar[100005][2];
vector<pair<ll,ll> >v,v1;
int main ()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout<<setprecision(11);
ll n,q;
cin>>n>>q;
ll a[n],p[n];
rep(i,n)
{
cin>>a[i];
if(i>0)
p[i]=p[i-1]+a[i];
else
p[i]=a[i];
if(i>1)
ar[i][0]=ar[i-1][1]+a[i];
else
ar[i][0]=a[i];
if(i>0)
ar[i][1]=ar[i-1][0];
// debug(ar[i][0]);
// debug(ar[i][1]);
}
v.pb(mp(INF,ar[n-1][0]));
for(ll i=2;i<=(n+1)/2;i++)
{
ll kk=max(n-2*i+1,0ll);
ll k=a[n-i]+a[kk];
k/=2;
// debug(k);
ll ans=p[n-1]-p[n-1-i];
// debug(ans);
ans+=ar[n-1-2*i][0];
// debug(ar[n-1-2*i][0]);
// debug(ans);
v.pb(mp(k,ans));
}
// debug("Df");
reverse(all(v));
ll ans=p[n-1]-p[n-1-(n+1)/2];
rep(i,q)
{
ll x;
cin>>x;
v1.pb(mp(x,i));
}
sort(all(v1));
ll an[q]={0};
ll j=0;
// debug(ans);
rep(i,q)
{
// debug(v1[i].ff);
// debug(v[])
while(v1[i].ff>v[j].ff)
{
ans=v[j+1].ss;
j++;
}
an[v1[i].ss]=ans;
}
rep(i, q)
{
cout<<an[i]<<endl;
}
return 0;
} |
p03158 | C++ | #include<bits/stdc++.h>
using namespace std;
#define LL long long
#define pa pair<int,int>
const int Maxn=100010;
const int inf=2147483647;
int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
return x*f;
}
int n,m,ans[Maxn];LL sum[Maxn],a[Maxn],s[Maxn];
struct Query{int x,id;}q[Maxn];
bool cmp(Query a,Query b){return a.x>b.x;}
int L,R;
LL g(int x,int st,int len,LL v)
{
int ed=st+len-1;
if(ed>n)return(1LL<<61);
if(ed<=x)return (LL)len*v-(sum[ed]-sum[st-1]);
if(st>x)return (LL)sum[ed]-sum[st-1]-len*v;
return (LL)(x-st+1)*v-(sum[x]-sum[st-1])+(sum[ed]-sum[x])-(ed-x)*v;
}
void get(int x,int len,int v)
{
int l=1,r=n-len+1;
while(l<=r)
{
int mid=l+r>>1;
if(g(x,mid,len,v)<=g(x,mid+1,len,v))r=mid-1;
else l=mid+1;
}
L=r+1,R=L+len-1;
// printf("%d %d %d %d %d\n",x,len,v,L,R);
}
int main()
{
n=read(),m=read();sum[0]=s[0]=0;
for(int i=1;i<=n;i++)
{
a[i]=read(),sum[i]=sum[i-1]+a[i];
s[i]=s[max(0,i-2)]+a[i];
}
for(int i=1;i<=m;i++)q[i].x=read(),q[i].id=i;
sort(q+1,q+1+m,cmp);
// printf("%lld %lld\n",g(1,1,2,20),g(1,2,2,20));
int t=1;
for(int i=1;i<=m;i++)
{
int l=1,r=n;
while(l<=r)
{
int mid=l+r>>1;
if(a[mid]>=q[i].x)r=mid-1;
else l=mid+1;
}
int pos=r+1;
while(t<=(n+1)/2)
{
get(pos,t,q[i].x);
if(R<n-t+1){t++;continue;}
// printf("%d %d %d\n",L,R,t);
if(R>n-t+1)t--;
else if(abs(a[R]-q[i].x)<abs(a[L]-q[i].x))t--;
break;
}
t=min(t,(n+1)/2);
ans[q[i].id]=t;
}
// for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
for(int i=1;i<=m;i++)printf("%lld\n",sum[n]-sum[n-ans[i]]+s[max(0,n-(ans[i]<<1))]);
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
const int MAX_N = 100005;
int N, Q;
lint A[MAX_N], X[MAX_N], S[MAX_N], odd[MAX_N], even[MAX_N];
bool check(int q, int i){
int j = distance(A, lower_bound(A, A+N, 2*X[q]-A[i]));
int cnt = i - j;
if(A[i]+A[j]>=2*X[q]) cnt++;
if(cnt>N-i-1) return false;
return true;
}
int main(){
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> N >> Q;
for(int i=0;i<N;i++) cin >> A[i];
for(int i=0;i<Q;i++) cin >> X[i];
for(int i=1;i<=N;i++){
S[i] += S[i-1] + A[i-1];
odd[i] = odd[i-1], even[i] = even[i-1];
if(i%2) even[i] += A[i-1];
else odd[i] += A[i-1];
}
for(int i=0;i<Q;i++){
int left = -1, right = N + 1;
while(1<right-left){
int mid = (left+right) / 2;
if(check(i, mid)) left = mid;
else right = mid;
}
int lb = max(2*left - N + 2, 0);
lint ans = S[N] - S[left+1];
if(lb%2) ans += even[lb];
else ans += odd[lb];
cout << ans << endl;
}
return 0;
} |
p03158 | C++ | #include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
#define LL long long
int N, Q;
LL inf = 1 << 30;
vector<LL> A(100010);
LL sum1[100010];
LL sum2[100010];
bool judge(LL X, int l, int r){
int dl = abs(X - A[l]);
int dr = abs(X - A[r]);
if(dr < dl) return true;
if(dr == dl) return false;
return false;
}
LL solve(LL X) {
LL ub = N + 1, lb = 0;
while(ub - lb > 1){
LL mid = (ub + lb) / 2;
int t = (mid + 1) / 2;
int r = N - t - 1;
int l = N - mid;
if(judge(X, l, r + 1)){
ub = mid;
}else{
lb = mid;
}
}
int l = N - (lb + 1) / 2;
if(lb % 2) lb++;
LL ans = sum1[N - 1] - sum1[l - 1];
if(N - lb > 0) ans += sum2[N - lb - 1];
return ans;
}
int main(){
cin >> N >> Q;
for(int i = 0; i < N; i++){
cin >> A[i];
}
for(int i = 0; i < N; i++){
sum1[i] += A[i];
sum1[i + 1] += sum1[i];
}
for(int i = 0; i < N; i++){
sum2[i] += A[i];
sum2[i + 2] += sum2[i];
}
for(int i = 1; i <= Q; i++){
LL X;
cin >> X;
cout << solve(X) << endl;
}
return 0;
} |
p03158 | C++ | #include <bits/stdc++.h>
using namespace std;
#define INF (INT64_MAX)
#define MOD (1000000000+7)
#define MAX 100000
int N, Q;
long long A[MAX];
long long x[MAX];
long long S[MAX + 1];
long long T[MAX + 1];
int main() {
cin >> N >> Q;
for( int i = 0; i < N; i++ ) {
cin >> A[i];
}
for( int i = 0; i < Q; i++ ) {
cin >> x[i];
}
for( int i = 1; i < N; i++ ) {
S[i + 1] = S[i] + A[i];
}
T[1] = A[0];
for( int i = 1; i < N; i++ ) {
T[i + 1] = T[i - 1] + A[i];
}
for( int i = 0; i < Q; i++ ) {
long long X = x[i];
int l = 0;
int h = N;
while( h - l > 1 ) {
int m = ( l + h ) / 2;
if( A[m] < X ) {
l = m;
continue;
}
int acnt = upper_bound( A, A + N, A[m] ) - lower_bound( A, A + N, X - (A[m] - X) );
if( acnt < N - m ) {
l = m;
}
else {
h = m;
}
}
l++;
long long ans = S[N] - S[l];
if( 2 * l >= N ) {
ans += T[2 * l - N];
}
cout << ans << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.