void addNum(int val) {
if (isExist[val]) return;
isExist[val] = true;
int left = val, right = val;
if (leftBound.find(val+1) != leftBound.end()) {
right = leftBound[val+1].end;
interval.erase(leftBound[val+1]);
leftBound.erase(val+1);
rightBound.erase(right);
}
if (rightBound.find(val-1) != rightBound.end()) {
left = rightBound[val-1].start;
interval.erase(rightBound[val-1]);
leftBound.erase(left);
rightBound.erase(val-1);
}
Interval i = Interval(left, right);
interval.insert(i);
leftBound[left] = i;
rightBound[right] = i;
return;
}
void insert_set(ll l, ll r) {
it = S.upper_bound({l, l + r - 1});
elem ra = *it; it--;
elem la = *it;
if(la.y + 1 >= l && ra.x - 1 <= (l + r - 1)) {
set<elem>::iterator temp = it;
printf("%lld %lld\n", la.y + 1, ra.x - 1);
S.erase(++it);
S.erase(temp);
S.insert({la.x, ra.y});
}
else {
if(l <= la.y + 1) {
ll left = la.x, right = la.y + r;
S.erase(it);
printf("%lld %lld\n", la.y + 1, min(right, ra.x - 1));
S.insert({left, min(right, ra.x - 1)});
}
else if((l + r - 1) >= ra.x - 1 ) {
S.erase(++it);
printf("%lld %lld\n", l, ra.x - 1);
S.insert({ l, ra.y });
}
else {
printf("%lld %lld\n", l, l + r - 1);
S.insert({l, l + r - 1});
}
}
}
bool check(int mid)
{
// debug(mid)
st.clear();
repI(i,v.size())st.insert({v[i],i});
queue<pair<ll,int> > q[2];
int cur = 0;
int prv = 1;
repI(i,mid)
{
q[cur].push(*st.begin());
st.erase(*st.begin());
}
void calculate_combinations(set< set < int > >& result,
set< int > stack,
vector< int > target, int offset, int number){
if(number == 0) {
result.insert(stack);
return;
}
for(int i = offset; i <= target.size() - number; i++){
stack.insert(target[i]);
calculate_combinations(result, stack, target, i + 1, number - 1);
stack.erase(target[i]);
}
}
void discoverInstrumentationLevel(set<string> & UserFunctions, map<string, vector<string> > & LoopLevels)
{
set<string>::iterator uf_it = UserFunctions.begin();
set<string>::iterator uf_end = UserFunctions.end();
while(uf_it != uf_end)
{
vector<string> tokens;
string uf = *uf_it;
split(tokens, uf, SPLIT_CHAR);
if (tokens.size() > 1)
{
string uf_name = tokens[0]; // [kernel]+loop_1.1,loop_1.2
string bb_part = tokens[1]; // kernel+[loop_1.1,loop_1.2]
tokens.clear();
split(tokens, bb_part, ',');
for(unsigned i=0; i < tokens.size(); i++)
{
LoopLevels[uf_name].push_back(tokens[i]);
}
UserFunctions.erase(uf_it);
UserFunctions.insert(uf_name);
}
uf_it++;
}
uf_it = UserFunctions.begin();
uf_end = UserFunctions.end();
cout<< PACKAGE_NAME": XML functions parsed: ";
while(uf_it != uf_end){
if (LoopLevels.find(*uf_it) != LoopLevels.end())
{
cout<< "\""<<*uf_it<<"\"" <<"->[loops:";
for(unsigned i=0; i < LoopLevels[*uf_it].size(); i++){
cout<<LoopLevels[*uf_it][i]<<",";
}
cout<<"]";
}
else
{
cout<< "\""<<*uf_it<<"\"";
}
set<string>::iterator uf_it_plus_one = uf_it;
uf_it_plus_one++;
if (uf_it_plus_one != uf_end)
{
cout<<";";
} else cout<<endl;
uf_it++;
}
}
int main() {
int i, j, t, ans, now;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &c[i]);
for (j = 0; j < c[i]; j++) {
scanf("%d", &t);
q[i].pb(t);
}
}
scanf("%d", &m);
while (m--) {
scanf("%d %d %d %d", &X, &A, &Y, &B);
X--, Y--;
if (A > c[X]) A = c[X];
if (B > c[Y]) B = c[Y];
hx.clear(), hy.clear();
for (i = 0; i < A; i++) hy.pb(q[X][i]);
for (i = B; i < c[Y]; i++) hy.pb(q[Y][i]);
for (i = 0; i < B; i++) hx.pb(q[Y][i]);
for (i = A; i < c[X]; i++) hx.pb(q[X][i]);
q[X] = hx, q[Y] = hy;
c[X] = hx.size(), c[Y] = hy.size();
// for (i = 0; i < n; i++) {
// cout << "i= " << i << '\n';
// for (j = 0; j < c[i]; j++) cout << q[i][j] << ' ';
// puts("");
// }
// system("pause");
s.clear();
for (i = 0; i < n; i++) {
s.insert(gao(i));
}
ans = now = 0;
while (!s.empty()) {
it = s.begin();
s.erase(it);
if (it->X <= now) now += c[it->Y];
else {
ans += it->X - now;
now = it->X + c[it->Y];
}
}
printf("%d\n", ans);
}
return 0;
}
void toggleSegment(int y1, int y2) {
vector<pii> addSegments;
vector<pii> remSegments;
set< pair<bool, pii> >::iterator lb;
// Remove intersection of segment starting BEFORE y1 with (y1, y2)
lb = segments.lower_bound(make_pair(END, make_pair(-y1, -oo)));
for (; lb != segments.end(); lb++) {
int _y1 = -lb->second.first, _y2 = -lb->second.second;
if (_y2 >= y1 && _y1 < y1) {
remSegments.push_back(make_pair(_y1, _y2));
if (_y1 < y1)
addSegments.push_back(make_pair(_y1, y1));
if (y2 < _y2)
addSegments.push_back(make_pair(y2, _y2));
y1 = _y2;
}
break;
}
// Remove intersection of segments starting AFTER y1 with (y1, y2)
lb = segments.lower_bound(make_pair(START, make_pair(y1, -oo)));
for (; lb != segments.end(); lb++) {
if (lb->first != START) break;
int _y1 = lb->second.first, _y2 = lb->second.second;
if (_y1 >= y2) break;
addSegments.push_back(make_pair(y1, _y1));
if (_y2 <= y2) {
remSegments.push_back(make_pair(_y1, _y2));
y1 = _y2;
} else {
remSegments.push_back(make_pair(_y1, _y2));
addSegments.push_back(make_pair(y2, _y2));
y1 = _y2;
}
}
if (y1 < y2)
addSegments.push_back(make_pair(y1, y2));
for (int i = 0; i < remSegments.size(); i++) {
segments.erase(make_pair(START, make_pair(remSegments[i].first, remSegments[i].second)));
segments.erase(make_pair(END, make_pair(-remSegments[i].first, -remSegments[i].second)));
}
for (int i = 0; i < addSegments.size(); i++) {
if (addSegments[i].first != addSegments[i].second) {
segments.insert(make_pair(START, make_pair(addSegments[i].first, addSegments[i].second)));
segments.insert(make_pair(END, make_pair(-addSegments[i].first, -addSegments[i].second)));
}
}
}
virtual void gotObject( const BSONObj& obj ) {
if (_curns == OPLOG_SENTINEL) { // intentional ptr compare
if (obj["op"].valuestr()[0] == 'n') // skip no-ops
return;
// exclude operations that don't meet (timestamp) criteria
if ( _opmatcher.get() && ! _opmatcher->matches ( obj ) ) {
_oplogEntrySkips++;
return;
}
string db = obj["ns"].valuestr();
db = db.substr(0, db.find('.'));
BSONObj cmd = BSON( "applyOps" << BSON_ARRAY( obj ) );
BSONObj out;
conn().runCommand(db, cmd, out);
_oplogEntryApplies++;
// wait for ops to propagate to "w" nodes (doesn't warn if w used without replset)
if (mongoRestoreGlobalParams.w > 0) {
string err = conn().getLastError(db, false, false, mongoRestoreGlobalParams.w);
if (!err.empty()) {
error() << "Error while replaying oplog: " << err;
}
}
}
else if (nsToCollectionSubstring(_curns) == "system.indexes") {
createIndex(obj, true);
}
else if (mongoRestoreGlobalParams.drop &&
nsToCollectionSubstring(_curns) == ".system.users" &&
_users.count(obj["user"].String())) {
// Since system collections can't be dropped, we have to manually
// replace the contents of the system.users collection
BSONObj userMatch = BSON("user" << obj["user"].String());
conn().update(_curns, Query(userMatch), obj);
_users.erase(obj["user"].String());
}
else {
conn().insert( _curns , obj );
// wait for insert to propagate to "w" nodes (doesn't warn if w used without replset)
if (mongoRestoreGlobalParams.w > 0) {
string err = conn().getLastError(_curdb, false, false, mongoRestoreGlobalParams.w);
if (!err.empty()) {
error() << err;
}
}
}
}
void update(set<int>&s , int pos, int col){
if (a[pos]== col){
return ;
}
if (pos == 1){
if (a[pos] == a[pos+1]){
s.insert(2) ; a[pos] = col ; return ;
}
else{
if (col == a[pos+1]){
s.insert(1) ; s.erase(2) ; a[pos] = col ; return ;
}
}
}
if (a[pos-1] == a[pos+1]){
if (a[pos]==a[pos+1]){
s.insert(pos) ; s.insert(pos+1) ; a[pos] = col ; return ;
}
if (a[pos]!=a[pos+1]){
if (col == a[pos+1]){
s.erase(pos) ; s.erase(pos+1) ; a[pos] = col ; return ;
}
}
}
else {
if (a[pos]==a[pos+1]){
if (col != a[pos-1]){
s.insert(pos) ; s.insert(pos+1) ; a[pos] = col ; return ;
}
if (col == a[pos-1]){
s.insert(pos+1) ;s.erase(pos) ; a[pos] = col ; return ;
}
}
if (a[pos] == a[pos-1]){
if (col == a[pos+1]){
s.insert(pos) ; s.erase(pos+1) ; a[pos] = col ; return ;
}
else{
s.insert(pos) ; s.insert(pos+1) ; a[pos] = col ; return ;
}
}
if ((a[pos]!= a[pos-1]) && (a[pos]!= a[pos+1])){
if (col == a[pos-1]){
s.erase(pos) ; s.insert(pos+1) ; a[pos] = col ; return ;
}
if (col == a[pos+1]){
s.erase(pos+1) ; s.insert(pos) ; a[pos] = col ; return ;
}
}
}
}
int remove_set(set<int> my_set) {
double start_time;
double end_time;
double result_time;
start_time = clock();
for (int i = 0; i < my_set.size(); ++i)
my_set.erase(i);
end_time = clock();
result_time = end_time - start_time;
cout << " Remove set: " << result_time / CLOCKS_PER_SEC << "s." << endl;
return 0;
}
int main()
{
int i,b,hh,len;
while(EOF!=scanf("%s",cc))
{
n=0;
hh=1;
len=strlen(cc);
cc[len++]='W';
for(i=0; i<=len; i++)
L[i]=i-1,R[i]=i+1,head[i]=tail[i]=i;
for(i=1; i<len; i++)
{
if(cc[i]==cc[i-1])
hh++;
else
{
++n;
self[n]=num[n]=hh;
color[n]=cc[i-1];
pos[n]=i-hh+1;///偏离量为1
hh=1;
}
}
H.clear();
for(i=1; i<=n; i++)
H.insert(i);
while(!H.empty())
{
it=--H.end();
b=*it;
if(num[b]==1)
break;
H.erase(it);
del(b);
}
}
return 0;
}
void optimize_feedback() {
for(set<uint64_t>::iterator optimize_it =
advertise_hashes.begin();
optimize_it!= advertise_hashes.end(); ){
if(hashes_seen_already.find(*optimize_it) != hashes_seen_already.end()) {
/* hash already seen so remove it*/
advertise_hashes.erase(optimize_it++);
} else {
hashes_seen_already[*optimize_it] = true;
++optimize_it;
}
}
return;
}
void eliminate(set<pair<ull,int>,greater<pair<ull,int> > > & vec){
for(set<pair<ull,int> >::iterator it1=vec.begin();it1!=vec.end();it1++){
int l=it1->second;
ull f=it1->first;
if(l==0){
vec.erase(it1);
break;
}
set<pair<ull,int> >::iterator it2=it1;
it2++;
while(it2!=vec.end() && l==it2->second){
ull temp=f^(it2->first);
vec.erase(it2);
if(temp!=0)
vec.insert(make_pair(temp,length(temp)));
it2=it1;
it2++;
}
}
}
void make_w(int pos,int flag){
set<p3>::iterator it = b.lower_bound(p3(pii(pos,0),0));
if(it->second==flag)return;
//cout<<(it==b.end())<<endl;
int from = it->first.second;
int to = it->first.first;
b.erase(it);
if(pos-1>=from)
add(from, pos-1, 1-flag);
add(pos,pos,flag);
if(pos+1<=to)
add(pos+1,to,1-flag);
}
void set_test(set<int> a) {
a.erase(1);
return;
StaticVertex* st1 = new StaticVertex("1");
StaticVertex* st2 = new StaticVertex("1");
shared_ptr<StaticVertex> sh1(st1);
shared_ptr<StaticVertex> sh2(st2);
unordered_set<shared_ptr<StaticVertex>, KeyHasher>* s = new unordered_set<shared_ptr<StaticVertex>, KeyHasher>();
s->insert(s->begin(), sh1);
s->insert(s->begin(), sh2);
cout << s->size();
// delete s;
}
void addNum(int val) {
set< pair<int, int> >::iterator jt = S.lower_bound(make_pair(val, val));
set< pair<int, int> >::iterator it = prev(jt);
if (it != S.end() && val >= it->first && val <= it->second)
return ;
if (jt != S.end() && val >= jt->first && val <= jt->second)
return ;
if (it != S.end() && jt != S.end() && it->second == val-1 && jt->first == val+1) {
int l = it->first, r = jt->second;
S.erase(it), S.erase(jt);
S.insert(make_pair(l, r));
} else if (it != S.end() && it->second == val-1) {
int l = it->first;
S.erase(it);
S.insert(make_pair(l, val));
} else if (jt != S.end() && jt->first == val+1) {
int r = jt->second;
S.erase(jt);
S.insert(make_pair(val, r));
} else {
S.insert(make_pair(val, val));
}
}
int add_city(char s[25]){
int i;
string ss = string(s);
if(!mpc.count(ss)){
cc[ict].d = 0;
cc[ict].name = ss;
cc[ict].qto = 0;
mpc.insert(make_pair(ss, ict++));
return ict-1;
}
int ret = mpc[ss];
st.erase(ret);
return ret;
}
void TeAbstractTheme::setStatusForObjectsAddedByPointing(set<string>& oidSet)
{
if (oidSet.empty())
return;
unsigned int i;
string oid, uid;
vector<string> prevOidPointedVec; // previous oids pointed
vector<string> uidVec; // vector of uids
map<string, int>::iterator mapIt;
set<string>::iterator setIt;
// Get the previous oids pointed
for (mapIt = objStatusMap_.begin(); mapIt != objStatusMap_.end(); ++mapIt)
{
oid = mapIt->first;
if (objStatusMap_[oid] == TePOINTED || objStatusMap_[oid] == TePOINTED_QUERIED)
prevOidPointedVec.push_back(mapIt->first);
}
// If there is any object in the oidSet that is already in the previous oids pointed,
// remove it from the oidSet
for (i = 0; i < prevOidPointedVec.size(); ++i)
{
oid = prevOidPointedVec[i];
if (oidSet.find(prevOidPointedVec[i]) != oidSet.end())
oidSet.erase(oid);
}
// Set the pointed status for the objects added by pointing
for (setIt = oidSet.begin(); setIt != oidSet.end(); ++setIt)
{
oid = *setIt;
if (objStatusMap_[oid] == TeDEFAULT)
objStatusMap_[oid] = TePOINTED;
if (objStatusMap_[oid] == TeQUERIED)
objStatusMap_[oid] = TePOINTED_QUERIED;
}
// Set the pointed status for the uids of the objects added by pointing
uidVec = getItemVector(oidSet);
for (i = 0; i < uidVec.size(); ++i)
{
uid = uidVec[i];
if (itemStatusMap_[uid] == TeDEFAULT)
itemStatusMap_[uid] = TePOINTED;
else if (itemStatusMap_[uid] == TeQUERIED)
itemStatusMap_[uid] = TePOINTED_QUERIED;
}
}
void djikstra (int v) {
st.insert (mp (0, v));
for (int tt = 1; tt <= n; ++tt) {
st.insert (mp (INF, tt));
d[tt] = INF;
}
while (st.size ()) {
it = st.begin ();
int cur = it -> second;
st.erase (st.begin ());
for (int it = 0; it < (int) g[cur].size (); ++it) {
int len = g[cur][it].first;
int to = g[cur][it].second;
if (d[cur] + len < d[to]) {
st.erase (st.find (mp (d[to], to)));
d[to] = d[cur] + len;
p[to] = cur;
st.insert (mp (d[to], to));
}
}
}
}
void removeOldNullRules(set<char*>& rules, char* start){
set<char*>::iterator it;
char* rule;
for( it = rules.begin(); it != rules.end(); it++){
if( !(varEqual(start, *it))){
rule = getRulePtr(*it);
if( strcmp(rule, NULL_CHAR) == 0 ){
rules.erase(it);
}
}
}
}
void inqueue(int node,int mask,int cost){
if(shortest_path[node][mask]<=cost){
return;
}
pair<int,pair<int,int>> current = make_pair(shortest_path[node][mask],make_pair(node,mask));
auto it = queue.find(current);
if(it!=queue.end()){
queue.erase(it);
}
shortest_path[node][mask]=cost;
current.first=cost;
queue.insert(current);
}
void merges(set<dd> &segs){
set<dd> ans;
set<dd>::iterator it,aux;
double l,r;
for (it=segs.begin();it!=segs.end();){
l = (*it).first;
r = (*it).second;
aux = it;
aux++;
segs.erase(it);
it = aux;
while (it!=segs.end() && (*it).first<=r){
r = max(r,(*it).second);
aux = it;
aux++;
segs.erase(it);
it = aux;
}
segs.insert(dd(l,r));
}
}
void go(set<pair<int, int>> &out, int index, int len) { // real index
if (best < len) {
besti = index - len;
best = len;
}
if (n <= index) return;
if (len + (n-index) <= best) return;
if (possible(out, index*2)) {
pair<int, int> pp = get(index*2);
out.insert(pp);
go(out, index+1, len+1);
out.erase(pp);
}
if (possible(out, index*2+1)) {
pair<int, int> pp = get(index*2+1);
out.insert(pp);
go(out, index+1, len+1);
out.erase(pp);
}
}
void topology() {
int u, v;cnt=0;
set< int >::iterator it;
while(!nextNode.empty()) {
u = *nextNode.begin();
nextNode.erase(nextNode.begin());
order.PB(u);cnt++;
for(int i=0; i!=g[u].size(); i++) {
v = g[u][i];
indeg[v]--;
if(!indeg[v]) nextNode.insert(v);
}
}
}
void build(){
vector<pair<ll,ll> > bases;
EACH(it, tab){
if(!unavailable.count(it->second)) available.insert(it->second);
if(tab.count(make_pair(it->first.first-1, it->first.second-1))) bases.push_back(make_pair(it->first.first-1, it->first.second-1));
if(tab.count(make_pair(it->first.first, it->first.second-1))) bases.push_back(make_pair(it->first.first, it->first.second-1));
if(tab.count(make_pair(it->first.first+1, it->first.second-1))) bases.push_back(make_pair(it->first.first+1, it->first.second-1));
if(bases.size()==1){
unavailable.insert(tab[bases[0]]);
available.erase(tab[bases[0]]);
}
bases.clear();
}
}
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;
}
void solve() {
sort(d.begin(), d.end());
set<pair<int, int> >::iterator it;
for(int i = 0; i < n; ++i) {
it = c.lower_bound(make_pair(d[i].l, 0));
if(it == c.end()) --it;
else if(it->first > d[i].l) {
if(it == c.begin()) {
it = c.end();
--it;
sol[d[i].br] = it->second;
c.erase(it);
continue;
}
--it;
}
sol[d[i].br] = it->second;
c.erase(it);
sum+=d[i].cost;
}
printf("%d\n", sum);
for(int i = 0; i < n; ++i) printf("%d ", sol[i]+1);
}
int main(){
int cases = 0;
while ( scanf("%d", &N) && N ){
for ( int i=0; i < N; ++i ){
scanf("%d %d %d %d %d", X + i, Y + i, W + i, D + i, H + i);
E[2*i] = event( X[i] , pii (1, i) );
E[2*i + 1] = event( X[i] + W[i] , pii(0, i) );
vis[i] = false;
}
sort( E, E + 2*N );
int x, idx;
int lastH;
set<pii>::iterator it;
for ( int i=0; i < 2*N; ){
// Check the visible buildings
if ( !S.empty() ){
lastH = -1;
for ( it = S.begin(); it != S.end(); it++ ){
if ( H[ it->second ] > lastH ){
lastH = H[ it->second ];
vis[it->second] = true;
}
}
}
x = E[i].first;
while ( i < 2*N && E[i].first == x ){
idx = E[i].second.second;
if ( E[i].second.first == 1 ){
S.insert( pii( Y[idx], idx ) );
}
else {
S.erase( pii( Y[idx], idx ) );
}
i++;
}
}
if ( cases ) puts("");
printf("For map #%d, the visible buildings are numbered as follows:\n", ++cases);
int M = 0;
for ( int i=0; i < N; ++i )
if ( vis[i] ) ord[M++] = i;
sort( ord, ord + M, cmp );
for ( int i=0; i < M; ++i ){
if ( i ) putchar(' ');
printf("%d", ord[i] + 1);
}
puts("");
}
return 0;
}
void rem_down(int i, int j) {
if (min(i, j) <= 0 || max(i, j) > n) return;
if (!cand[i][j]) return;
st.erase(make_pair(i, j));
cand[i][j] = false;
if (inc_row(i))
rem_down(i, j-1), le[i] = max(le[i], j+1);
else
rem_down(i, j+1), ri[i] = min(ri[i], j-1);
if (inc_col(j))
rem_down(i-1, j), lo[j] = max(lo[j], i+1);
else
rem_down(i+1, j), hi[j] = min(hi[j], i-1);
}
void add(int val, int cnt){
if(cnt == 0)
return;
auto it = s.lower_bound(MP(val, 0));
if(it == s.end() or it->L != val)
s.insert(MP(val, cnt));
else{
pii x = *it;
s.erase(it);
x.R += cnt;
s.insert(x);
}
return;
}
