C++ multimap::clear方法代码示例

int fun(){
    int i;
    for(i=1;i<root;i++){
		if(freq[i] ==0 ){
			leaf.push(i);
		}
	}
	
	int f, p;
	i = 0;
	while(! leaf.empty() ){
		f = leaf.top(); leaf.pop();
		p = node[i];
		edge.insert( make_pair(p, f) );
		if(--freq[p] == 0 && p < root-1){
			leaf.push(p);
		}
		i++;
	}
	edge.erase(0);
	
	printf("(");
	traceback(root-1);
	printf(")\n");
	edge.clear();
}

void readIn(){
    int n;
    e.clear();
    r.clear();
    h.clear();
    string a, b;

    cin>>n;
    while(n--){ // type of plug
        cin>>a;
        e.insert(a);
    }
    cin>>n;
    while(n--){ // type of device
        cin>>a>>b;
        if(e.find(b) != e.end()){
            e.erase(b);
        } else {
            r[b]++;
        }
    }
    cin>>n;
    while(n--){ // type of adapter
        cin>>a>>b;
        //h.insert(make_pair(a,b));
        h.insert(make_pair(b,a));
    }
}

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);
		}
	}

}

 LRUCache(int capacity)
 {
     count = 0;
     count2Key.clear();
     key2Value2Count.clear();
     max = capacity;
 }

 void init() {
     double INF = 262144;
     S.clear();
     S.insert(make_pair(Seg(Pt(-INF, -INF), Pt(INF, -INF), -1, -1), (Triangle*)NULL));
     S.insert(make_pair(Seg(Pt(-INF,  INF), Pt(INF,  INF), -1, -1), (Triangle*)NULL));
     status = 0;
 }

void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event event) {
    static bool doOnce = false;
    if ( !doOnce ) {
        //TODO: put this somewhere else
        doOnce = true;
        EventHandler buildingHandler(Buildings::updateBuildings, 100);
        DFHack::EventManager::registerListener(EventType::BUILDING, buildingHandler, NULL);
        //out.print("Registered listeners.\n %d", __LINE__);
    }
    if ( event == DFHack::SC_WORLD_UNLOADED ) {
        lastTick = 0;
        lastJobId = -1;
        for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
            Job::deleteJobStruct((*i).second);
        }
        prevJobs.clear();
        tickQueue.clear();
        livingUnits.clear();
        nextItem = -1;
        nextBuilding = -1;
        buildings.clear();
        constructions.clear();

        Buildings::clearBuildings(out);
        gameLoaded = false;
        nextInvasion = -1;
    } else if ( event == DFHack::SC_WORLD_LOADED ) {
        uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear
            + DFHack::World::ReadCurrentTick();
        multimap<uint32_t,EventHandler> newTickQueue;
        for ( auto i = tickQueue.begin(); i != tickQueue.end(); i++ ) {
            newTickQueue.insert(pair<uint32_t,EventHandler>(tick + (*i).first, (*i).second));
        }
        tickQueue.clear();

        tickQueue.insert(newTickQueue.begin(), newTickQueue.end());

        nextItem = 0;
        nextBuilding = 0;
        lastTick = 0;
        nextInvasion = df::global::ui->invasions.next_id;
        gameLoaded = true;
    }
}

 void a_search(string t, multimap<string, int>& pos)
 {
     //扫描文本t
     //返回其中出现的字典树中的字符串及其位置 存储于映射表pos中
     pos.clear();
     int i(0);
     ac_node *p(&a_root);
     while(i < (int)t.length())
     {
         int index = t[i] - 'a';
         while(p->a_ch[index] == NULL && p != &a_root)
             //若字典树中该节点不存在
             //则沿着fail指针递归 直到回到根节点
             p = p->a_fail;
         if(p->a_ch[index] == NULL)
             p = &a_root;
         else
         {
             //若点p的孩子节点index存在
             //即该孩子节点与文本下标i处字符匹配
             p = p->a_ch[index];
             ac_node *tmp(p);
             while(tmp != &a_root)
             {
                 //通过指针tmp找出所有可能与文本下标i处匹配的字符串
                 //因为除了p的孩子节点index 还可能存在其他字符串此时也与i处匹配
                 //
                 //在文档"AC自动机算法详解" 作者"极限定律"中
                 //第一个有问题的地方是:
                 //原文中该处的判断条件是:
                 //while(tmp != root && tmp->a_cnt == 0)
                 //(原文与本文中的变量名不一样 但代码的含义没有曲解)
                 //但是经过测试这里tmp->a_cnt == 0的条件恰好应该是相反的
                 //即tmp->a_cnt != 0 也可写作tmp->a_cnt(该值为正时即true)
                 if(tmp->a_cnt)
                 {
                     string s(a_getstring(tmp));
                     pos.insert(make_pair(s, i - (int)s.length() + 1));
                     //文档"AC自动机算法详解" 作者"极限定律"中
                     //第二个有问题的地方则是:
                     //原文中该处有一处操作:
                     //tmp->a_cnt = 0;
                     //(原文与本文中的变量名不一样 但代码的含义没有曲解)
                     //但我不太明白为何要将字典树中该字符串删除
                     //也可能只求字符串第一次出现的位置
                     //本文的代码中没有删除字符串
                     //测试用例中可以看出本文的代码找出了所有匹配到的字符串位置
                 }
                 tmp = tmp->a_fail;
             }
         }
         ++ i;
     }
 }

