void init(){
int i,j;
sort(det,det+N);
i = j = 0;
while(i < N){
while(det[j].first+D < det[i].first && j < i){
max_height.erase(make_pair(det[j].second,j));
++j;
}
if(!max_height.empty() && max_height.rbegin()->first >= det[i].second*2) crowded[i] = 1;
max_height.insert(make_pair(det[i].second,i));
++i;
}
i = N-1,j = N-1;
max_height.clear();
while(i >= 0){
while(det[j].first-D > det[i].first && j > i){
max_height.erase(make_pair(det[j].second,j));
--j;
}
crowded[i] &= (!max_height.empty() && max_height.rbegin()->first >= det[i].second*2);
max_height.insert(make_pair(det[i].second,i));
--i;
}
}
int main() {
int N; scanf("%d", &N);
while(N--) {
int x; scanf("%d", &x);
A.insert(x);
}
int first = 0, second = 0;
if(A.size() > 0) {
first = *A.rbegin();
A.erase(*A.rbegin());
}
if(A.size() > 0) {
second = *A.rbegin();
A.erase(*A.rbegin());
}
else {
second = first;
}
printf("%d\n", second % first);
}
int main()
{
while(scanf("%d",&N)==1)
{
S.clear();
for(int i=0; i<N; i++)
{
scanf("%d",A+i);
S.insert(A[i]);
}
//sort(A,A+N);
for(set<int>::reverse_iterator rit=S.rbegin();; rit=S.rbegin())
{
//cout<<(*rit)<<endl;
int now=(*rit)/2;
set<int>::iterator it=S.find(now);
while(it!=S.end())now/=2,it=S.find(now);//,cout<<"rit"<<endl;
if(now==0)break;
S.erase(*rit);
S.insert(now);
}
//cout<<"YEE"<<endl;
for(set<int>::iterator it=S.begin(); it!=S.end(); it++)
{
if(it!=S.begin())printf(" ");
printf("%d",(*it));
}
puts("");
}
return 0;
}
int main()
{
while(1)
{
scanf("%d",&cmd);
switch(cmd)
{
case 0:
return 0;
case 1:
scanf("%d%d",&a,&b);
q.insert(mp(b,a));
break;
case 2:
if(q.empty()) printf("0\n");
else
{
printf("%d\n",q.rbegin()->second);
q.erase(q.find(*q.rbegin()));
}
break;
case 3:
if(q.empty()) printf("0\n");
else
{
printf("%d\n",q.begin()->second);
q.erase(q.begin());
}
break;
}
}
return 0;
}
int CDetCandit::Get_START_Boundary_Range_For_END(set<size_t>& START_s, set<size_t>& END_s, int Curposit, int limit)
{
int FeedBorder = limit;
for(set<size_t>::reverse_iterator rsite = START_s.rbegin(); rsite != START_s.rend(); rsite++){
if((int)*rsite < Curposit){
FeedBorder = *rsite;
break;
}
}
set<size_t>::reverse_iterator rsite;
for(rsite = END_s.rbegin(); rsite != END_s.rend(); rsite++){
if(((int)*rsite < Curposit) && ((int)*rsite < FeedBorder)){
FeedBorder = *rsite;
break;
}
}
/*for(rsite = END_s.rbegin(); rsite != END_s.rend(); rsite++){
if(((int)*rsite < Curposit) && ((int)*rsite < FeedBorder)){
FeedBorder = *rsite;
break;
}
}*/
/*if(FeedBorder < Curposit){
FeedBorder++;
}*/
/*set<size_t>::reverse_iterator rsite;
for(rsite = END_s.rbegin(); rsite != END_s.rend(); rsite++){
if((int)*rsite < Curposit){
FeedBorder = *rsite;
break;
}
}*/
/*if(rsite != END_s.rend()){
rsite++;
if(rsite != END_s.rend()){
FeedBorder = *rsite;
}
}
if(rsite != END_s.rbegin()){
FeedBorder++;
}*/
if(FeedBorder < limit){
FeedBorder = limit;
}
for(int i = CAND_FEEDBACK_NUM; (i >= 0) && (FeedBorder > limit); i--){
FeedBorder--;
}
return FeedBorder;
}
int main () {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
x.insert(a);
}
it = x.begin();
++it;
jt = x.begin();
while (it != x.end()) {
s[*jt-*it].push_back(*it);
}
bool ty = 1;
while (x.size() > 2) {
if (ty) {
} else {
}
ty = !ty;
}
printf("%d\n", *(x.rbegin())-*(x.begin()));
}
int main()
{
int n;
cin >> n;
for (int i = 2; i <= 2 * n; i++)
for (int j = 1; j < i; j++)
{
int val;
cin >> val;
S.insert(make_pair(val, make_pair(i, j)));
}
vector<int> ans(2 * n + 1);
set<int> toAllot;
for (int i = 1; i <= 2 * n; i++)
toAllot.insert(i);
for (auto it = S.rbegin(); it != S.rend(); it++)
{
int a = (*it).second.first;
int b = (*it).second.second;
if (toAllot.count(a) and toAllot.count(b))
ans[a] = b, ans[b] = a, toAllot.erase(a), toAllot.erase(b);
}
for (int i = 1; i <= 2 * n; i++)
cout << ans[i] << ' ';
return 0;
}
int main(void)
{
int N;
int remain=0;
string name,operation;
cin>>N;
for (int i=0;i<N;i++)
{
cin>>name>>operation;
if (operation=="enter")
{
remain++;
container.insert(name);
}
if (operation=="leave")
{
set<string>::iterator it=container.find(name);
if (it!=container.end())
{
container.erase(it);
remain--;
}
}
}
set<string>::reverse_iterator it_2=container.rbegin();
for (;it_2!=container.rend();++it_2)
cout<<*it_2<<endl;
return 0;
}
int main()
{
scanf("%d", &n);
for(int i = 0; i < n; ++i)
{
scanf("%d%d", x + i, y + i);
Hash[{x[i], y[i]}] = i;
}
for(int i = 0; i < n; ++i)
if(check(x[i], y[i]))
Cube.insert(i);
for(int i = 0; i < n; ++i)
{
int now = i & 1 ? *Cube.begin() : *Cube.rbegin();
ans = ((long long)ans * n + now) % mod;
Cube.erase(now);
Hash.erase({x[now], y[now]});
for(int d = -2, k; d <= 2; ++d)
if(Hash.count({x[now] + d, y[now]}) && Cube.count(k = Hash[{x[now] + d, y[now]}]) && !check(x[now] + d, y[now]))
Cube.erase(k);
if(!y[now])
continue;
for(int d = -1, k; d <= 1; ++d)
if(Hash.count({x[now] + d, y[now] - 1}) && !Cube.count(k = Hash[{x[now] + d, y[now] - 1}]) && check(x[now] + d, y[now] - 1))
Cube.insert(k);
}
printf("%d\n", ans);
return 0;
}
void append_next() {
int biggest = *(prime_list.rbegin()) + 2;
while (!is_prime(biggest)) {
biggest += 2;
}
prime_list.insert(biggest);
}
int main()
{
scanf("%d", &T);
while(T--){
scanf("%d %d", &n, &k);
s.clear();
set<pair<int, int> >::iterator it;
set<pair<int, int> >::reverse_iterator rit;
long long ans = 0; int x, h = 1;
for (int i = 1; i <= n; i++){
scanf("%d", &x);
while(!s.empty()){
it = s.begin();
if (abs(x - it->first) >= k){
h = max(h, it->second + 1);
s.erase(*it);
}
else break;
}
while(!s.empty()){
rit = s.rbegin();
if (abs(rit->first - x) >= k){
h = max(h, rit->second + 1);
s.erase(*rit);
}
else break;
}
ans += i - h + 1;
s.insert(make_pair(x, i));
}
printf("%I64d\n", ans);
}
return 0;
}
int main() {
int t, n;
while (true) {
cin >> t >> n;
if (t + n == 0) break;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
for (int i = 0; i < n; ++i) {
vector<int> ans;
go (i, 0, t, n, ans, v);
}
if (!st.size()) {
cout << "Sums of " << t << ":" << endl << "NONE" << endl;
continue;
}
cout << "Sums of " << t << ":" << endl;
set< vector<int> > :: reverse_iterator it;
for (it = st.rbegin(); it != st.rend(); ++it) {
vector<int> cur = *it;
cout << cur[0];
for (int j = 1; j < cur.size(); ++j) {
cout << "+" << cur[j];
}
cout << endl;
}
st.clear();
}
return 0;
}
int main(int argc, char *argv[]) {
int N, W, lo, hi, res, mi, ma;
N = nextInt();
W = nextInt();
for(int i = 0; i < N; ++i)
A[i] = nextInt();
if(W == 1) {
printf("%d\n",N);
} else {
S.clear();
for(int i = 0; i < W - 1; ++i)
S.insert(A[i]);
lo = 0;
res = 0;
hi = W - 1;
while(hi < N) {
S.insert(A[hi]);
ma = *S.rbegin();
mi = *S.begin();
if(ma - mi + 1 == W) res++;
S.erase(S.find(A[lo]));
lo++;
hi++;
}
printf("%d\n",res);
}
return 0;
}
int main()
{
int i, j;
#ifdef DEBUG
freopen("./in", "r", stdin);
freopen("./out", "w", stdout);
#endif
scanf("%d%d%d", &n, &s, &l);
for(i = 1; i <= n; i++)
scanf("%d", &in[i]);
j = 1;
for(i = 1; i <= n; i++){
S.insert(bbq(in[i], i));
while(!S.empty() && S.rbegin()->first - S.begin()->first > s ){
S.erase(bbq(in[j], j));
j++;
}
if(i >= l && -1 != dp[i - l])
R.insert(bbq(dp[i - l], i - l));
while(!R.empty() && R.begin()->second < j - 1)
R.erase(R.begin());
dp[i] = R.empty() ? -1 : R.begin()->first + 1;
}
printf("%d\n", dp[n]);
return 0;
}
int calc() {
int total = 1;
set<pair<int, int> >::reverse_iterator it = data.rbegin();
set<pair<int, int> >::reverse_iterator lastIt = data.rbegin();
it++;
int pos = n - 2;
int lastPos = n - 1;
while (it != data.rend()) {
while (lastIt->first >= it->first + d) {
lastIt++;
lastPos--;
}
total = total * (LLI)(lastPos - pos + 1) % MOD;
it++;
pos--;
}
return total;
}
int main(){
int n;cin >> n;
int t;cin >> t;
int c;cin >> c;
for(int i=0;i<n;i++) cin >> a[i];
for(int i=0;i<c;i++) s.insert(MP(a[i],i));
int ans = 0;
for(int i=c;i<n;i++){
II top = *(s.rbegin());
if(top.F <= t) ans++;
s.erase(s.find(MP(a[i-c],i-c)));
s.insert(MP(a[i],i));
}
II top = *(s.rbegin());
if(top.F <= t) ans++;
cout << ans << endl;
return 0;
}
int main()
{
int m;
ll upright,up,upleft,downright,down,downleft;
ll x,y;
ii Cu;
cin >> m;
for(int i=1;i<=m;i++) {
cin >> x >> y;
cube[mp(x,y)] = i;
pos[i] = mp(x,y);
}
for(int i=1;i<=m;i++)
if(check(i))
top.insert(i);
vector <ll> number;
int turn = 1;
for(int i=0;i<m;i++) {
ll k;
if(turn)
k = *(top.rbegin());
else
k = *(top.begin());
number.pb(k);
Cu = pos[k];
x = Cu.fi;
y = Cu.se;
top.erase(k);
pos.erase(k);
cube.erase(mp(x,y));
for(int j=-2;j<=2;j++) {
if(!j)
continue;
if(!check(cube[mp(x+j,y)]))
top.erase(cube[mp(x+j,y)]);
}
downright = cube[mp(x+1,y-1)];
down = cube[mp(x,y-1)];
downleft = cube[mp(x-1,y-1)];
if(check(downright))
top.insert(downright);
if(check(down))
top.insert(down);
if(check(downleft))
top.insert(downleft);
turn = (turn) ? 0:1;
}
reverse(all(number));
ll res = 0;
for(int i=0;i<number.size();i++) {
res += (number[i]-1) * fastexp(m,i);
res %= MOD;
}
cout << res;
return 0;
}
void add_variant(const Entry &entry) {
if (isinf(entry.value) || isnan(entry.value) || max_variants == 0) return;
if ((int)variants.size() < max_variants || entry.value < variants.rbegin()->value) {
variants.insert(entry);
if (max_variants < (int)variants.size()) {
set<Entry>::iterator i = variants.end();
variants.erase(--i);
}
}
}
bool possible(set<pair<int, int>> &out, int index) { // *2 index
pair<int, int> add = get(index);
if (out.rbegin()->second < add.first) return true;
for (auto p : out) {
if (add.second < p.first) return true;
if (p.first <= add.second || add.first <= p.second) return false;
}
return true;
}
int main(int argc, char const *argv[])
{
scanf("%d", &n);
for (int i = 0; i < n; ++i)
scanf("%d", A + i);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (C(A[i] * A[j])) s.insert(A[i] * A[j]);
if (s.size())
printf("%d\n", *s.rbegin());
else printf("%d\n", -1);
return 0;
}
int main() {
int n;
scanf("%d", &n);
int x;
scanf("%d", &x);
values.insert(x);
neg_values.insert(-x);
for (int i = 1; i < n; ++i) {
scanf("%d", &x);
// handle the edge cases
if (x < *values.begin()) {
full_left.insert(*values.begin());
printf("%d ", *values.begin());
} else if (x > *values.rbegin()) {
full_right.insert(*values.rbegin());
printf("%d ", *values.rbegin());
} else {
// find the nodes surrounding x
int lower = -1 * (*neg_values.upper_bound(-x));
int upper = *values.upper_bound(x);
// printf("%d %d %d\n", lower, x, upper);
assert(full_right.count(lower) ^ full_left.count(upper));
if (full_right.find(lower) == full_right.end()) {
full_right.insert(lower);
printf("%d ", lower);
} else {
full_left.insert(upper);
printf("%d ", upper);
}
}
values.insert(x);
neg_values.insert(-x);
}
}
//==============================================
int CDetCandit::Get_Left_Outer_Feature_Range_For_START(set<size_t>& START_s, set<size_t>& END_s, int Curposit, int limit)
{
int FeedBorder = limit;
for(set<size_t>::reverse_iterator rsite = END_s.rbegin(); rsite != END_s.rend(); rsite++){
if((int)*rsite < Curposit){
FeedBorder = *rsite;
break;
}
}
if(FeedBorder < limit){
FeedBorder = limit;
}
return FeedBorder;
}
void* AGDaemonID_local_timeout_thread (void* cls) {
struct timespec request;
struct timespec remain;
while (true) {
request.tv_sec = 30;
request.tv_nsec = 0;
remain.tv_sec = 0;
remain.tv_nsec = 0;
int rc = clock_nanosleep(CLOCK_MONOTONIC, 0,
&request, &remain);
if (rc < 0)
perror("clock_nanosleep");
//Traverse the set...
set<AGDaemonID_local*, AGDaemonID_comp>::reverse_iterator itr;
fwd_itr fitr;
for (itr = agd_set.rbegin(); itr != agd_set.rend(); itr++) {
AGDaemonID_local *agdl = *itr;
time_t current_time;
time(¤t_time);
if ((current_time - agdl->pulse_ts) >= agdl->freq * 2) {
syslog(LOG_WARNING, "%s:%i Pulse rate lower than anticipated (%i)\n", agdl->addr.c_str(), agdl->port, agdl->freq);
//ping
PingResponse pr;
thrift_connection *tc = thrift_connect(agdl->addr.c_str(), agdl->port, false);
if (tc->is_connected) {
tc->ag_client->ping(pr);
if (pr.id != agdl->id) {
syslog(LOG_CRIT, "%s:%i Returns an unexpected ID\n", agdl->addr.c_str(), agdl->port);
del_set.insert(agdl);
continue;
}
fitr = agd_set.find(*itr);
agd_set.erase(fitr);
time(&(agdl->pulse_ts));
agd_set.insert(agdl);
}
else {
syslog(LOG_CRIT, "%s at %s:%i", tc->err, agdl->addr.c_str(), agdl->port);
del_set.insert(agdl);
}
thrift_disconnect(tc);
}
else {
break;
}
}
delete_elements();
}
return NULL;
}
// By going through the list backwards I can ensure the first entry.
void generateDensity( DensityStruct *dStruct) {
int i, mw_int;
for(i = 0; i < MAX_PEPTIDE_MASS*DENSITY_MULTIPLIER; i++) {
dStruct[i].numEntries = 0;
dStruct[i].firstEntry = 0;
}
for(i = globalPeptideSet.size(), revPepSetIter = globalPeptideSet.rbegin(); revPepSetIter != globalPeptideSet.rend(); --i, ++revPepSetIter) {
mw_int = (int) ( (*revPepSetIter).neutralMass*DENSITY_MULTIPLIER);
dStruct[mw_int].numEntries += 1;
dStruct[mw_int].firstEntry = i;
}
/*for(i = 0; i < MAX_PEPTIDE_MASS*DENSITY_MULTIPLIER; i++) {
cout << i << " " << dStruct[i].numEntries << " " << dStruct[i].firstEntry << endl;
}*/
}
bool is_prime(int n) {
if (n <= *(prime_list.rbegin())){
if (prime_list.count(n)) {
return true;
}
return false;
} else {
auto it = prime_list.begin();
while ((*it)*(*it) <= n) {
if (n%(*it) == 0) {
return false;
}
it++;
}
return true;
}
}
void solve(int case_num) {
bool valid = true;
int len = n;
while (true) {
if (len <= 2) {
valid = false;
break;
}
int target_ind = (len - 1) / 2;
int seen = 0;
int ind = 0;
while (seen < target_ind) {
if (!used[ind]) {
++seen;
}
++ind;
}
while (used[ind]) {
++ind;
}
int val = a[ind];
if (val == *(all_vals.begin())) {
used[ind] = true;
all_vals.erase(all_vals.begin());
} else if (val == *(all_vals.rbegin())) {
used[ind] = true;
auto ptr = all_vals.end();
ptr = prev(ptr);
all_vals.erase(ptr);
} else {
break;
}
--len;
}
printf("Case #%d: %s\n", case_num, !valid ? "YES" : "NO");
}
void CDetCandit::Greedy_Right_to_Left_matching(set<size_t>& START_s, set<size_t>& END_s, int Curposit, int limit, size_t Match_Distance, set<size_t>& Match_s)
{
if(END_s.find(Curposit) == END_s.end()){
AppCall::Secretary_Message_Box("Data Error in CDetCandit::Greedy_Right_to_Left_matching()...", MB_OK);
}
size_t loc_Distance = 0;
for(set<size_t>::reverse_iterator rsite = START_s.rbegin(); rsite != START_s.rend(); rsite++){
if((int)(*rsite) <= Curposit){
Match_s.insert(*rsite);
if(++loc_Distance == Match_Distance){
break;
}
}
}
if(Match_s.empty()){
Match_s.insert(limit);
}
}
int main() {
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i)
scanf("%d", c + i);
for(int i = 1; i <= m; ++i)
sp.insert(make_pair(c[i], i));
for(int i = 1; i <= n; ++i) {
if(i + m <= n)
sp.insert(make_pair(c[i + m], i + m));
pair<int, int> cur = *sp.rbegin();
sp.erase(cur);
out[cur.second] = i + m;
ans += (LL)(i + m - cur.second) * cur.first;
}
printf("%I64d\n", ans);
for(int i = 1; i <= n; ++i)
printf("%d%c", out[i], " \n"[i == n]);
return 0;
}
int main() {
scanf("%d", &n);
int last;
scanf("%d", &last);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
d[i] = x - last;
last = x;
}
n--;
for (int i = 1; i <= n;) {
if (d[i] == 0) {
hills.insert(Hill(0, pii(i, i)));
invhills.insert(InvHill(pii(i, i), 0));
i++;
continue;
}
int j = i;
if (d[i] > 0) while (j + 1 <= n && d[j + 1] > 0) j++;
while (j + 1 <= n && d[j + 1] < 0) j++;
hills.insert(Hill(j - i + 1, pii(i, j)));
invhills.insert(InvHill(pii(i, j), j - i + 1));
i = j + 1;
}
print_hills();
int q;
for (scanf("%d", &q); q--;) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
upd(l - 1, x);
print_hills();
upd(r, -x);
print_hills();
if (n == 0) printf("1\n");
else printf("%d\n", hills.rbegin()->first + 1);
}
return 0;
}
repe(e, sweep) {
if (e.y.x) {
active.erase(mp(r[e.y.y], e.y.y));
lft.erase(mp(l[e.y.y], e.y.y));
} else {
active.insert(mp(r[e.y.y], e.y.y));
lft.insert(mp(l[e.y.y], e.y.y));
if (sz(active) == k+1) {
lft.erase(mp(l[active.begin()->y], active.begin()->y));
active.erase(active.begin());
}
if (sz(active) == k) {
int t = active.begin()->x - lft.rbegin()->x + 1;
if (t == ans) {
vt(int) v;
repe(a, active) {
v.push_back(a.y+1);
}
sort(all(v));
return v;
}
