int main() { int que; scanf("%d", &que); for (int i = 0; i < que; i++) { scanf("%d %d %d", t+i, &p[i].x, &p[i].y); if (t[i]) { scanf("%d %d", &q[i].x, &q[i].y); } else { vp.push_back(make_pair(p[i], i)); } } sort(vp.begin(), vp.end()); for (int i = 0; i < vp.size(); i++) id[vp[i].second] = i+1; fen bup(vp.size() + 2), blow(vp.size()+ 2); for (int i = 0; i < que; i++) { if (t[i] == 0) { pair<point, int> now = make_pair(p[i], id[i]); lower.insert(now); set<pair<point, int> >::iterator it = lower.lower_bound(now); if (baddown(it)) lower.erase(it); else { blow.upd(now.second, +1); set<pair<point, int> >::iterator nx = it; nx++; while (nx != lower.end() && baddown(nx)) { blow.upd(nx->second, -1); lower.erase(nx++); } nx = it; while (nx != lower.begin()) { nx--; if (baddown(nx)) { blow.upd(nx->second, -1); lower.erase(nx); nx = it; } else break; } } // upper upper.insert(now); it = upper.lower_bound(now); if (badup(it)) upper.erase(it); else { bup.upd(now.second, +1); set<pair<point, int> >::iterator nx = it; nx++; while (nx != upper.end() && badup(nx)) { bup.upd(nx->second, -1); upper.erase(nx++); } nx = it; while (nx != upper.begin()) { nx--; if (badup(nx)) { bup.upd(nx->second, -1); upper.erase(nx); nx = it; } else break; } } } else { int ans = 1, tot = (int)upper.size() + (int)lower.size() - 4; set<pair<point, int> >::iterator lowa = lower.lower_bound(make_pair(p[i], -1)), lowb = lower.lower_bound(make_pair(q[i], -1)); set<pair<point, int> >::iterator upa = upper.lower_bound(make_pair(p[i], -1)), upb = upper.lower_bound(make_pair(q[i], -1)); if (lowa != lower.end() && lowb != lower.end() && lowa->first == p[i] && lowb->first == q[i]) { int d = blow.get(lowb->second) - blow.get(lowa->second); if (d > 0) { d--; ans = (tot-d >= d); } else { d = -d - 1; ans = (d >= tot-d); } } else if (upa != upper.end() && upb != upper.end() && upa->first == p[i] && upb->first == q[i]) { int d = bup.get(upb->second) - bup.get(upa->second); if (d > 0) { d--; ans = (d >= tot-d); } else { d = -d - 1; ans = (tot-d >= d); } } else if (lowa != lower.end() && upb != upper.end() && lowa->first == p[i] && upb->first == q[i]) { int d = blow.get(lowa->second) + bup.get(upb->second) - 3; ans = (d >= tot-d); } else if (upa != upper.end() && lowb != lower.end() && upa->first == p[i] && lowb->first == q[i]) { int d = blow.get(lowb->second) + bup.get(upa->second) - 3; ans = (tot-d >= d); } else { cerr << "Ooops!" << endl; assert(false); } puts(ans ? "CW" : "CCW"); } } return 0; }
//-------------------------------------- bool ofGetKeyPressed(int key){ if(key==-1) return pressedKeys.size(); return pressedKeys.find(key)!=pressedKeys.end(); }
set<int> SetOperation::Union() { set<int> result(setA.begin(), setA.end()); result.insert(setB.begin(), setB.end()); return result; }
int main() { scanf("%d %d", &n, &T); for (int i = 1; i <= n; i++) { scanf("%d %d", a + i, t + i); prob cur = prob(a[i], t[i], i); S.insert(cur); v.pb(cur); num[a[i]].pb(cur); } sort(v.begin(), v.end()); int temp = 0; for (int i = 1; i <= n; i++) { for (auto P : num[i - 1]) { //debug("(%d) ==> Deletando %d\n", i, P.id); if (S.find(P) != S.end()) S.erase(P); if (resp.find(P) != resp.end()) { temp -= P.t; resp.erase(P); } } set<prob>::iterator it = S.begin(); int tam = resp.size(); while (it != S.end() && tam < i) { resp.insert(*it); temp += it->t; S.erase(it); tam++; it = S.begin(); } //debug("--> %d %d\n", tam, temp); if (temp <= T) mx = max(mx, tam); // if (tam > mx && temp <= T) { // mx = tam; // //debug("(%d) --> %d %d\n", i, mx, temp); // final.clear(); // for (auto P : resp) // final.pb(P); // } } printf("%d\n%d\n", mx, mx); int cur = 1; for (int i = 0; i < n; i++) { if (cur <= mx && mx <= v[i].a) { printf("%d ", v[i].id); cur++; } } printf("\n"); }
void DoAnswer(MCONTACT hContact, const TalkBot::MessageInfo *info, bool sticky = false) { if (info->Answer[0] == _T('\0')) return; int waitTime, thinkTime = 0; int defWaitTime = Config.AnswerPauseTime * 1000; if (Config.PauseDepends) waitTime = defWaitTime * (int)info->Answer.length() / 25; else waitTime = defWaitTime; if (Config.PauseRandom) { //Let it be up to 4 times longer. waitTime = waitTime * (rand() % 300) / 100 + waitTime; } if (waitTime == 0) waitTime = 50; //it's essential, because otherwise message will be added later //then its response, that will cause incorrect ordering of //messages in the opened history (reopening will //help, but anyway it's no good) if (NotifyTyping(hContact) && Config.AnswerThinkTime) { thinkTime = Config.AnswerThinkTime * 1000; if (Config.PauseRandom) { //Let it be up to 4 times longer. thinkTime = thinkTime * (rand() % 300) / 100 + thinkTime; } } cs.Enter(); //Check if this contact's timer handler is now waiting for a cs. bool needTimerRearrange = false; if (!actionQueue.empty() && actionQueue.front().hContact == hContact) { needTimerRearrange = true; KillTimer(NULL, timerID); cs.Leave(); cs.Enter(); } if (!actionQueue.empty()) { list<QueueElement>::iterator it = actionQueue.end(); --it; while (true) { if ((*it).hContact == hContact) { if ((*it).Sticky) break; list<QueueElement>::iterator tmp = it; if (tmp != actionQueue.begin()) --tmp; actionQueue.erase(it); it = tmp; if (actionQueue.empty()) break; } if (it == actionQueue.begin()) break; --it; } } typingContactsLock.Enter(); if (typingContacts.find(hContact) != typingContacts.end()) { CallService(MS_PROTO_SELFISTYPING, hContact, (LPARAM)PROTOTYPE_SELFTYPING_OFF); typingContacts.erase(hContact); } typingContactsLock.Leave(); if (actionQueue.empty()) needTimerRearrange = true; if (thinkTime) actionQueue.push_back(QueueElement(hContact, StartTyping, thinkTime, NULL, sticky)); actionQueue.push_back(QueueElement(hContact, TimerAnswer, waitTime, info, sticky)); if (needTimerRearrange) UpdateTimer(); cs.Leave(); }
int main() { scanf("%d",&n); for(int i=1;i<=n;i++) { scanf("%d",&h[i].h); h[i].num=i; } for(int i=n;i;i--) { S.insert(h[i]); it=S.find(h[i]); if(it!=S.begin()) { it--; update(h[i],*it); if(it!=S.begin()) { it--; update(h[i],*it); it++; } it++; } if((++it)!=S.end()) { update(h[i],*it); if((++it)!=S.end()) update(h[i],*it); it--; } it--; } for(int i=1;i<=n;i++) { g[i][0]=next[next[i][1]][0]; f[i][0][0]=dist[i][1]; f[i][0][1]=dist[next[i][1]][0]; } for(int j=1;j<=20;j++) for(int i=1;i<=n;i++) { g[i][j]=g[g[i][j-1]][j-1]; f[i][j][0]=f[i][j-1][0]+f[g[i][j-1]][j-1][0]; f[i][j][1]=f[i][j-1][1]+f[g[i][j-1]][j-1][1]; } scanf("%d",&x0); int s0=0; LL a=1e15,b=0; for(int i=1;i<=n;i++) { LL dista=0,distb=0; query(i,x0,dista,distb); if(distb&&(!s0||a*distb>b*dista)) { s0=i; a=dista; b=distb; } } printf("%d\n",s0); scanf("%d",&m); while(m--) { int s,x; scanf("%d%d",&s,&x); LL dista=0,distb=0; query(s,x,dista,distb); printf("%lld %lld\n",dista,distb); } return 0; }
set<int> difference(const set<int>& s1, const set<int>& s2) { set<int> diff; set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(diff, diff.end())); return diff; }
int main(){ input_file.open( input_file_name ); while (input_file){ string s; if (!getline( input_file, s )) break; no_of_trans++; istringstream ss( s ); while (ss) { string s; if (!getline( ss, s, ',' )) break; items.insert(s); } } input_file.close(); cout << items.size() << endl; int id = 1; for (set<string>::iterator it = items.begin(); it != items.end(); it++) { item_ids_map.insert(pair<string, int>(*it, id)); ids_item_map.insert(pair<int, string>(id, *it)); id++; } /** for (map<string, int>:: iterator it = item_ids_map.begin(); it != item_ids_map.end(); it++) { cout << it->first << " -- " << it ->second << endl; } **/ vector<set<set<int> > > freq_itemsets; // finding 1 freq itemsets map<set<int>,int> temp_map; for (int i = 1; i<=items.size(); i++) { set<int> temp_set; temp_set.insert(i); temp_map.insert(pair<set<int>,int>(temp_set,0) ); } /** for (map<set<int>,int>::iterator it = temp_map.begin(); it != temp_map.end(); it++) { set<int> temp_set = it->first; cout << "{"; for (set<int>::iterator it1 = temp_set.begin(); it1 != temp_set.end(); it1++) { cout << *it1 << ","; } cout << "} -- " << it->second << endl; } **/ // iterating through every trasaction for counting support input_file.open( input_file_name); while (input_file) { string s; if (!getline( input_file, s )) break; istringstream ss( s ); set<int> trans_temp; while (ss) { string s; if (!getline( ss, s, ',' )) break; int item_id = item_ids_map.find(s)->second; set<int> temp_set; temp_set.insert(item_id); trans_temp.insert(item_id); temp_map.find(temp_set)->second++; } transactions_int.insert(trans_temp); } input_file.close(); set<set<int> > f1; for (map<set<int>,int>::iterator it = temp_map.begin(); it != temp_map.end(); it++) { float itemset_support = (it->second)/no_of_trans; set<int> temp_set = it->first; if (itemset_support > min_support) { f1.insert(temp_set); } } freq_itemsets.push_back(f1); // priting freq 1 item sets /** for (set<set<int> >::iterator it = f1.begin(); it != f1.end(); it++) { set<int> temp_set = *it; cout << "{"; for (set<int>::iterator it1 = temp_set.begin(); it1 != temp_set.end(); it1++) { cout << ids_item_map.find(*it1)->second << "," ; } cout << "}" << endl; } **/ int k = 1; while (true) { k = k+1; set<set<int> > fk; set<set<int> > ck = apriori_gen(freq_itemsets[k-2]); // printing candidate itemsets /** for (set<set<int> >::iterator it = ck.begin(); it != ck.end(); it++) { set<int> temp_set = *it; cout << "{"; for (set<int>::iterator it1 = temp_set.begin(); it1 != temp_set.end(); it1++) { cout << ids_item_map.find(*it1)->second << "," ; } cout << "}" << endl; } **/ // printing candidate itemsets // support counting for candidate itemsets // hash tree constructions and passing transactions // break if no candidates are generated if (ck.size() == 0) { break; } cout << "bef gen" << endl; fk = generate_fk_frm_ck(ck); cout << "end gen" << endl; if (fk.size() == 0) { break; }else{ freq_itemsets.push_back(fk); } } for (int i = 0; i<freq_itemsets.size(); i++) { cout << i+1 << " frequent itemsets" << endl; set<set<int> > temp_set_set = freq_itemsets[i]; for (set<set<int> >::iterator it = temp_set_set.begin(); it != temp_set_set.end(); it++) { set<int> temp_set = (*it); cout << "{"; for (set<int>::iterator it1 = temp_set.begin(); it1 != temp_set.end(); it1++) { cout << (*it1) << ","; } cout << "}" << endl; } cout << endl; } return 0; }
set<SgInitializedName*> computeLiveVars(SgStatement* stmt, const X86CTranslationPolicy& conv, map<SgLabelStatement*, set<SgInitializedName*> >& liveVarsForLabels, set<SgInitializedName*> currentLiveVars, bool actuallyRemove) { switch (stmt->variantT()) { case V_SgBasicBlock: { const SgStatementPtrList& stmts = isSgBasicBlock(stmt)->get_statements(); for (size_t i = stmts.size(); i > 0; --i) { currentLiveVars = computeLiveVars(stmts[i - 1], conv, liveVarsForLabels, currentLiveVars, actuallyRemove); } return currentLiveVars; } case V_SgPragmaDeclaration: return currentLiveVars; case V_SgDefaultOptionStmt: return currentLiveVars; case V_SgCaseOptionStmt: { return computeLiveVars(isSgCaseOptionStmt(stmt)->get_body(), conv, liveVarsForLabels, currentLiveVars, actuallyRemove); } case V_SgLabelStatement: { liveVarsForLabels[isSgLabelStatement(stmt)] = currentLiveVars; return currentLiveVars; } case V_SgGotoStatement: { return liveVarsForLabels[isSgGotoStatement(stmt)->get_label()]; } case V_SgSwitchStatement: { SgSwitchStatement* s = isSgSwitchStatement(stmt); SgBasicBlock* swBody = isSgBasicBlock(s->get_body()); ROSE_ASSERT (swBody); const SgStatementPtrList& bodyStmts = swBody->get_statements(); set<SgInitializedName*> liveForBody; // Assumes any statement in the body is possible for (size_t i = 0; i < bodyStmts.size(); ++i) { setUnionInplace(liveForBody, computeLiveVars(bodyStmts[i], conv, liveVarsForLabels, currentLiveVars, actuallyRemove)); } return computeLiveVars(s->get_item_selector(), conv, liveVarsForLabels, liveForBody, actuallyRemove); } case V_SgContinueStmt: { return makeAllPossibleVars(conv); } case V_SgIfStmt: { set<SgInitializedName*> liveForBranches = computeLiveVars(isSgIfStmt(stmt)->get_true_body(), conv, liveVarsForLabels, currentLiveVars, actuallyRemove); setUnionInplace(liveForBranches, (isSgIfStmt(stmt)->get_false_body() != NULL ? computeLiveVars(isSgIfStmt(stmt)->get_false_body(), conv, liveVarsForLabels, currentLiveVars, actuallyRemove) : set<SgInitializedName*>())); return computeLiveVars(isSgIfStmt(stmt)->get_conditional(), conv, liveVarsForLabels, liveForBranches, actuallyRemove); } case V_SgWhileStmt: { while (true) { set<SgInitializedName*> liveVarsSave = currentLiveVars; currentLiveVars = computeLiveVars(isSgWhileStmt(stmt)->get_body(), conv, liveVarsForLabels, currentLiveVars, false); currentLiveVars = computeLiveVars(isSgWhileStmt(stmt)->get_condition(), conv, liveVarsForLabels, currentLiveVars, false); setUnionInplace(currentLiveVars, liveVarsSave); if (liveVarsSave == currentLiveVars) break; } if (actuallyRemove) { set<SgInitializedName*> liveVarsSave = currentLiveVars; currentLiveVars = computeLiveVars(isSgWhileStmt(stmt)->get_body(), conv, liveVarsForLabels, currentLiveVars, true); currentLiveVars = computeLiveVars(isSgWhileStmt(stmt)->get_condition(), conv, liveVarsForLabels, currentLiveVars, true); setUnionInplace(currentLiveVars, liveVarsSave); } return currentLiveVars; } case V_SgBreakStmt: return set<SgInitializedName*>(); case V_SgExprStatement: { SgExpression* e = isSgExprStatement(stmt)->get_expression(); switch (e->variantT()) { case V_SgAssignOp: { SgVarRefExp* lhs = isSgVarRefExp(isSgAssignOp(e)->get_lhs_operand()); ROSE_ASSERT (lhs); SgInitializedName* in = lhs->get_symbol()->get_declaration(); if (currentLiveVars.find(in) == currentLiveVars.end()) { if (actuallyRemove) { // cerr << "Removing assignment " << e->unparseToString() << endl; isSgStatement(stmt->get_parent())->remove_statement(stmt); } return currentLiveVars; } else { currentLiveVars.erase(in); getUsedVariables(isSgAssignOp(e)->get_rhs_operand(), currentLiveVars); return currentLiveVars; } } case V_SgFunctionCallExp: { getUsedVariables(e, currentLiveVars); SgFunctionRefExp* fr = isSgFunctionRefExp(isSgFunctionCallExp(e)->get_function()); ROSE_ASSERT (fr); if (fr->get_symbol()->get_declaration() == conv.interruptSym->get_declaration()) { setUnionInplace(currentLiveVars, makeAllPossibleVars(conv)); return currentLiveVars; } else { return currentLiveVars; } } default: { getUsedVariables(e, currentLiveVars); return currentLiveVars; } } } case V_SgVariableDeclaration: { ROSE_ASSERT (isSgVariableDeclaration(stmt)->get_variables().size() == 1); SgInitializedName* in = isSgVariableDeclaration(stmt)->get_variables()[0]; bool isConst = isConstType(in->get_type()); if (currentLiveVars.find(in) == currentLiveVars.end() && isConst) { if (actuallyRemove) { // cerr << "Removing decl " << stmt->unparseToString() << endl; isSgStatement(stmt->get_parent())->remove_statement(stmt); } return currentLiveVars; } else { currentLiveVars.erase(in); if (in->get_initializer()) { getUsedVariables(in->get_initializer(), currentLiveVars); } return currentLiveVars; } } default: cerr << "computeLiveVars: " << stmt->class_name() << endl; abort(); } }
void query(Atomic &atom, set<varint_t> &allvars, Relation &results) { switch (atom.type) { case ATOM: query_atom(atom.get.atom, allvars, results); return; case MEMBERSHIP: case SUBCLASS: case EQUALITY: return; // only concerned with triples for data case EXTERNAL: cerr << "[ERROR] This should never happen, at line " << __LINE__ << endl; return; case FRAME: break; // just handle outside this messy switch default: cerr << "[ERROR] Unhandled case " << (int) atom.type << " at line " << __LINE__ << endl; return; } Relation intermediate; Term subj = atom.get.frame.object; if (subj.type == LIST) { return; // no lists (real lists, not rdf:Lists) in RDF } if (subj.type == FUNCTION) { cerr << "[ERROR] Functions are currently unsupported." << endl; return; } varint_t maxvar = 0; Tuple mintriple(3); Tuple maxtriple(3); if (subj.type == CONSTANT) { mintriple[0] = maxtriple[0] = subj.get.constant; } else { mintriple[0] = 0; maxtriple[0] = CONSTINT_MAX; maxvar = subj.get.variable; } pair<Term, Term> *slot = atom.get.frame.slots.begin; for (; slot != atom.get.frame.slots.end; ++slot) { Term pred = slot->first; Term obj = slot->second; if (pred.type == LIST || obj.type == LIST) { Relation empty; results.swap(empty); return; } if (pred.type == FUNCTION || obj.type == FUNCTION) { cerr << "[ERROR] Functions are currently unsupported." << endl; return; } set<varint_t> newvars; if (subj.type == VARIABLE) { newvars.insert(subj.get.variable); } if (pred.type == CONSTANT) { mintriple[1] = maxtriple[1] = pred.get.constant; } else { mintriple[1] = 0; maxtriple[1] = CONSTINT_MAX; maxvar = max(maxvar, pred.get.variable); newvars.insert(pred.get.variable); } if (obj.type == CONSTANT) { mintriple[2] = maxtriple[2] = obj.get.constant; } else { mintriple[2] = 0; maxtriple[2] = CONSTINT_MAX; maxvar = max(maxvar, obj.get.variable); newvars.insert(obj.get.variable); } int idx = (subj.type == CONSTANT ? 0x4 : 0x0) | (pred.type == CONSTANT ? 0x2 : 0x0) | ( obj.type == CONSTANT ? 0x1 : 0x0); Index::const_iterator begin, end; switch (idx) { case 0x0: case 0x4: case 0x6: case 0x7: // SPO begin = idxspo.lower_bound(mintriple); end = idxspo.upper_bound(maxtriple); break; case 0x2: case 0x3: // POS begin = idxpos.lower_bound(mintriple); end = idxpos.upper_bound(maxtriple); break; case 0x1: case 0x5: // OSP begin = idxosp.lower_bound(mintriple); end = idxosp.upper_bound(maxtriple); break; default: cerr << "[ERROR] Unhandled case " << hex << idx << " at line " << dec << __LINE__ << endl; return; } // TODO the following loop could probably be more efficient Relation selection; for (; begin != end; ++begin) { Tuple result(maxvar + 1); if (subj.type == VARIABLE) { result[subj.get.variable] = begin->at(0); } if (pred.type == VARIABLE) { if (subj.type == VARIABLE && subj.get.variable == pred.get.variable) { if (begin->at(0) != begin->at(1)) { continue; } } result[pred.get.variable] = begin->at(1); } if (obj.type == VARIABLE) { if (subj.type == VARIABLE && subj.get.variable == obj.get.variable) { if (begin->at(0) != begin->at(2)) { continue; } } if (pred.type == VARIABLE && pred.get.variable == obj.get.variable) { if (begin->at(1) != begin->at(2)) { continue; } } result[obj.get.variable] = begin->at(2); } selection.push_back(result); } if (slot == atom.get.frame.slots.begin) { intermediate.swap(selection); } else { vector<size_t> joinvars (allvars.size() + newvars.size()); vector<size_t>::iterator jit = set_intersection(allvars.begin(), allvars.end(), newvars.begin(), newvars.end(), joinvars.begin()); joinvars.resize(jit - joinvars.begin()); join(intermediate, selection, joinvars, intermediate); } allvars.insert(newvars.begin(), newvars.end()); } results.swap(intermediate); DEBUG("Number selected = ", results.size()); }
void query(Condition &condition, set<varint_t> &allvars, Relation &results) { deque<void*> negated; Relation intermediate; switch (condition.type) { case ATOMIC: { query(condition.get.atom, allvars, results); return; } case CONJUNCTION: { Condition *subformula = condition.get.subformulas.begin; for (; subformula != condition.get.subformulas.end; ++subformula) { if (subformula->type == NEGATION) { negated.push_back((void*)subformula->get.subformulas.begin); continue; } Relation subresult; set<varint_t> newvars; // TODO vvv this won't work right if a non-special query // has not been performed first if (special(*subformula, intermediate, subresult)) { if (subformula == condition.get.subformulas.begin) { cerr << "[ERROR] Must have non-special query at beginning of conjunction." << endl; } intermediate.swap(subresult); continue; } query(*subformula, newvars, subresult); if (subformula == condition.get.subformulas.begin) { intermediate.swap(subresult); } else { vector<size_t> joinvars(allvars.size() + newvars.size()); vector<size_t>::iterator jit = set_intersection(allvars.begin(), allvars.end(), newvars.begin(), newvars.end(), joinvars.begin()); joinvars.resize(jit - joinvars.begin()); join(intermediate, subresult, joinvars, intermediate); } allvars.insert(newvars.begin(), newvars.end()); } break; } case DISJUNCTION: { cerr << "[ERROR] Disjunction is not supported." << endl; return; } case EXISTENTIAL: { // assuming all quantified variables are uniquely named in the scope of the rule Condition *subformula = condition.get.subformulas.begin; for (; subformula != condition.get.subformulas.end; ++subformula) { if (subformula->type == NEGATION) { negated.push_back((void*)subformula->get.subformulas.begin); } Relation subresult; query(*subformula, allvars, subresult); intermediate.splice(intermediate.end(), subresult); } break; } case NEGATION: { cerr << "[ERROR] This should never happen. query should not be called directly on negated formulas." << endl; return; } default: { cerr << "[ERROR] Unhandled case " << (int)condition.type << " on line " << __LINE__ << endl; return; } } // TODO deal with negation later, if at all #if 1 deque<void*>::iterator it = negated.begin(); for (; !intermediate.empty() && it != negated.end(); ++it) { Relation negresult; Condition *cond = (Condition*) *it; if (special(*cond, intermediate, negresult)) { intermediate.sort(); negresult.sort(); Relation leftover(intermediate.size()); Relation::iterator iit = set_difference(intermediate.begin(), intermediate.end(), negresult.begin(), negresult.end(), leftover.begin()); Relation newinter; newinter.splice(newinter.end(), leftover, leftover.begin(), iit); intermediate.swap(newinter); continue; } query(*((Condition*)(*it)), allvars, negresult); minusrel(intermediate, negresult, intermediate); } #endif results.swap(intermediate); }
int SlaveManager::chooseIONode(set<int>& loclist, int mode, vector<SlaveNode>& sl, const SF_OPT& option, const int rep_dist, const vector<int>* restrict_loc) { CGuardEx sg(m_SlaveLock); timeval t; gettimeofday(&t, 0); srand(t.tv_usec); sl.clear(); if (m_mSlaveList.empty()) return SectorError::E_NODISK; if (!loclist.empty()) { SlaveNode sn; int rc = findNearestNode(loclist, option.m_strHintIP, sn); if( rc < 0 ) return rc; sl.push_back(sn); // if this is a READ_ONLY operation, one node is enough if ((mode & SF_MODE::WRITE) == 0) return sl.size(); // the first node will be the closest to the client; the client writes to that node only for (set<int>::iterator i = loclist.begin(); i != loclist.end(); i ++) { if (*i == sn.m_iNodeID) continue; if( m_mSlaveList.find( *i ) == m_mSlaveList.end() ) log().error << __PRETTY_FUNCTION__ << ": about to add new slave to list " << *i << std::endl; sl.push_back(m_mSlaveList[*i]); } } else { // no available nodes for READ_ONLY operation if ((mode & SF_MODE::WRITE) == 0) return 0; //TODO: optimize the node selection process; no need to scan all nodes set<int> avail; vector<int> path_limit; if (option.m_strCluster.c_str()[0] != '\0') Topology::parseTopo(option.m_strCluster.c_str(), path_limit); for (map<int, SlaveNode>::iterator i = m_mSlaveList.begin(); i != m_mSlaveList.end(); ++ i) { // skip bad & lost nodes if (i->second.m_iStatus != SlaveStatus::NORMAL) { continue; } // if client specifies a cluster ID, then only nodes on the cluster are chosen if (!path_limit.empty()) { int clusterId = i->second.m_viPath.back(); if( std::find( path_limit.begin(), path_limit.end(), clusterId ) == path_limit.end() ) { continue; } } // if there is location restriction on the file, check path as well if ((NULL != restrict_loc) && (!restrict_loc->empty())) { int clusterId = i->second.m_viPath.back(); if( std::find( restrict_loc->begin(), restrict_loc->end(), clusterId ) == restrict_loc->end() ) { continue; } } // only nodes with more than minimum available disk space are chosen if (i->second.m_llAvailDiskSpace > (m_llSlaveMinDiskSpace + option.m_llReservedSize)) avail.insert(i->first); } if (avail.empty()) return SectorError::E_NODISK; SlaveNode sn; findNearestNode(avail, option.m_strHintIP, sn); sl.push_back(sn); // otherwise choose more nodes for immediate replica for (int i = 0; i < option.m_iReplicaNum - 1; ++ i) { set<int> locid; for (vector<SlaveNode>::iterator j = sl.begin(); j != sl.end(); ++ j) locid.insert(j->m_iNodeID); if (choosereplicanode_(locid, sn, option.m_llReservedSize, rep_dist, restrict_loc) <= 0) break; sl.push_back(sn); } } return sl.size(); }
int SlaveManager::choosereplicanode_(set<int>& loclist, SlaveNode& sn, const int64_t& filesize, const int rep_dist, const vector<int>* restrict_loc) { // If all source nodes are busy, we should skip the replica. /* bool idle = false; for (set<int>::const_iterator i = loclist.begin(); i != loclist.end(); ++ i) { // TODO: each slave may set a capacity limit, which could be more than 2 active trasactions. if (m_mSlaveList[*i].m_iActiveTrans <= 1) { idle = true; break; } } if (!idle) return -1; */ vector< set<int> > avail; avail.resize(m_pTopology->m_uiLevel + 2); // find the topology of current replicas vector< vector<int> > locpath; set<string> usedIP; for (set<int>::iterator i = loclist.begin(); i != loclist.end(); ++ i) { map<int, SlaveNode>::iterator p = m_mSlaveList.find(*i); if (p == m_mSlaveList.end()) continue; locpath.push_back(p->second.m_viPath); usedIP.insert(p->second.m_strIP); } // TODO: this should not be calcuated each time. for (map<int, SlaveNode>::iterator i = m_mSlaveList.begin(); i != m_mSlaveList.end(); ++ i) { // skip bad&lost slaves if (i->second.m_iStatus != SlaveStatus::NORMAL) continue; // only nodes with more than minimum availale disk space are chosen if (i->second.m_llAvailDiskSpace < (m_llSlaveMinDiskSpace + filesize)) continue; // cannot replicate to a node already having the data if (loclist.find(i->first) != loclist.end()) continue; // if a location restriction is applied to the file, only limited nodes can be chosen if ((NULL != restrict_loc) && (!restrict_loc->empty())) { int clusterId = i->second.m_viPath.back(); if( std::find( restrict_loc->begin(), restrict_loc->end(), clusterId ) == restrict_loc->end() ) { continue; } } // Calculate the distance from this slave node to the current replicas // We want maximize the distance to closest node. int level = m_pTopology->min_distance(i->second.m_viPath, locpath); // if users define a replication distance, then only nodes within rep_dist can be chosen if ((rep_dist >= 0) && (level > rep_dist)) continue; // if level is 1, it is possible there is a replica on slave on same node (same IP) // we do not want to have more than 1 replica per node // this can happen is several slaves started per node, one slave per volume if ( level == 1 ) { set<string>::iterator fs = usedIP.find(i->second.m_strIP); if (fs != usedIP.end()) continue; } // level <= m_pTopology->m_uiLevel + 1. // We do not want to replicate on the same node (level == 0), even if they are different slaves. if (level > 0) avail[level].insert(i->first); } set<int>* candidate = NULL; // choose furthest node within replica distance for (int i = m_pTopology->m_uiLevel + 1; i > 0; -- i) { if (!avail[i].empty()) { candidate = &avail[i]; break; } } if (NULL == candidate) return SectorError::E_NODISK; /* int lvl = 0; log().trace << "Available slaves" << std::endl; for ( vector <set <int> >::const_iterator vi = avail.begin(); vi != avail.end(); ++vi) { log().trace << "Level " << lvl << " "; for ( set< int >::const_iterator si = vi->begin(); si != vi->end(); ++si) log().trace << *si << ","; log().trace << std::endl; lvl++; } log().trace << "Candidate slaves "; for (set<int>::const_iterator cs = candidate->begin(); cs != candidate->end(); ++ cs) log().trace << *cs << ","; log().trace << std::endl; */ /* int64_t totalFreeSpaceOnCandidates = 0; for( set<int>::iterator j = candidate->begin(); j != candidate->end(); ++j ) { totalFreeSpaceOnCandidates += m_mSlaveList[*j].m_llAvailDiskSpace; } int64_t avgFreeSpaceOnCandidates = totalFreeSpaceOnCandidates / candidate->size(); for( set<int>::iterator c = candidate->begin(); c != candidate->end(); ) if( m_mSlaveList[*c].m_llAvailDiskSpace < avgFreeSpaceOnCandidates ) { set<int>::iterator tmp = c++; candidate->erase( tmp ); } else ++c; */ std::vector<int> slavesOrderedByFreeSpace( candidate->begin(), candidate->end() ); std::sort( slavesOrderedByFreeSpace.begin(), slavesOrderedByFreeSpace.end(), SortByFreeSpace( m_mSlaveList ) ); slavesOrderedByFreeSpace.resize( slavesOrderedByFreeSpace.size() / 2 + slavesOrderedByFreeSpace.size() % 2 ); candidate->clear(); candidate->insert( slavesOrderedByFreeSpace.begin(), slavesOrderedByFreeSpace.end() ); // Choose a random node. timeval t; gettimeofday(&t, 0); srand(t.tv_usec); int r = int(candidate->size() * (double(rand()) / RAND_MAX)); set<int>::iterator n = candidate->begin(); for (int i = 0; i < r; ++ i) n ++; // If there is no other active transaction on this node, return. if( m_mSlaveList.find( *n ) == m_mSlaveList.end() ) log().error << __PRETTY_FUNCTION__ << ": (1) about to add new slave to list " << *n << std::endl; sn = m_mSlaveList[*n]; if (sn.m_iActiveTrans == 0) { // log().trace << "Choosen slave without active transactions " << sn.m_iNodeID << std::endl; return 1; } // Choose node with lowest number of active transactions. set<int>::iterator s = n; do { if (++s == candidate->end()) s = candidate->begin(); if( m_mSlaveList.find( *s ) == m_mSlaveList.end() ) log().error << __PRETTY_FUNCTION__ << ": (2) about to add new slave to list " << *s << std::endl; if (m_mSlaveList[*s].m_iActiveTrans < sn.m_iActiveTrans) { sn = m_mSlaveList[*s]; if (sn.m_iActiveTrans == 0) break; } } while (s != n); // log().trace << "Choosen slave with lowest no of active transactions " << sn.m_iNodeID << std::endl; return 1; }
// this is set union for the blob coloring algo set<int> set_union(set<int>& a, set<int>& b) { set<int> retVal = a; retVal.insert(b.begin(),b.end()); return retVal; }
set<DeviceID> EbNRadioBT2PSI::handshake(const set<DeviceID> &deviceIDs) { set<DeviceID> encountered; for(auto it = deviceIDs.begin(); it != deviceIDs.end(); it++) { EbNDeviceBT2 *device = deviceMap_.get(*it); // Only perform active confirmation once per device if(!device->isConfirmed() && (getHandshakeScheme() == ConfirmScheme::Active)) { // TODO: Make sure that there is enough time to contact the remote // device (or time out) prior to the next action LOG_D("EbNRadioBT2PSI", "Attempting to connect to device (ID %d, Address %s)", device->getID(), device->getAddress().toString().c_str()); unique_lock<mutex> discDevicesLock(discDevicesMutex_); if(discDevices_.insert(device->getAddress()).second == false) { LOG_D("EbNRadioBT2PSI", "Skipping connection, already performed during this discovery period"); break; } discDevicesLock.unlock(); int sock = hci_.connectBT2(device->getAddress(), 1, 5000); if(sock >= 0) { LOG_D("EbNRadioBT2PSI", "Connected!"); Client *psiClient = new JL10_Client(); Server *psiServer = new JL10_Server(); psiClient->SetAdaptive(); psiServer->SetAdaptive(); psiClient->Setup(1024); psiServer->Setup(1024); unique_lock<mutex> setLock(setMutex_); psiClient->LoadData(psiClientData_); psiServer->LoadData(psiServerData_); setLock.unlock(); psiClient->Initialize(1024); psiServer->Initialize(1024); LOG_D("EbNRadioBT2PSI", "PSI Server and Client initialized..."); uint32_t messageSize = 0; vector<uint8_t> message; vector<string> output; bool success = true; //Exchanging and computing the shared secret if(success && (success = hci_.send(sock, dhExchange_.getPublic(), dhExchange_.getPublicSize(), 30000))) { vector<uint8_t> remotePublic(dhExchange_.getPublicSize()); if(success && (success = hci_.recv(sock, remotePublic.data(), dhExchange_.getPublicSize(), 30000))) { SharedSecret sharedSecret(SharedSecret::ConfirmScheme::Active); if(dhExchange_.computeSharedSecret(sharedSecret, remotePublic.data())) { LOG_E("EbNRadioBT2PSI", "Computed shared secret!"); device->addSharedSecret(sharedSecret); } else { LOG_E("EbNRadioBT2PSI", "Could not compute shared secret"); } } } //Act as client first if(success && (success = hci_.recv(sock, (uint8_t *)&messageSize, 4, 30000))) { LOG_D("EbNRadioBT2PSI", "HC1 - Incoming message of size %u", messageSize); message.resize(messageSize); if(success && (success = hci_.recv(sock, message.data(), messageSize, 30000))) { vector<string> publishedData = parsePSIMessage(message); psiClient->StoreData(publishedData); output.clear(); (psiClient->*(psiClient->m_vecRequest[0]))(output); constructPSIMessage(message, output); LOG_D("EbNRadioBT2PSI", "HC1 - Sending message of size %zu", message.size()); success = hci_.send(sock, message.data(), message.size(), 30000); } } if(success && (success = hci_.recv(sock, (uint8_t *)&messageSize, 4, 30000))) { LOG_D("EbNRadioBT2PSI", "HC2 - Incoming message of size %u", messageSize); message.resize(messageSize); if(success && (success = hci_.recv(sock, message.data(), messageSize, 30000))) { vector<string> input = parsePSIMessage(message); (psiClient->*(psiClient->m_vecOnResponse[0]))(input); LOG_D("EbNRadioBT2PSI", "HC2 - Result (Size = %zu)", psiClient->m_vecResult.size()); } } //Act as server second if(success) { output.clear(); psiServer->PublishData(output); constructPSIMessage(message, output); LOG_D("EbNRadioBT2PSI", "HS1 - Sending message of size %zu", message.size()); success = hci_.send(sock, message.data(), message.size(), 30000); } if(success && (success = hci_.recv(sock, (uint8_t *)&messageSize, 4, 30000))) { LOG_D("EbNRadioBT2PSI", "HS2 - Incoming message of size %u", messageSize); message.resize(messageSize); if(success && (success = hci_.recv(sock, message.data(), messageSize, 30000))) { vector<string> input = parsePSIMessage(message); (psiServer->*(psiServer->m_vecOnRequest[0]))(input); output.clear(); (psiServer->*(psiServer->m_vecResponse[0]))(output); constructPSIMessage(message, output); LOG_D("EbNRadioBT2PSI", "HS2 - Sending message of size %zu", message.size()); success = hci_.send(sock, message.data(), message.size(), 30000); } } // TODO: Process the result to update matching set delete psiClient; delete psiServer; LOG_D("EbNRadioBT2PSI", "Waiting for remote client to close connection..."); hci_.waitClose(sock, 30000); LOG_D("EbNRadioBT2PSI", "Done!"); close(sock); } } device->setShakenHands(true); } // Going through all devices to report 'encountered' devices, meaning // the devices we have shaken hands with and confirmed for(auto it = deviceMap_.begin(); it != deviceMap_.end(); it++) { EbNDevice *device = it->second; if(device->hasShakenHands() && device->isConfirmed()) { encountered.insert(device->getID()); } } return encountered; }
void SimpleSnpCallPileupVisitor::Visit(const PileupPosition &pileupData) { if (pileupData.Position<m_chrLeftPos || pileupData.Position>=m_chrRightPos) return; if (m_snpPositions->find(pileupData.Position)==m_snpPositions->end()) return; // random dicer unsigned UniformSeed = chrono::system_clock::now().time_since_epoch().count(); mt19937_64 UniformGenerator(UniformSeed); uniform_int_distribution<int> UniformDist; UniformDist = uniform_int_distribution<int>(0, pileupData.PileupAlignments.size()); auto UniformDicer = bind(UniformDist, UniformGenerator); // reference base char refBase = m_fasta->at(pileupData.Position-m_chrLeftPos); if (refBase=='N') return; // information buffer int globalDepth = 0; double globalMapAvgQual = 0; int globalStrandPos = 0; int globalStrandNeg = 0; list<tuple<char,int,int,double>> bamData; set<char> alleleBases; map<char, int> alleleDepth; map<char, double> alleleMapAvgQual; map<char, int> alleleStrandPos; map<char, int> alleleStrandNeg; // iterate through alignments for (int i=0; i<pileupData.PileupAlignments.size(); i++) { char readBase; BamAlignment al = pileupData.PileupAlignments[i].Alignment; // update global info globalDepth += 1; globalMapAvgQual += al.MapQuality*al.MapQuality; if (al.IsReverseStrand()) globalStrandNeg += 1; else globalStrandPos += 1; // downsampling if (UniformDicer()>m_downSample) continue; // data info int nx = GenericBamAlignmentTools::numBamAlignmentMismatches(al); int nm = GenericBamAlignmentTools::numBamAlignmentMatches(al); double nr = nm/(nm+nx+0.); if (pileupData.PileupAlignments[i].IsCurrentDeletion) { bamData.push_back(tuple<char,int,int,double>('-',0,al.MapQuality,1.)); }else { readBase = al.QueryBases.at(pileupData.PileupAlignments[i].PositionInAlignment); int baseQuality = int(al.Qualities.at(pileupData.PileupAlignments[i].PositionInAlignment))-33; // debug if (baseQuality<0) { cout << int(al.Qualities.at(pileupData.PileupAlignments[i].PositionInAlignment)) << endl; } if (readBase==refBase || readBase=='N') { bamData.push_back(tuple<char,int,int,double>(readBase, baseQuality, al.MapQuality,1.)); } else { bamData.push_back(tuple<char,int,int,double>(readBase, baseQuality, al.MapQuality,nr)); } } // here is deletion if (pileupData.PileupAlignments[i].IsCurrentDeletion) continue; // update allele info if (readBase!='N' && readBase!=refBase) { if (pileupData.PileupAlignments[i].IsSegmentBegin || pileupData.PileupAlignments[i].IsSegmentEnd) continue; if (alleleBases.find(readBase)==alleleBases.end()) { alleleDepth[readBase] = 1; alleleMapAvgQual[readBase] = al.MapQuality*al.MapQuality; if (al.IsReverseStrand()) { alleleStrandPos[readBase] = 0; alleleStrandNeg[readBase] = 1; } else { alleleStrandPos[readBase] = 1; alleleStrandNeg[readBase] = 0; } alleleBases.insert(readBase); }else { alleleDepth[readBase] += 1; alleleMapAvgQual[readBase] += al.MapQuality*al.MapQuality; if (al.IsReverseStrand()) alleleStrandNeg[readBase] += 1; else alleleStrandPos[readBase] += 1; } } } // save allele info for (set<char>::iterator iter=alleleBases.begin(); iter!=alleleBases.end(); iter++) { Allele allele; allele.m_chrID = pileupData.RefId; allele.m_chrPosition = pileupData.Position; allele.m_allele = *iter; allele.m_reference = refBase; allele.m_alleleDepth = alleleDepth[*iter]; allele.m_alleleMapAvgQual = sqrt(alleleMapAvgQual[*iter])/allele.m_alleleDepth; allele.m_alleleStrandPos = alleleStrandPos[*iter]; allele.m_alleleStrandNeg = alleleStrandNeg[*iter]; // global info allele.m_globalDepth = globalDepth; allele.m_globalMapAvgQual = sqrt(globalMapAvgQual)/globalDepth; allele.m_globalStrandPos = globalStrandPos; allele.m_globalStrandNeg = globalStrandNeg; m_snpAlleles->push_back(allele); } (*m_bamData)[pileupData.Position] = bamData; }
int main() { inp(t); while(t--) { inp(k); inp(q); for(int a=0;a<k;a++) inp(A[a]); for(int a=0;a<k;a++) inp(B[a]); sort(A,A+k); sort(B,B+k); s.clear(); s1.clear(); lli ind=1; big=min((lli)10000,k*k); lli i=0,j=0,kri=0,a1,b1; for(int a=0;a<k;a++) { s.insert(mp(A[0]+B[a],ii(0,a))); s.insert(mp(A[a]+B[0],ii(a,0))); } // cout<<s.size()<<endl; a1=k; b1=k; set<pair<lli,ii> >::iterator it; while(ind<=big) { it=s.begin(); ans[ind++]=it->first; s1.insert(it->second); // cout<<ind-1<<" "<<ans[ind-1]<<endl; // cout<<big<<endl; if((it->second).first==i) { a1--; // i++; if(a1==0 && (i+1)<k) { i++; // while(i<k) { for(int a=0;a<k;a++) { if(s1.find(ii(i,a))!=s1.end()) continue; a1++; s.insert(mp(A[i]+B[a],ii(i,a))); } // if(a1) // break; // i++; } } if((it->second).second==j) { b1--; if(b1==0 && (j+1)<k) { j++; for(int a=0;a<k;a++) { if(s1.find(ii(a,j))!=s1.end()) continue; b1++; s.insert(mp(A[a]+B[j],ii(a,j))); } } } s.erase(s.begin()); } while(q--) { inp(num); // if(num>big) // printf("0\n"); printf("%lld\n", ans[num]); } } return 0; }
bool GetKeyState(int key) { int vk = 0; if(key >= eRENDERDOC_Key_A && key <= eRENDERDOC_Key_Z) vk = key; if(key >= eRENDERDOC_Key_0 && key <= eRENDERDOC_Key_9) vk = key; switch(key) { case eRENDERDOC_Key_Divide: vk = VK_DIVIDE; break; case eRENDERDOC_Key_Multiply: vk = VK_MULTIPLY; break; case eRENDERDOC_Key_Subtract: vk = VK_SUBTRACT; break; case eRENDERDOC_Key_Plus: vk = VK_ADD; break; case eRENDERDOC_Key_F1: vk = VK_F1; break; case eRENDERDOC_Key_F2: vk = VK_F2; break; case eRENDERDOC_Key_F3: vk = VK_F3; break; case eRENDERDOC_Key_F4: vk = VK_F4; break; case eRENDERDOC_Key_F5: vk = VK_F5; break; case eRENDERDOC_Key_F6: vk = VK_F6; break; case eRENDERDOC_Key_F7: vk = VK_F7; break; case eRENDERDOC_Key_F8: vk = VK_F8; break; case eRENDERDOC_Key_F9: vk = VK_F9; break; case eRENDERDOC_Key_F10: vk = VK_F10; break; case eRENDERDOC_Key_F11: vk = VK_F11; break; case eRENDERDOC_Key_F12: vk = VK_F12; break; case eRENDERDOC_Key_Home: vk = VK_HOME; break; case eRENDERDOC_Key_End: vk = VK_END; break; case eRENDERDOC_Key_Insert: vk = VK_INSERT; break; case eRENDERDOC_Key_Delete: vk = VK_DELETE; break; case eRENDERDOC_Key_PageUp: vk = VK_PRIOR; break; case eRENDERDOC_Key_PageDn: vk = VK_NEXT; break; case eRENDERDOC_Key_Backspace: vk = VK_BACK; break; case eRENDERDOC_Key_Tab: vk = VK_TAB; break; case eRENDERDOC_Key_PrtScrn: vk = VK_SNAPSHOT; break; case eRENDERDOC_Key_Pause: vk = VK_PAUSE; break; default: break; } if(vk == 0) return false; bool keydown = GetAsyncKeyState(vk) != 0; if(inputWindows.empty() || !keydown) return keydown; for(auto it = inputWindows.begin(); it != inputWindows.end(); ++it) { HWND w = *it; HWND fore = GetForegroundWindow(); while(w) { if(w == fore) return keydown; w = GetParent(w); } } return false; }
void drillDown( boost::filesystem::path root, bool use_db, bool use_coll, bool top_level=false ) { log(2) << "drillDown: " << root.string() << endl; // skip hidden files and directories if (root.leaf()[0] == '.' && root.leaf() != ".") return; if ( is_directory( root ) ) { boost::filesystem::directory_iterator end; boost::filesystem::directory_iterator i(root); boost::filesystem::path indexes; while ( i != end ) { boost::filesystem::path p = *i; i++; if (use_db) { if (boost::filesystem::is_directory(p)) { error() << "ERROR: root directory must be a dump of a single database" << endl; error() << " when specifying a db name with --db" << endl; printHelp(cout); return; } } if (use_coll) { if (boost::filesystem::is_directory(p) || i != end) { error() << "ERROR: root directory must be a dump of a single collection" << endl; error() << " when specifying a collection name with --collection" << endl; printHelp(cout); return; } } // don't insert oplog if (top_level && !use_db && p.leaf() == "oplog.bson") continue; if ( p.leaf() == "system.indexes.bson" ) { indexes = p; } else if (_restoreShardingConfig && is_directory(p) && p.leaf() == "config") { // Config directory should have already been restored. Skip it here. continue; } else { drillDown(p, use_db, use_coll); } } if (!indexes.empty()) drillDown(indexes, use_db, use_coll); return; } if ( endsWith( root.string().c_str() , ".metadata.json" ) ) { // Metadata files are handled when the corresponding .bson file is handled return; } if ( ! ( endsWith( root.string().c_str() , ".bson" ) || endsWith( root.string().c_str() , ".bin" ) ) ) { error() << "don't know what to do with file [" << root.string() << "]" << endl; return; } log() << root.string() << endl; if ( root.leaf() == "system.profile.bson" ) { log() << "\t skipping" << endl; return; } string ns; if (use_db) { ns += _db; } else { string dir = root.branch_path().string(); if ( dir.find( "/" ) == string::npos ) ns += dir; else ns += dir.substr( dir.find_last_of( "/" ) + 1 ); if ( ns.size() == 0 ) ns = "test"; } verify( ns.size() ); string oldCollName = root.leaf(); // Name of the collection that was dumped from oldCollName = oldCollName.substr( 0 , oldCollName.find_last_of( "." ) ); if (use_coll) { ns += "." + _coll; } else { ns += "." + oldCollName; } log() << "\tgoing into namespace [" << ns << "]" << endl; if ( _drop ) { if (root.leaf() != "system.users.bson" ) { log() << "\t dropping" << endl; conn().dropCollection( ns ); } else { // Create map of the users currently in the DB BSONObj fields = BSON("user" << 1); scoped_ptr<DBClientCursor> cursor(conn().query(ns, Query(), 0, 0, &fields)); while (cursor->more()) { BSONObj user = cursor->next(); _users.insert(user["user"].String()); } } } BSONObj metadataObject; if (_restoreOptions || _restoreIndexes) { boost::filesystem::path metadataFile = (root.branch_path() / (oldCollName + ".metadata.json")); if (!boost::filesystem::exists(metadataFile.string())) { // This is fine because dumps from before 2.1 won't have a metadata file, just print a warning. // System collections shouldn't have metadata so don't warn if that file is missing. if (!startsWith(metadataFile.leaf(), "system.")) { log() << metadataFile.string() << " not found. Skipping." << endl; } } else { metadataObject = parseMetadataFile(metadataFile.string()); } } _curns = ns.c_str(); _curdb = NamespaceString(_curns).db; _curcoll = NamespaceString(_curns).coll; if (_restoreOptions && metadataObject.hasField("options")) { // Try to create collection with given options createCollectionWithOptions(metadataObject["options"].Obj()); } processFile( root ); if (_drop && root.leaf() == "system.users.bson") { // Delete any users that used to exist but weren't in the dump file for (set<string>::iterator it = _users.begin(); it != _users.end(); ++it) { BSONObj userMatch = BSON("user" << *it); conn().remove(ns, Query(userMatch)); } _users.clear(); } if (_restoreIndexes && metadataObject.hasField("indexes")) { vector<BSONElement> indexes = metadataObject["indexes"].Array(); for (vector<BSONElement>::iterator it = indexes.begin(); it != indexes.end(); ++it) { createIndex((*it).Obj(), false); } } }
void Editor::formatStreamLine(){ string out; char cf='0'; for( int k=0;k<is_line.size(); ){ int from=k; char pf=cf; int c=is_line[k],is_sz=is_line.size(); if( !isgraph( c ) ){ for( ++k;k<is_sz && !isgraph(is_line[k]);++k ){} }else if( !isfmt( c,k+1<is_sz?is_line[k+1]:0 ) ){ for( ++k;k<is_sz && !isfmt( is_line[k],k+1<is_sz?is_line[k+1]:0 );++k ){} cf='6'; }else if( c==';' ){ //comment? k=is_sz; cf='4'; }else if( c=='\"' ){ //string const? for( ++k;k<is_sz && is_line[k]!='\"';++k ){} if( k<is_sz ) ++k; cf='1'; }else if( isalpha( c ) ){ //ident? for( ++k;k<is_sz && isid(is_line[k]);++k ){} if( keyWordSet.find( is_line.substr( from,k-from ) )==keyWordSet.end() ) cf='2'; else cf='3'; }else if( c=='$' ){ for( ++k;k<is_sz && isxdigit(is_line[k]);++k ){} cf='5'; }else if( isdigit( c ) ){ //numeric const? for( ++k;k<is_sz && isdigit(is_line[k]);++k ){} cf='5'; } if( cf!=pf ){ out+="\\cf";out+=cf;out+=' '; } out+=is_line.substr( from,k-from ); } if( is_line[0]=='F' && is_line.find( "Function" )==0 ){ for( int k=8;k<is_line.size();++k ){ if( isalpha( is_line[k] ) ){ int start=k; for( ++k;k<is_line.size() && isid(is_line[k]);++k ){} funcList.insert( is_linenum,is_line.substr( start,k-start ) ); break; } } }else if( is_line[0]=='T' && is_line.find( "Type" )==0 ){ for( int k=4;k<is_line.size();++k ){ if( isalpha( is_line[k] ) ){ int start=k; for( ++k;k<is_line.size() && isid(is_line[k]);++k ){} typeList.insert( is_linenum,is_line.substr( start,k-start ) ); break; } } }else if( is_line[0]=='.' ){ for( int k=1;k<is_line.size();++k ){ if( isalpha( is_line[k] ) ){ int start=k; for( ++k;k<is_line.size() && isid(is_line[k]);++k ){} labsList.insert( is_linenum,is_line.substr( start,k-start ) ); break; } } } is_line=out+"\\line "; }
set<int> myunion(const set<int>& s1, const set<int>& s2) { set<int> u; set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(u, u.begin())); return u; }
int main() { const bool debug = false; int i, j, k; P bg, nd, t; while(~scanf("%d%d%d%d", &x1, &y1, &x2, &y2)) { if(x1 == 0 && x2 == 0 && y1 == 0 && y2 == 0)break; scanf("%d", &n); x.clear();x.insert(x1);x.insert(x2); y.clear();y.insert(y1);y.insert(y2); for(i = 0; i < n; i++) { b[i].init(); x.insert(b[i].x1); x.insert(b[i].x2); y.insert(b[i].y1); y.insert(b[i].y2); } hx.clear(); hy.clear(); //把地图扩大二倍后,矩阵内部就可以被填充,矩阵边界就可以走了 //对x离散化 for(si = x.begin(), mx = 1; si != x.end(); hx[*si++] = mx, mx+=2) ; //对y离散化 for(si = y.begin(), my = 1; si != y.end(); hy[*si++] = my, my+=2); //初始化 for(j = 0; j < 4; ++j){ for(i = 0; i < mx; ++i){ fill(v[j][i], v[j][i] + my, false); fill(s[j][i], s[j][i] + my, inf); } } for(i = 0; i < mx; ++i){ fill(m[i], m[i] + my, 0); } //填充矩阵,填充为1 for(i = 0; i < n; i++) { int xuper = hx[b[i].x2]; int yuper = hy[b[i].y2]; //填充上下边界 for(j = hx[b[i].x1]; j <= xuper; j++){ m[j][hy[b[i].y1]]=m[j][hy[b[i].y2]]=1; } //填充左右边界 for(k = hy[b[i].y1]; k <= yuper; k++){ m[hx[b[i].x1]][k]=m[hx[b[i].x2]][k]=1; } //填充矩阵内部 for(j = hx[b[i].x1] + 1; j < xuper; j++) { for(k = hy[b[i].y1] + 1; k < yuper; k++) { m[j][k]=2; } } } //此路不同,标记为2 for(i=1;i<mx-1;i++){ for(j=1;j<my-1;j++){ if(m[i-1][j]&&m[i][j-1]&&m[i+1][j]&&m[i][j+1]) m[i][j]=2; } } if(debug) { puts("---- stp ----"); for(i = 0; i < mx; i++) { for(j = 0; j < my; j++) { printf(" %2d",m[i][j]); } puts(""); } puts("---- stp ----\n\n"); } while(!que.empty())que.pop(); nd.x = hx[x2]; nd.y = hy[y2]; bg.x = hx[x1]; bg.y = hy[y1]; bg.stp = 0; //分别标记出发点的四个方向,并入队 for(i = 0; i < 4; i++) { bg.d = i; v[i][bg.x][bg.y] = true; s[i][bg.x][bg.y] = 0; que.push(bg); } int ndnum=0; while(!que.empty()) { bg = que.top();que.pop(); //由于是优先搜索,所以只要到达就一定是最优的 if(bg.x == nd.x && bg.y == nd.y){ break; } for(i = 0; i < 4; i++) { //回头,不会有更优的答案 if((i+2)%4 == bg.d)continue; t.x = bg.x + pos[i][0]; t.y = bg.y + pos[i][1]; //越界 if(t.x < 0 || t.y < 0 || t.x >= mx || t.y >= my)continue; //此路不通 if(m[t.x][t.y] >1)continue; //更新步数 t.stp = s[bg.d][bg.x][bg.y] + (i == bg.d?0:1); //此地点已经达到过,且更优 if(v[i][t.x][t.y] && t.stp >= s[i][t.x][t.y])continue; //此路可以更新 s[i][t.x][t.y] = t.stp; v[i][t.x][t.y] = true; t.d = i; que.push(t); } } int ans = inf; for(i = 0; i < 4; i++) { if(ans > s[i][nd.x][nd.y]) ans = s[i][nd.x][nd.y]; } printf("%d\n", ans==inf?-1:ans); if(debug) { puts("---- stp ----"); for(i = 0; i < mx; i++) { for(j = 0; j < my; j++) { if(m[i][j]){ printf(" %2d",-m[i][j]); }else{ int tmp=inf; for(int kk=0;kk<4;kk++){ if(tmp>s[kk][i][j]){ tmp=s[kk][i][j]; } } if(tmp==inf)tmp=-3; printf(" %2d",tmp); } } puts(""); } puts("---- stp ----\n\n"); } } return 0; }
LabelUpdateThread::LabelUpdateThread(const set<string> &labelsToDelete, const map<string, string> &labelsToRename) { copy(labelsToDelete.begin(), labelsToDelete.end(), inserter(m_labelsToDelete, m_labelsToDelete.begin())); copy(labelsToRename.begin(), labelsToRename.end(), inserter(m_labelsToRename, m_labelsToRename.begin())); }
void work() { for (int i = 0; i < 40005; i++) { f[i] = i; } for (int i = 0; i < 40005; i++) { g[i].clear(); } cb.clear(); ans.clear(); dd.clear(); i1.clear(); qu.clear(); int n, m, q, u, v, a, b, c; scanf("%d %d %d", &n, &m, &q); for (int i = 0; i < m; i++) { scanf("%d %d", &u, &v); if (u > v) swap(u, v); i1.push_back(make_pair(u, v)); } for (int i = 0; i < q; i++) { scanf("%d %d %d", &a, &b, &c); if (a == 1) { if (b > c) swap(b, c); dd[make_pair(b, c)]++; } qu.push_back(make_tuple(a, b, c)); } for (int i = 0; i < m; i++) { if (dd[i1[i]] == 0) { if (cb.find(i1[i]) == cb.end()) { if (i1[i].first == i1[i].second) continue; cb.insert(i1[i]); g[i1[i].first].push_back(i1[i].second); g[i1[i].second].push_back(i1[i].first); } else { uni(i1[i].first, i1[i].second); } } else { dd[i1[i]]--; } } memset(vis, 0, sizeof(vis)); dfs(1, -1, 0); slpf::init(n); for (int i = q-1 ; i >= 0; i--) { int a = get<0>(qu[i]), b = get<1>(qu[i]), c = get<2>(qu[i]); if (a == 1) { if (getf(b) == getf(c)) continue; slpf::modify(getf(b), getf(c)); } else { if (getf(b) == getf(c)) { ans.push_back(0); } else { ans.push_back(slpf::query(getf(b), getf(c))); } } } int s = ans.size(); for (int i = s-1; i >= 0; i--) { printf("%d\n", ans[i]); } }
//-------------------------------------- bool ofGetMousePressed(int button){ //by default any button if(button==-1) return pressedMouseButtons.size(); return pressedMouseButtons.find(button)!=pressedMouseButtons.end(); }
set<int>::iterator next(set<int>::iterator it, set<int> &S) { return it == S.end() ? it : ++it; }
int main() { int n; scanf("%d", &n); for (int i = 0; i < n; ++i) scanf("%lld", a+i); long long sum1 = 0, ma1 = -1e18, sum2 = 0, ma2 = -1e18; for (int i = 0; i < n; ++i) { if (i & 1) { if (a[i] > 0) sum1 += a[i]; ma1 = max(ma1, a[i]); } else { if (a[i] > 0) sum2 += a[i]; ma2 = max(ma2, a[i]); } } fill(live, live+n, 1); if (ma1 < 0) sum1 = ma1; if (ma2 < 0) sum2 = ma2; if (sum1 > sum2) { if (ma1 < 0) { for (int i = 0; i < n; ++i) if (a[i] == ma1) { used[i] = 1; break; } } else { for (int i = 1; i < n; i += 2) if (a[i] >= 0) used[i] = 1; } } else { if (ma2 < 0) { for (int i = 0; i < n; ++i) if (a[i] == ma2) { used[i] = 1; break; } } else { for (int i = 0; i < n; i += 2) if (a[i] >= 0) used[i] = 1; } } long long ans = 0; for (int i = 0; i < n; ++i) if (used[i]) ans += a[i]; for (int i = 0; i < n; ++i) { upd(i, 1); st.insert(i); } printf("%lld\n", ans); vector<int> op; while (st.size() > 1) { for (auto it = st.begin(); it != st.end(); ++it) { if (used[*it]) continue; auto nx = it; ++nx; bool del = 0; if (it == st.begin() || nx == st.end()) { del = 1; } else { auto pr = it; --pr; if (used[*pr] == used[*nx]) del = 1; } if (del) { op.push_back(get(*it)); if (nx != st.end()) { used[*it] = used[*nx]; rem(*nx); } if (it != st.begin()) { auto pr = it; --pr; used[*it] = used[*pr]; rem(*pr); } break; } } } printf("%d\n", op.size()); for (int x : op) printf("%d\n", x); return 0; }
Query ConfigDiffTracker<ValType,ShardType>:: configDiffQuery( const set<ChunkVersion>& extraMinorVersions ) const { verifyAttached(); // // Basic idea behind the query is to find all the chunks $gt the current max version, and // then also update chunks that we need minor versions - splits and (2.0) max chunks on // shards // static const int maxMinorVersionClauses = 50; BSONObjBuilder queryB; int numStaleMinorClauses = extraMinorVersions.size() + _maxShardVersions->size(); #ifdef _DEBUG // In debug builds, randomly trigger full reloads to exercise both codepaths if( rand() % 2 ) numStaleMinorClauses = maxMinorVersionClauses; #endif queryB.append(ChunkType::ns(), _ns); // // If we have only a few minor versions to refresh, we can be more selective in our query // if( numStaleMinorClauses < maxMinorVersionClauses ){ // // Get any version changes higher than we know currently // BSONArrayBuilder queryOrB( queryB.subarrayStart( "$or" ) ); { BSONObjBuilder queryNewB( queryOrB.subobjStart() ); { BSONObjBuilder ts(queryNewB.subobjStart(ChunkType::DEPRECATED_lastmod())); // We should *always* pull at least a single chunk back, this lets us quickly // detect if our collection was unsharded (and most of the time if it was // resharded) in the meantime ts.appendTimestamp( "$gte", _maxVersion->toLong() ); ts.done(); } queryNewB.done(); } // Get any shard version changes higher than we know currently // Needed since there could have been a split of the max version chunk of any shard // TODO: Ideally, we shouldn't care about these for( typename map<ShardType, ChunkVersion>::const_iterator it = _maxShardVersions->begin(); it != _maxShardVersions->end(); it++ ){ BSONObjBuilder queryShardB( queryOrB.subobjStart() ); queryShardB.append(ChunkType::shard(), nameFrom( it->first ) ); { BSONObjBuilder ts(queryShardB.subobjStart(ChunkType::DEPRECATED_lastmod())); ts.appendTimestamp( "$gt", it->second.toLong() ); ts.done(); } queryShardB.done(); } // Get any minor version changes we've marked as interesting // TODO: Ideally we shouldn't care about these for( set<ChunkVersion>::const_iterator it = extraMinorVersions.begin(); it != extraMinorVersions.end(); it++ ){ BSONObjBuilder queryShardB( queryOrB.subobjStart() ); { BSONObjBuilder ts(queryShardB.subobjStart(ChunkType::DEPRECATED_lastmod())); ts.appendTimestamp( "$gt", it->toLong() ); ts.appendTimestamp( "$lt", ChunkVersion( it->majorVersion() + 1, 0, OID() ).toLong() ); ts.done(); } queryShardB.done(); } queryOrB.done(); } BSONObj query = queryB.obj(); LOG(2) << "major version query from " << *_maxVersion << " and over " << _maxShardVersions->size() << " shards is " << query << endl; // // NOTE: IT IS IMPORTANT FOR CONSISTENCY THAT WE SORT BY ASC VERSION, TO HANDLE // CURSOR YIELDING BETWEEN CHUNKS BEING MIGRATED. // // This ensures that changes to chunk version (which will always be higher) will always // come *after* our current position in the chunk cursor. // Query queryObj(query); queryObj.sort(BSON( "lastmod" << 1 )); return Query( query ); }
Endpoint EndpointPool::getCandidate(const set<unsigned int>& not_in, int64_t start_time) { // // Choose an address to connect to based on most recently seen // Endpoint candidate; int64_t now = GetAdjustedTime(); vector<Endpoint> endpoints = queryColRow<Endpoint(unsigned int, unsigned short, unsigned int, unsigned int)>("SELECT ip, port, time, lasttry FROM Endpoints WHERE lasttry < ? ORDER BY time DESC", now-60*60); // iterate until we get an address not in not_in or in the same class-B network: for (vector<Endpoint>::const_iterator e = endpoints.begin(); e != endpoints.end(); ++e) { bool skip = false; for (set<unsigned int>::const_iterator ep = not_in.begin(); ep != not_in.end(); ++ep) { if (e->getIP() == (*ep)) { skip = true; break; } } if (skip) continue; Endpoint candidate = *e; if (!candidate.isIPv4() || !candidate.isValid()) continue; return candidate; } return Endpoint(); /* BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, Endpoint)& item, _endpoints) { const Endpoint& ep = item.second; if (!ep.isIPv4() || !ep.isValid() || not_in.count(ep.getIP() & 0x0000ffff)) continue; int64_t sinceLastSeen = GetAdjustedTime() - ep.getTime(); int64_t sinceLastTry = GetAdjustedTime() - ep.getLastTry(); // Randomize the order in a deterministic way, putting the standard port first int64_t randomizer = (uint64_t)(start_time * 4951 + ep.getLastTry() * 9567851 + ep.getIP() * 7789) % (2 * 60 * 60); if (ep.getPort() != htons(_defaultPort)) randomizer += 2 * 60 * 60; // Last seen Base retry frequency // <1 hour 10 min // 1 hour 1 hour // 4 hours 2 hours // 24 hours 5 hours // 48 hours 7 hours // 7 days 13 hours // 30 days 27 hours // 90 days 46 hours // 365 days 93 hours int64_t delay = (int64_t)(3600.0 * sqrt(fabs((double)sinceLastSeen) / 3600.0) + randomizer); // Fast reconnect for one hour after last seen if (sinceLastSeen < 60 * 60) delay = 10 * 60; // Limit retry frequency if (sinceLastTry < delay) continue; // If we have IRC, we'll be notified when they first come online, // and again every 24 hours by the refresh broadcast. // if (vNodes.size() >= 2 && sinceLastSeen > 24 * 60 * 60) // continue; // Only try the old stuff if we don't have enough connections //if (vNodes.size() >= 8 && sinceLastSeen > 24 * 60 * 60) // continue; if (start_time > 0 && sinceLastSeen > 24 * 60 * 60) continue; // If multiple addresses are ready, prioritize by time since // last seen and time since last tried. int64_t score = min(sinceLastTry, (int64_t)24 * 60 * 60) - sinceLastSeen - randomizer; if (score > best) { best = score; candidate = ep; } } return candidate; */ }
int main() { const bool debug = false; int i, j, k,cs=1; while(scanf("%d", &n),n) { x.clear();y.clear(); for(i = 0; i < n; i++) { b[i].init(); x.insert(b[i].x1); x.insert(b[i].x2); y.insert(b[i].y1); y.insert(b[i].y2); } hx.clear(); hy.clear(); //把地图扩大二倍后,矩阵内部就可以被填充,矩阵边界就可以走了 //对x离散化 for(si = x.begin(), mx = 2; si != x.end(); hx[*si] = mx, hhx[mx] = *si, si++,mx+=2) ; //对y离散化 for(si = y.begin(), my = 2; si != y.end(); hy[*si] = my, hhy[my] = *si, si++,my+=2); for(i = 0; i < mx; ++i){ fill(m[i], m[i] + my, 0); } //填充矩阵,填充为1 for(i = 0; i < n; i++) { int xuper = hx[b[i].x2]; int yuper = hy[b[i].y2]; //填充上下边界 for(j = hx[b[i].x1]; j <= xuper; j++){ if(m[j][hy[b[i].y1]]==0)m[j][hy[b[i].y1]]=1; if(m[j][hy[b[i].y2]]==0)m[j][hy[b[i].y2]]=1; } //填充左右边界 for(k = hy[b[i].y1]; k <= yuper; k++){ if(m[hx[b[i].x1]][k]==0)m[hx[b[i].x1]][k]=1; if(m[hx[b[i].x2]][k]==0)m[hx[b[i].x2]][k]=1; } //填充矩阵内部 for(j = hx[b[i].x1] + 1; j < xuper; j++) { for(k = hy[b[i].y1] + 1; k < yuper; k++) { m[j][k]=2; } } } if(debug) { puts("---- stp ----"); for(i = 0; i < mx; i++) { for(j = 0; j < my; j++) { printf(" %2d",m[i][j]); } puts(""); } puts("---- stp ----\n\n"); } double ans = 0; for(i=3;i<mx;i+=2){ for(j=3;j<my;j+=2){ if(m[i][j]==2){ ans += get(i,j); } } } printf("Test case #%d\nTotal explored area: 180.00 %.2f\n",cs++,ans); } return 0; }