void clearMimeHandlerCache()
{
    LOGDEB(("clearMimeHandlerCache()\n"));
    typedef multimap<string, RecollFilter*>::value_type value_type;
    multimap<string, RecollFilter *>::iterator it;
    PTMutexLocker locker(o_handlers_mutex);
    for (it = o_handlers.begin(); it != o_handlers.end(); it++) {
	delete it->second;
    }
    o_handlers.clear();
}

void jack_host::get_automation(int param_no, multimap<uint32_t, automation_range> &dests)
{
    dests.clear();
    if (!cc_mappings)
        return;
    for(automation_map::iterator i = cc_mappings->begin(); i != cc_mappings->end(); ++i)
    {
        if (param_no == -1 || param_no == i->second.param_no)
            dests.insert(*i);
    }
}

 vector<string> findItinerary(vector<pair<string, string>> tickets) 
 {
     trav.clear();
     for (int i=0;i<tickets.size();++i)
         trav.emplace(tickets[i].first, tickets[i].second);
     
     ans.clear();
     solve("JFK");
     
     reverse(ans.begin(), ans.end());
     return ans;
 }

    void operator& (multimap<double,double>& x, istream& stream) {
	size_t l;
	l & stream;
	validateListSize (l);
	x.clear ();
	multimap<double,double>::iterator pos = x.begin ();
	for (size_t i = 0; i < l; ++i) {
	    double s;
	    double t;
	    s & stream;
	    t & stream;
	    pos = x.insert (pos, make_pair (s,t));
	}
    }

void OP_perf_utils::op_release_resources(void)
{
	map<pid_t, operf_process_info *>::iterator it = process_map.begin();
	while (it != process_map.end())
		delete it++->second;
	process_map.clear();

	multimap<string, struct operf_mmap *>::iterator images_it = all_images_map.begin();
	while (images_it != all_images_map.end())
		delete images_it++->second;
	all_images_map.clear();
	delete kernel_mmap;

	operf_sfile_close_files();
	operf_free_modules_list();

}

	int countRangeSum(vector<int>& nums, int lower, int upper)
	{
		_hash.clear(); _prefix.clear();
		_prefix.push_back(0);
		for (int i = 0, sz = nums.size(); i < sz; i++)
		{
			_prefix.push_back(_prefix.back() + nums[i]);
			_hash.insert(make_pair(_prefix.back(), i + 1));
		}
		int ret = 0;
		for (int i = 0, sz = _prefix.size(); i < sz; i++)
		{
			int64_t hoge = _prefix[i];
			for (auto it = _hash.lower_bound(hoge + lower);
				it != _hash.end() && it -> first <= hoge + upper; it++ )
				if (it -> second > i)
					ret++;
		}
		return ret;
	}

void solve() {
	int i, j, cnt = 0;
	for (i = 0; i < n; i++) {
		tr[i].get();
		ev[cnt++] = EVENT(i, tr[i].p1.x, IN);
		ev[cnt++] = EVENT(i, tr[i].p2.x, CH);
		ev[cnt++] = EVENT(i, tr[i].p3.x, OUT);
	}
	sort(ev, ev + cnt);
	T.clear();
	T.insert(make_pair(SEG(POINT(-INF, -INF), POINT(INF, -INF), -1), 1));
	T.insert(make_pair(SEG(POINT(-INF, INF), POINT(INF, INF), -1), 0));
	curx = 0, ans = 1;
	for (i = 0; i < cnt && ans != -1; i++) {
		j = ev[i].id, curx = ev[i].x;
		if (ev[i].type == IN) {
			tr[j].p12 = T.insert(make_pair(SEG(tr[j].p1, tr[j].p2, j), 0));
			tr[j].p13 = T.insert(make_pair(SEG(tr[j].p1, tr[j].p3, j), 0));
			if (!isok(tr[j].p12) || !isok(tr[j].p13)) ans = -1;
			else {
				IT t = tr[j].p12;
				if (++t == tr[j].p13) update(tr[j].p12, tr[j].p13);
				else update(tr[j].p13, tr[j].p12);
			}
		} else if (ev[i].type == CH) {
			if (!isok(tr[j].p12)) ans = -1;
			else {
				tr[j].p23 = T.insert(make_pair(SEG(tr[j].p2, tr[j].p3, j), tr[j].p12->second));
				T.erase(tr[j].p12);
				if (!isok(tr[j].p23)) ans = -1;
			}
		} else if (ev[i].type == OUT) {
			if (!isok(tr[j].p13) || !isok(tr[j].p23)) ans = -1;
			else T.erase(tr[j].p13), T.erase(tr[j].p23);
		}
	}
	if (ans == -1) printf("ERROR\n");
	else printf("%d shades\n", ans);
}

		double getValue(double value){


            if(type == Filter_Median){
                data.push_back(value);

				medianMap.clear();
				for(int i=0; i < data.size(); i++){
                    medianMap.insert(make_pair(data[i], data[i]));
                }

				double median = getValue();

				medians.push_back(median);

				if(medians.size() > mediansLength){
					medians.erase(medians.begin());
				}

				value = 0.0;
				for(unsigned int i=0; i<medians.size(); i++){
					value += medians[i];
				}

				value = value / (double) medians.size();
			}
			else if(type == Filter_Average){
				data.push_back(value);
				value = getValue();
			}


			if(data.size() > bufferLength){
				data.erase(data.begin());
			}


			return value;
		}