int main()
{
//ifstream f("file.in");
//ofstream g("file.out");
ifstream f("lupu.in");
ofstream g("lupu.out");
f >> n >> x >> l;
for (i = 1; i <= n; i++)
{
f >> dist >> lana;
if (dist <= x)
{
dist = (x - dist) / l + 1;
oi.insert(make_pair(dist, lana));
}
}
it = oi.begin();
dist = it->first;
while (dist)
{
while (it != oi.end() && dist == it->first)
{
prque.push(it->second);
it++;
}
if (!prque.empty())
{
rez += (long long)prque.top();
prque.pop();
}
dist--;
}
g << rez;
return 0;
}
void SV_SectorList_f( void )
{
areaParms_t ap;
// ap.mins = mins;
// ap.maxs = maxs;
// ap.list = list;
// ap.count = 0;
// ap.maxcount = maxcount;
entStats.clear();
SV_AreaEntitiesTree(sv_worldSectors,&ap,0);
char mess[1000];
multimap<int,pair<int,list<CBBox> > >::iterator j;
for(j=entStats.begin();j!=entStats.end();j++)
{
sprintf(mess,"**************************************************\n");
Sleep(5);
OutputDebugString(mess);
sprintf(mess,"level=%i, count=%i\n",(*j).first,(*j).second.first);
Sleep(5);
OutputDebugString(mess);
list<CBBox>::iterator k;
for(k=(*j).second.second.begin();k!=(*j).second.second.end();k++)
{
sprintf(mess,"mins=%f %f %f, maxs=%f %f %f\n",
(*k).mMins[0],(*k).mMins[1],(*k).mMins[2],(*k).mMaxs[0],(*k).mMaxs[1],(*k).mMaxs[2]);
OutputDebugString(mess);
}
}
}
int main() {
int n, id, power, lower_power = 0, higher_power;
s.insert(make_pair(1000000000, 1));
scanf("%d", &n);
while (n--) {
scanf("%d %d", &id, &power);
multimap<int, int>::iterator p;
p = s.insert(make_pair(power, id));
if (p == s.begin()) {
++p;
printf("%d %d\n", id, p->second);
}
else if (p == s.end()) {
printf("%d %d\n", id, p->second);
}
else {
--p;
lower_power = p->first;
++p; ++p;
higher_power = p->first;
if ((higher_power - power) < (power - lower_power)) {
printf("%d %d\n", id, p->second);
}
else {
--p; --p;
printf("%d %d\n", id, p->second);
}
}
}
return 0;
}
/* Look for mime handler in pool */
static RecollFilter *getMimeHandlerFromCache(const string& key)
{
PTMutexLocker locker(o_handlers_mutex);
string xdigest;
MD5HexPrint(key, xdigest);
LOGDEB(("getMimeHandlerFromCache: %s cache size %u\n",
xdigest.c_str(), o_handlers.size()));
multimap<string, RecollFilter *>::iterator it = o_handlers.find(key);
if (it != o_handlers.end()) {
RecollFilter *h = it->second;
hlruit_tp it1 = find(o_hlru.begin(), o_hlru.end(), it);
if (it1 != o_hlru.end()) {
o_hlru.erase(it1);
} else {
LOGERR(("getMimeHandlerFromCache: lru position not found\n"));
}
o_handlers.erase(it);
LOGDEB(("getMimeHandlerFromCache: %s found size %u\n",
xdigest.c_str(), o_handlers.size()));
return h;
}
LOGDEB(("getMimeHandlerFromCache: %s not found\n", xdigest.c_str()));
return 0;
}
//handle login requests
int loginReq(struct request_login *rl)
{
string username = rl->req_username;
struct sockaddr_in strctAddr = getAddrStruct();
userToAddrStrct.insert(userToAddrStrct.end(), pair<string, struct sockaddr_in>(username, strctAddr));
return 0;
}
map<string, double> indri::query::ConceptSelectorFuns::normConceptScoreFreq(indri::api::QueryEnvironment & env,
map<string, int> conceptsFrq,
multimap<double, pair<string, string> > scoredConcepts_norm )
{
// extract concept freq for the concepts exist in scoredConcepts_norm and store it in a container
map<string, double> conceptsFrqExtr_norm;
double max_cf = 0;
double min_cf = std::numeric_limits<double>::infinity();;
for (auto itSc = scoredConcepts_norm.begin(); itSc != scoredConcepts_norm.end(); itSc++)
{
conceptsFrqExtr_norm[(itSc->second).second] = conceptsFrq[(itSc->second).second] / double(env.documentCount());
max_cf = max(max_cf, conceptsFrqExtr_norm[(itSc->second).second]);
min_cf = min(min_cf, conceptsFrqExtr_norm[(itSc->second).second]);
cout << "indri::query::ConceptSelectorFuns::normConceptScoreFreq: conceptsFrqExtr_norm: min_cf, max_cf: " << min_cf << ", " << max_cf << endl;
cout << "indri::query::ConceptSelectorFuns::normConceptScoreFreq: scoredConcepts_norm: " << (itSc->second).second << " " << itSc->first << endl;
cout << "indri::query::ConceptSelectorFuns::normConceptScoreFreq: conceptsFrq: " << (itSc->second).second << " " << conceptsFrq[(itSc->second).second] << endl;
}
// normalize the extracted concepts' scores
map<string, double> conceptsFrqExtr_norm1;
for (auto itCf = conceptsFrqExtr_norm.begin(); itCf != conceptsFrqExtr_norm.end(); itCf++)
{
conceptsFrqExtr_norm1[itCf->first] = (itCf->second-min_cf)/(max_cf-min_cf);
cout << "indri::query::ConceptSelectorFuns::normConceptScoreFreq: conceptsFrqExtr_norm1: " << itCf->first << " " << conceptsFrqExtr_norm1[itCf->first] << endl;
}
return conceptsFrqExtr_norm1;
}
bool dfs(string &s){
e.insert(s);
v.push_back(s);
for(multimap<string,string>::iterator it=h.lower_bound(s);
it!=h.end()&&it->first==s; ++it){
if(e.find(it->second) != e.end()){
continue;
}
map<string, int>::iterator mi = r.find(it->second);
if(mi != r.end()){
/*
v.push_back(it->second);
reverse(v.begin(), v.end());
for(vector<string>::iterator vi=v.begin(); vi!=v.end(); vi++){
cout<<*vi<<" ";
}
cout<<endl;
*/
if(--mi->second<=0){
r.erase(mi);
}
return true;
} else if(dfs(it->second)){
return true;
}
}
v.pop_back();
return false;
}
void Vocabulary::search_image(int imgNum, vector<int> images, multimap<int, int> &imageScore, vector<int> &rankedScore)
{
for(int i=0; i<imgNum; i++)
{
imageScore.insert(pair<int,int>(i+1,0));
}
cout<<imageScore.size()<<endl;
int score=0;
for(auto ite=imageScore.begin(); ite!=imageScore.end(); ite++)
{
for(int i=0; i<images.size(); i++)
{
if((*ite).first==images[i])
{
(*ite).second++;
}
}
///normalize
float normalized_score=(float)(*ite).second/(float)images.size();
// (*ite).second=normalized_score;
cout.precision(5);
cout<<(*ite).first<<" "<<(*ite).second<<" "<<normalized_score<<endl;
rankedScore.push_back((*ite).second);
}
}
void DFHack::EventManager::unregisterAll(Plugin* plugin) {
for ( auto i = handlers[EventType::TICK].find(plugin); i != handlers[EventType::TICK].end(); i++ ) {
if ( (*i).first != plugin )
break;
//shenanigans to avoid concurrent modification
EventHandler getRidOf = (*i).second;
bool didSomething;
do {
didSomething = false;
for ( auto j = tickQueue.begin(); j != tickQueue.end(); j++ ) {
EventHandler candidate = (*j).second;
if ( getRidOf != candidate )
continue;
tickQueue.erase(j);
didSomething = true;
break;
}
} while(didSomething);
}
for ( size_t a = 0; a < (size_t)EventType::EVENT_MAX; a++ ) {
handlers[a].erase(plugin);
}
return;
}
void POICorrespondence::plotCorrespondences(const Mat& img1, vector<Point>& corners1, const Mat& img2,
multimap<Point, Point, PointCompare> &correspondences, Mat& dst)
{
dst.create(max(img1.rows, img2.rows), img1.cols + img2.cols, img1.type());
//ROI of bigger image pointing to first half
Mat dstImg1 = dst(Rect(0, 0, img1.cols, img1.rows));
//ROI of bigger image pointing to second half
Mat dstImg2 = dst(Rect(img1.cols, 0, img2.cols, img2.rows));
img1.copyTo(dstImg1);
img2.copyTo(dstImg2);
//Draw green lines
Scalar colorL(0, 255, 0);
int xP2;
map<Point, Point>::iterator it;
for (it = correspondences.begin(); it != correspondences.end(); ++it)
{
//Displace point in image2 since its located in the second half of the big image
xP2 = it->second.x + img1.cols;
line(dst, it->first, Point(xP2, it->second.y), colorL, 1, CV_AA);
}
}
int get(int key){
multimap<int, V2C>::iterator it = key2Value2Count.find(key);
if(it != key2Value2Count.end())
{
V2C& tmp = it->second;
#if 0
pair <multimap<int,int>::iterator, multimap<int,int>::iterator> ret;
ret = count2Key.equal_range(tmp.count);
for(multimap<int,int>::iterator it=ret.first; it!=ret.second;++it)
{
if(it->second == key)
{
count2Key.erase(it);
tmp.count++;
count2Key.insert(pair<int, int>(tmp.count, key));
break;
}
}
#endif
count2Key.erase(tmp.it);
list<int>::iterator iit = count2Key.insert(count2Key.end(),key);
tmp.it=iit;
#if 0
cout << "cache hit" << key << endl;
#endif
return tmp.value;
}
else
{
// cout << "cache miss" << key << endl;
return -1;
}
}
void set(int key, int value)
{
multimap<int, V2C>::iterator it = key2Value2Count.find(key);
if(it != key2Value2Count.end())
{
V2C& tmp = it->second;
tmp.value = value;
get(key);
}
else
{
if(count >= max)
{
list<int>::iterator cit=count2Key.begin();
// cout << "cache eviction: " << *cit << endl;
key2Value2Count.erase(*cit);
count2Key.erase(cit);
count--;
}
list<int>::iterator iit = count2Key.insert(count2Key.end(),key);
V2C tmp;
tmp.value = value;
tmp.it = iit;
// cout << "xxxx" <<*iit<<endl;
key2Value2Count.insert(pair<int, V2C>(key, tmp));
count++;
}
}
void timeout_alarm(int) {
cout << "!timeout alarm" << endl;
struct timeval tv;
struct timezone tz;
multimap<long, client_timeout>::iterator i;
long ts;
for (i = timestamp_map.begin(); i != timestamp_map.end();) {
gettimeofday(&tv, &tz); // pobranie aktualnego czasu
ts = tv.tv_sec * 1000 + tv.tv_usec / 1000; // zamiana na ms
if (i->first > ts)
break;
map<int, resource_clients>::iterator j = resource_map.find(
i->second.resource_id);
list<client>::iterator k = find_by_pid(j->second.waiting_clients,
i->second.pid);
j->second.waiting_clients.erase(k); // usuniecie klienta z kolejki oczekujacych
send_response(i->second.pid, TIMEDOUT);
timestamp_map.erase(i++); // usuniecie klienta z kolejki timeout
try_grant(j); // proba przydzielenia zasobu
}
if (!timestamp_map.empty()) {
useconds_t alrm = (i->first - ts) * 1000;
ualarm(alrm, 0);
}
cout << "!end of timeout alarm" << endl;
}
int Slave::checkBadDest(multimap<int64_t, Address>& sndspd, vector<Address>& bad)
{
bad.clear();
if (sndspd.empty())
return 0;
int m = sndspd.size() / 2;
multimap<int64_t, Address>::iterator p = sndspd.begin();
for (int i = 0; i < m; ++ i)
++ p;
int64_t median = p->first;
int locpos = 0;
for (multimap<int64_t, Address>::iterator i = sndspd.begin(); i != sndspd.end(); ++ i)
{
if (i->first > (median / 2))
return bad.size();
bad.push_back(i->second);
locpos ++;
}
return bad.size();
}
int main() {
int i;
scanf("%d", &n); sq_n = ceil(sqrt(n));
for(i = 0; i < n; i++) {
scanf("%d", &a[i]);
mp.insert(make_pair(a[i], i));
bit[i] = (i & -i);
}
for(i = n; i < n + 4; i++)
bit[i] = (i & -i);
scanf("%d", &q);
for(i = 0; i < q; i++) {
scanf("%d %d %d", &ql[i], &qr[i], &qk[i]);
ql[i]--; qr[i]--;
qs[i] = i;
}
sort(qs, qs + q, cmp_k);
auto it = mp.begin();
for(i = 0; i < q; i++) {
for(; it != mp.end() && it->first <= qk[qs[i]]; ++it)
add(it->second, -1);
ql[qs[i]] = get(ql[qs[i]], qr[qs[i]]);
}
for(i = 0; i < q; i++)
printf("%d\n", ql[i]);
return 0;
}
void DumpDOT(
char *Filename,
multimap <OperandPosition,OperandPosition,OperandPositionCompareTrait> &InstructionMap,
hash_map <ea_t,insn_t> &InstructionHash
)
{
HANDLE hFile=OpenLogFile(Filename);
//InstructionMap
//InstructionHash
WriteToLogFile(hFile,"digraph g {\r\n\
graph [\r\n\
rankdir = \"TB\"\r\n\
];\r\n\
node [\r\n\
fontsize = \"12\"\r\n\
];\r\n\
edge [\r\n\
];\r\n");
//shape = \"ellipse\"\r\n\
hash_map <ea_t,insn_t>::iterator InstructionHashIter;
//Write Node Data
for(InstructionHashIter=InstructionHash.begin();InstructionHashIter!=InstructionHash.end();InstructionHashIter++)
{
ea_t address=InstructionHashIter->first;
char op_buffer[100]={0,};
ua_mnem(address,op_buffer,sizeof(op_buffer));
WriteToLogFile(hFile,"\"%X\" [\r\n\tlabel=\"%s",address,op_buffer);
for(int i=0;i<UA_MAXOP;i++)
{
if(InstructionHashIter->second.Operands[i].type>0)
{
char operand_str[MAXSTR]={0,};
ua_outop(address,operand_str,sizeof(operand_str)-1,i);
tag_remove(operand_str,operand_str,0);
char *escaped_operand_str=EscapeString(operand_str);
if(escaped_operand_str)
{
WriteToLogFile(hFile,"|<f%u>%s",i,escaped_operand_str);
free(escaped_operand_str);
}
}
}
WriteToLogFile(hFile,"\"\r\n\tshape=\"record\"\r\n];\r\n\r\n");
}
multimap <OperandPosition,OperandPosition,OperandPositionCompareTrait>::iterator InstructionMapIter;
for(InstructionMapIter=InstructionMap.begin();InstructionMapIter!=InstructionMap.end();InstructionMapIter++)
{
WriteToLogFile(hFile,"\"%X\":f%u -> \"%X\":f%u\r\n",
InstructionMapIter->first.Address,
InstructionMapIter->first.Index,
InstructionMapIter->second.Address,
InstructionMapIter->second.Index);
}
CloseLogFile(hFile);
}
void print(multimap<char, int> m)
{
for (multimap<char, int>::iterator i = m.begin(); i != m.end(); ++i)
{
printf("%c-%d ", i->first, i->second);
}
printf("\n");
}
void print_inputs() {
cout << "switches: " << endl;
for (set<long>::iterator it = switches.begin(); it != switches.end(); it++) {
cout << *it << ", ";
}
cout << endl;
cout << "trackElement_sensors: " << endl;
for (multimap<long, long>::iterator itr = trackElement_sensors.begin();
itr != trackElement_sensors.end();) {
multimap<long, long>::iterator curr = itr;
while (itr != trackElement_sensors.end() && itr->first == curr->first) {
cout << itr->first << "-" << itr->second << ", ";
++itr;
}
}
}
void eliminate_left_recursion(multimap<string,string> &rules)
{
//cout<<"Left Recurse"<<endl;
multimap<string,string>::iterator it;
multimap<string,string>::iterator it1;
string non_term,non_term_1;
string RHS,leftmost,RHS1,remaining;
const char *rhs;
//string tok_rhs;
char *tok_rhs;
char r[1000];
string new_rhs;
for(int i=0;i<n_t.size();i++)
{
for(int j=0;j<i;j++)
{
it=rules.find(n_t[i]);
non_term=(*it).first;
for(;it!=rules.end() && (((*it).first.compare(non_term))==0);it++)
{
RHS=(*it).second;
rhs=RHS.c_str();
strcpy(r,rhs);
tok_rhs=strtok(r," ");
remaining.copy(r,strlen(r));
leftmost.copy(tok_rhs,strlen(tok_rhs));
if(leftmost.compare(n_t[j])==0)
{
new_rhs.clear();
it1=rules.find(n_t[j]);
non_term_1=(*it1).first;
for(;it1!=rules.end() && (((*it1).first.compare(non_term_1))==0);it1++)
{
RHS1=(*it1).second;
new_rhs.append(RHS1).append(remaining);
rules.erase(it);
rules.insert(pair<string,string>(non_term,new_rhs));
}
}
}
}
eliminate_immediate_left_recursion(rules,i);
}
}
void CCacheThread::SetOnlyValueProcess(const multimap<unsigned int, string> &mapRequestValue, multimap<unsigned int, string> &mapStoredValue)
{
CVS_XLOG(XLOG_DEBUG, "CCacheThread::%s\n", __FUNCTION__);
multimap<unsigned int, string>::iterator itr;
multimap<unsigned int, string>::const_iterator citr;
for (citr = mapRequestValue.begin(); citr != mapRequestValue.end(); ++citr)
{
itr = mapStoredValue.find(citr->first);
if (itr == mapStoredValue.end())
{
mapStoredValue.insert(make_pair(citr->first, citr->second));
}
else
{
itr->second = citr->second;
}
}
}
void CCacheThread::DumpMMap(const multimap<unsigned int, string> &mmap)
{
CVS_XLOG(XLOG_DEBUG, "CCacheThread::%s\n", __FUNCTION__);
multimap<unsigned int, string>::const_iterator citr;
for (citr=mmap.begin(); citr!=mmap.end(); ++citr)
{
CVS_XLOG(XLOG_DEBUG, "CCacheThread::%s, [%d:%s]\n", __FUNCTION__, citr->first, citr->second.c_str());
}
}
void print (multimap<string, int, less<string> > &m)
{
multimap<string, int, less<string> >::iterator It = m.begin();
cout << "multimap :" << endl;
while ( It != m.end() )
{
cout << (*It).first << " - " << (*It).second << endl;
It++;
}
}
void erase_from_timestamp_map(pid_t pid, int resource_id) {
for (multimap<long, client_timeout>::iterator i = timestamp_map.begin();
i != timestamp_map.end(); ++i) {
if (i->second.pid == pid && i->second.resource_id == resource_id) {
timestamp_map.erase(i);
break;
}
}
// ewentualnie przestawic alarm
}
// lists top 8 most popular playlists
void mostPopularPlaylist(){
multimap<int, string>:: iterator it = popularityDB.end(); // the most popular playlists are at the end of the database
// list top 8 playlists
for( int count = 0; count < 8 && it != popularityDB.begin() ; count++){
it--;
//cout<< it -> second <<endl;
printPlaylistSongs( it -> second );
}
}
void printml(multimap<int, double, less<int> > &m)
{
multimap<int, double, less<int> >::iterator it;
for (it = m.begin(); it != m.end(); ++it)
{
Custompair p1 = (pair<int, double>)(*it);
cout << p1.first << endl;
cout << std::fixed << cout.precision(2) << p1.second << endl;
}
}
int main(){
int i,j,ox,oy,oi,min1,min2,outCnt=0;
memset(used,0,sizeof(used));
for(i=1;i<=300;i++){
scanf("%d %d",x+i,y+i);
trees.insert(map<int,int>::value_type(x[i],i));
}
bool flag0=0;
for(it=trees.begin();it!=trees.end();it++){
oi=(*it).second;
if(used[oi])continue;
used[oi]=1;
for(i=1,j=0;i<=300;i++){
if(used[i])continue;
if(x[i]==x[oi])continue;
j++;
if(j==1){
min1=i;
if(x[i]==x[oi])flag0=1;
}else if(j==2){
min2=i;
if(x[i]==x[oi]){
swap(min1,min2);
flag0=1;
}else{
if(compA(oi,min1,oi,min2)>0)
swap(min1,min2);
}
}else{
if(x[oi]==x[i]){
min2=min1;
min1=i;
flag0=1;
}else if(compA(oi,i,oi,min2)<0){
min2=min1;
if(flag0){
min2=i;
}else if(compA(oi,i,oi,min1)>0){
min1=i;
}else{
min2=i;
}
}
}
}
if(j<2)break;
printf("%d %d %d\n",oi,min1,min2);
used[min1]=used[min2]=1;
outCnt++;
if(outCnt>=10)break;
}
return 0;
}
GDomNode* serialize(GDom* pDoc, size_t labelDims)
{
GDomNode* pList = pDoc->newList();
for(multimap<double,const double*>::iterator it = m_instances.begin(); it != m_instances.end(); it++)
{
pList->addItem(pDoc, pDoc->newDouble(it->first));
for(size_t i = 0; i < labelDims; i++)
pList->addItem(pDoc, pDoc->newDouble(it->second[i]));
}
return pList;
}
bool getOptValues(vector<string>& values, multimap<string,string>& optmap,const string& key){
values.clear();
pair<multimap<string,string>::iterator,multimap<string,string>::iterator> findI=optmap.equal_range(key);
if(findI.first==optmap.end())
return false;
for(multimap<string,string>::iterator i=findI.first;i!=findI.second;i++)
values.push_back(i->second);
return true;
}
void dump_weigths(const multimap<int32_t, ServerCollect*>& weights)
{
printf("-----------------------dump_weigths(%"PRI64_PREFIX"u)----------------------\n", weights.size());
multimap<int32_t, ServerCollect*>::const_iterator it = weights.begin();
while (it != weights.end())
{
printf("server(%s), weight(%d)", tbsys::CNetUtil::addrToString(it->second->get_ds()->id_).c_str(), it->first);
++it;
}
printf("-----------------------dump_weigths end----------------------\n");
}
void process() {
set<long> trackElements;
for (multimap<long, long>::iterator itr = trackElement_sensors.begin();
itr != trackElement_sensors.end();) {
multimap<long, long>::iterator curr = itr;
while (itr != trackElement_sensors.end() && itr->first == curr->first) {
trackElements.insert(itr->first);
++itr;
}
}
long n = 0;
for (set<long>::iterator it = switches.begin(); it != switches.end(); it++) {
if (trackElements.find(*it) == trackElements.end()) {
n++;
}
}
cout << "Results: " << n << endl;
}
