堆的基础学习

progressiveFighting

已于 2022-08-05 12:37:07 修改

阅读量2.1k

点赞数 9

分类专栏：算法文章标签：算法数据结构 c++

于 2022-03-31 20:27:28 首次发布

本文链接：https://blog.csdn.net/computs/article/details/123852854

版权

算法专栏收录该内容

18 篇文章 1 订阅

订阅专栏

堆通常是一个可以被看做一棵完全二叉树的数组对象。
堆总是满足下列性质：

堆中某个结点的值总是不大于或不小于其父结点的值；
堆总是一棵完全二叉树。

建堆

从上往下
假设给定一个数组，从第一个元素依次插入在堆中，调整至满足堆的结构（大根堆）
流程：比较当前位置与父结点位置，如果当前位置比父节点大，则交换。

void heapInsert(vector<int>&a,int index){//从index位置开始往上比较
	while(index<a.size()&& a[index]>a[(index-1)/2]){
		swap(a[index],a[(index-1)/2]);//(index-1)/2是index的父节点 
		index=(index-1)/2;
	} 
}
void heapSort2(vector<int>&a){
	int heapSize=a.size();
//	for(int i=heapSize/2;i>=0;--i){
//		heapify(a,i,heapSize-1);
//	}
	for(int i=0;i<heapSize;++i){
		heapInsert(a,i);//从0到heapSize-1依次插入到堆中
	} 
	for(int i=heapSize-1;i>0;--i){
		swap(a[0],a[i]);
		heapify(a,0,i-1);
	}
}

上述建堆的时间复杂度O(NlongN)

从下往上
一个数组就是一个完全二叉树，从最后一个非叶子结点开始往前调整结点的位置
流程：从当前位置开始往下调整，如果当前位置比最大孩子结点小，就交换，然后下移。

void heapify(vector<int>&a,int low,int high){
	int i=low;
	int j=2*i+1;
	int temp=a[i];
	while(j<=high){
		while(j<high&& a[j+1]>a[j]){
			++j;
		}
		if(a[j]>temp){
			a[i]=a[j];
			i=j;
			j=2*i+1;
		}else{
			break;
		}
	}
	a[i]=temp;
}
void heapSort2(vector<int>&a){
	int heapSize=a.size();
	for(int i=heapSize/2;i>=0;--i){//heapSize/2是最后一个非叶子结点
		heapify(a,i,heapSize-1);
	}
//	for(int i=0;i<heapSize;++i){
//		heapInsert(a,i);
//	}

上述时间复杂度O(N)
如果元素不是同时给出的，只能采用第一种建堆的方法。

题目

给定很多线段，每个线段都有两个数[start, end]，表示线段开始位置和结束位置，左右都是闭区间。
规定:
1)线段的开始和结束位置一定都是整数值
2)线段重合区域的长度必须>=1
返回线段最多重合区域中，包含了几条线段
例：
有三个线段，[1,2],[2,3],[1,3]，其中[1,2]和[1,3]重合或者[2,3]和[1,3]重合，所以返回2,但是[1,2]和[2,3]不重合(因为重合的长度是0)
分析：
解1 暴力方法
先找出所有线段中开始位置的最小值minStart和结束位置的最大值maxEnd，即在[minStart,maxEnd]找包含多少条重合的线段，然后考虑有多少个线段包含minStart+0.5记为r1，有多少个线段包含minStart+1.5记为r2,……，有多少个线段包含maxEnd-0,5，取这些数的最大值即为结果。因此每个重合区域必包含某个点5。

int way1(vector<Line*>lines){
	int minStart=lines[0]->start;
	int maxEnd=lines[0]->end;
	int re=0;
	//寻找线段的最小开始和最大结束
	for(int i=1;i<lines.size();++i){
		if(lines[i]->start<minStart){
			minStart=lines[i]->start;
		}
		if(lines[i]->end>maxEnd){
			maxEnd=lines[i]->end;
		}
	}
	for(double i=minStart+0.5;i<=maxEnd;++i){
		int sum=0;
		//遍历所有的线段，计算包含i的线段数
		for(int j=0;j<lines.size();++j){
			if(lines[j]->start<i && lines[j]->end>i){
				++sum;
			}
		}
		if(re<sum){
			re=sum;
		}
	}
	return re;
}

时间复杂度O((max-min)N)，max是线段的最大结束，min是线段的最小开始。

解2 堆
任何重合区域的左边界必是某一个线段的左边界

先按线段的开始位置从小到大排序，准备一个小顶堆（存放线段的结束位置）
从最小的线段开始，将线段结束位置小于等于本线段开始位置的线段从堆中弹出，然后将本线段的结束位置压入堆，此时堆中的元素个数就是从本线段开始的区域中重合的线段数。
每一个线段都进行2过程，并同时更新重合线段数的最大值，最后返回最大值。
为什么堆中的元素个数就是从本线段开始的区域中重合的线段数？
重合的线段的结束位置一定是大于本线段的开始位置的，所以将线段结束位置小于等于本线段开始位置的线段从堆中弹出，此时堆中剩下的线段都是结束位置大于本线段开始位置，也即都是重合的线段。

bool compare(Line* a,Line* b){
	return a->start<b->start;
} 
int way2(vector<Line*>&lines){
	priority_queue<int,vector<int>,greater<int> >q;//小根堆
	int re=0;
	sort(lines.begin(),lines.end(),compare);
	
	for(int i=0;i<lines.size();++i){
		int j=lines[i]->start;
		while(!q.empty() && q.top()<=j){
			q.pop();
		}
		q.push(lines[i]->end);
		re=re<q.size()?q.size():re;
	}
	return re;
}

线段重合
分析：
注意本题重合区域没有限制，例如[1,2],[2,3]也是重合的

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
bool cmp(pair<int, int>p1, pair<int, int>p2) {
	return p1.first < p2.first;//按开始位置从小到大排序
}
int way2(vector<pair<int, int>>lines) {
	sort(lines.begin(), lines.end(), cmp);
	priority_queue<int, vector<int>, greater<int>>pq;//存放线段结束位置的小根堆
	int result = 0;
	for (pair<int, int>curLine : lines) {
		pq.push(curLine.second);
		while (!pq.empty() && pq.top() < curLine.first) {//如果堆顶元素小于等于线段的开始位置就弹出
			pq.pop();
		}

		result = result >= pq.size() ? result : pq.size();//更新结果
	}
	return result;
}
int main()
{

	vector<pair<int, int>>lines;
	int N;
    cin>>N;
    for(int i=0;i<N;i++){
        pair<int,int>p;
        cin>>p.first;
        cin>>p.second;
        lines.push_back(p);
    }
    cout<<way2(lines);
	return 0;
}

函数指针

写法1

int sum(int a,int b)
{
    return a+b;
}
int (*f)(int a,int b);
	f=sum;
	cout<<f(3,2);

写法2

typedef int (*fun)(int c,int d);
	fun f ;//定义一个函数指针 
	f=sum;
	cout<<f(1,2);

写法3

typedef int (fun)(int c,int d);
	fun* f ;//定义一个函数指针 
	f=sum;
	cout<<f(44,2);

手写堆

其中comp的一个实例如下：

bool myCompare(Line* a,Line*b){
	return a->start<b->start;
}

#pragma once
#include<iostream>
#include<vector>
#include<unordered_map>
#include<list>
using namespace std;


//T不可以是基础类型，如果是基础类型的话需要再包一层（因为map的key不可以重复） 
template<class T>
class Heap {
private:
	vector<T>a;
	unordered_map<T, int> map;
	int heapSize;
	typedef bool(*compare)(T a, T b);
	compare comp;//比较器 

public:
	Heap(compare comp) :comp(comp) {
		heapSize = 0;
	}
	void mySwap(int i, int j) {//交换i和j位置的数,同时索引也交换 
		map[a[i]] = j;
		map[a[j]] = i;
		swap(a[i], a[j]);
	}
	void heapify(int low, int high) {

		int i = low;
		int j = 2 * i + 1;
		while (j <= high) {
			while (j < high && comp(a[j + 1], a[j])) {
				++j;
			}
			if (comp(a[j], a[i])) {
				mySwap(i, j);
				i = j;
				j = 2 * i + 1;
			}
			else {
				break;
			}
		}
	}
	void heapInsert(int index) {
		
		while (comp(a[index], a[(index - 1) / 2])){
			mySwap(index, (index - 1) / 2);
			index = (index - 1) / 2;
		}
	}
	int getSize() {
		return heapSize;
	}
	bool empty() {
		return heapSize == 0;
	}
	T top() {
		return a[0];
	}
	void pop() {
		mySwap(0, --heapSize);
		map.erase(a[heapSize]);
		a.erase(a.begin() + heapSize);
		a.resize(heapSize);
		heapify(0, heapSize - 1);
	}

	void push(T t) {
		a.resize(++heapSize);
		a[heapSize - 1] = t;
		map[t] = heapSize - 1;
		heapInsert(heapSize-1);
		
	}
	void remove(T t) {
		int index = map[t];
		if (index == heapSize - 1) {
			--heapSize;
			a.resize(heapSize);
			map.erase(t);
			return;
		}
		mySwap(index, heapSize-1);
		--heapSize;
		a.resize(heapSize);
		map.erase(t);
		if (heapSize > 0) {
			
			heapInsert(index);
			heapify(0, heapSize - 1);
		}
		

	}
	void resign(T t) {//t元素发生改动，可能需要调整堆
		if (heapSize == 0) {
			return;
		}
		int index = map[t];
		heapInsert(index);
		heapify(index, heapSize - 1);
	}
	list<T>returnList() {//返回堆中所有元素
		list<T>re;
		for (int i = 0; i < heapSize; ++i) {
			
			re.push_back(a[i]);
		}
		return re;
	}
	bool contain(T t) {
		return map.count(t);
	}

};

相关题目

题目描述：
给定一个整形数组 int arr[] 和一个布尔类型的数组 bool op[]，两个数组等长，假设长度为N，arr[i]表示客户编号，op[i]表示客户操作，op[i]=true表示客户i购买了一件商品，op[i]=false表示客户i退了一件商品。
现在要求给购买次数最多的前k名用户颁奖。所以每个事件发生前，都返回一个前k名用户名单。
得奖的规则：

如果某个用户购买商品次数为0，但是又发生了退货事件，则认为该事件无效，得奖名单和之前事件一致.
某用户发生购买商品事件，购买商品数+1，发生退货事件，购买商品数-1.
每次都是最多K个用户得奖，K也为传入的参数.如果根据全部规则，得奖人数确实不够K个，那就以不够的情况输出结果.
得奖系统分为得奖区和候选区，任何用户只要购买数＞0，一定在这两个区域中的一个.
购买数最大的前K名用户进入得奖区，在最初时如果得奖区没有到达K个用户，那么新来的用户直接进入得奖区.
如果购买数不足以进入得奖区的用户，进入候选区.
如果候选区购买数最多的用户，已经足以进入得奖区，该用户就会替换得奖区中购买数最少的用户(大于才能替换)，如果得奖区中购买数最少的用户有多个，就替换最早进入得奖区的用户.如果候选区中购买数最多的用户有多个，机会会给最早进入候选区的用户.
候选区和得奖区是两套时间，因用户只会在其中一个区域，所以只会有一个区域的时间，另一个没有从得奖区出来进入候选区的用户，得奖区时间删除，进入候选区的时间就是当前事件的时间(可以理解为arr[]和op中的i)从候选区出来进入得奖区的用户，候选区时间删除，进入得奖区的时间就是当前事件的时间(可以理解为arr和op们中的i).
如果某用户购买数==0，不管在哪个区域都离开，区域时间删除，离开是指彻底离开，哪个区域也不会找到该用户
如果下次该用户又发生购买行为，产生>0的购买数，会再次根据之前规则回到某个区域中，进入区域的时间重记.

解法1 暴力模拟

class Customer {
public:
	int id;
	int item;
	int time;
	Customer(int id) :id(id) {
		item = 0;
		time = 0;
	}
	Customer(Customer* c) {
		id = c->id;
		item = c->item;
		time = c->item;
	}
};
bool count(list<Customer*>& v, Customer* c) {//查找list是否有c
	for (auto it = v.begin(); it != v.end(); ++it) {
		if ((*it) == c) {
			return true;
		}
	}
	return false;
}
bool winnerCom(Customer* a, Customer* b) {
	if (a->item < b->item) {
		return true;
	}
	else if (a->item == b->item && a->time < b->time) {
		return true;
	}
	else {
		return false;
	}
}
bool waitCom(Customer* a, Customer* b) {
	if (a->item > b->item) {
		return true;
	}
	else if (a->item == b->item && a->time < b->time) {
		return true;
	}
	else {
		return false;
	}
}
void clearZero(list<Customer*>& s) {
	auto it = s.begin();
	while (it != s.end()) {
		auto im = it;
		++it;
		if ((*im)->item == 0) {
			s.erase(im);
		}
	}
	
}
void move(list<Customer*>& winner, list<Customer*>& wait, int k, int i) {
	if (wait.empty()) {
		return;
	}
	if (winner.size() < k) {//得奖区不足k个 
		Customer* c = wait.front();
		wait.pop_front();
		c->time = i;
		winner.push_back(c);
	}
	else {
		if (wait.front()->item > winner.front()->item) {
			Customer* wa = wait.front();
			wait.pop_front();
			Customer* wi = winner.front();
			winner.pop_front();
			wa->time = i;
			wi->time = i;
			wait.push_back(wi);
			winner.push_back(wa);
		}
	}
}
void putRe(list<list<int>>& re, list<Customer*>& winner) {
	list<int>ans;
	for (auto it = winner.begin(); it != winner.end(); ++it) {
		
		Customer* lc = new Customer(*it);
		ans.push_back(lc->id);
	}
	re.push_back(ans);
}
list<list<int>> topK(vector<int>& arr, vector<bool>& op, int k) {
	unordered_map<int, Customer*>customers;//客户的id 
	list<Customer*> winner;//得奖区 	
	list<list<int>>re;
	list<Customer*> wait;//候选区 
	for (int i = 0; i< arr.size(); ++i) {

		int id = arr[i];
		bool buyOrRefund = op[i];
		if (!buyOrRefund && !customers.count(id)) {//用户退货，并且之前未购买过 

			putRe(re, winner);
			continue;
		}
		/*
		接下来分以下几种情况：
		1. 用户之前没有购买，此时买货
		2. 用户之前购买数>0,此时买货
		3. 用户之前购买数>0,此时退货
		*/
		if (!customers.count(id)) {
			Customer* customer = new Customer(id);
			customers.emplace(id, customer);
		}
		Customer* c = customers[id];
		if (buyOrRefund) {
			++c->item;
		}
		else {
			--c->item;
		}
		if (c->item == 0) {
			customers.erase(customers.find(id));
		}
		//用户购买数大于0，并且此时买货 
		if (!count(winner, c) && !count(wait, c)) {
			if (winner.size() < k) {
				c->time = i;
				winner.insert(winner.end(), c);
			}
			else {
				c->time = i;
				wait.insert(wait.end(), c);
			}
		}
		//删除购买数为0的用户 
		clearZero(winner);
		clearZero(wait);
		winner.sort(winnerCom);
		wait.sort(waitCom);
		move(winner, wait, k, i);
		putRe(re, winner);
	}
	return re;
}

解法2 加强堆

class ReturnWinner {
private:
	unordered_map<int, Customer*>customers;
	Heap<Customer*>* winner;
	Heap<Customer*>* wait;
	int k;
	int* a;
public:
	ReturnWinner(int k) :k(k) {
		winner = new Heap<Customer*>(winnerCom);
		wait = new Heap<Customer*>(waitCom);
		a = new int[10];
	}
	void operate(int time, int id, bool buyOrRefund) {
		if (!buyOrRefund && !customers.count(id)) {
			return;
		}
		//第一次购买
		if (!customers.count(id)) {
			Customer* c = new Customer(id);
			customers.emplace(id, c);
		}
		Customer* c = customers[id];
		if (buyOrRefund) {
			c->item++;
		}
		else {
			c->item-- ;
		}
		if (c->item == 0) {
			customers.erase(id);
		}
		//第一次购买
		if (!winner->contain(c) && !wait->contain(c)) {
			if (winner->getSize() < k) {
				c->time = time;
				winner->push(c);
			}
			else {
				c->time = time;
				wait->push(c);
			}
		}
		//之前在候选区
		else if (wait->contain(c)) {
			if (c->item == 0) {
				wait->remove(c);
			}
			else {
				wait->resign(c);//重新调整
			}
		}
		//之前在获奖区
		else {
			if (c->item == 0) {
				winner->remove(c);
			}
			else {
				winner->resign(c);
			}
		}
		move(time);
	}
	void move(int time) {
		if (wait->getSize() == 0) {
			return;
		}
		if (winner->getSize() < k) {
			Customer* c = wait->top();
			wait->pop();
			c->time = time;
			winner->push(c);
		}
		else {
			if (wait->top()->item > winner->top()->item) {
				Customer* wi = winner->top();
				winner->pop();
				Customer* wa = wait->top();
				wait->pop();
				wi->time = time;
				wa->time = time;
				winner->push(wa);
				wait->push(wi);
			}
		}
	}
	list<int> getList() {//返回获奖用户的id
		list<int>re;
		list<Customer*>origin = winner->returnList();
		for (auto it = origin.begin(); it != origin.end(); ++it) {
			re.push_back((*it)->id);
		}
		return re;
	}
	

};
list<list<int>> topK2(vector<int>& arr, vector<bool>& op, int k) {
	list<list<int>>re;
	ReturnWinner* returnWinner = new ReturnWinner(k);
	for (int i = 0; i < arr.size(); ++i) {
		returnWinner->operate(i, arr[i], op[i]);//一次交易
		re.push_back(returnWinner->getList());
	}
	return re;
}

完整可测试的代码

#include<iostream>
#include<cstdlib>
#include<ctime>
#include<vector> 
#include<unordered_map>
#include<list>
#include<algorithm>
#include"Heap.h"
using namespace std;
class Customer {
public:
	int id;
	int item;
	int time;
	Customer(int id) :id(id) {
		item = 0;
		time = 0;
	}
	Customer(Customer* c) {
		id = c->id;
		item = c->item;
		time = c->item;
	}
};
bool count(list<Customer*>& v, Customer* c) {//查找list是否有c
	for (auto it = v.begin(); it != v.end(); ++it) {
		if ((*it) == c) {
			return true;
		}
	}
	return false;
}
bool winnerCom(Customer* a, Customer* b) {
	if (a->item < b->item) {
		return true;
	}
	else if (a->item == b->item && a->time < b->time) {
		return true;
	}
	else {
		return false;
	}
}
bool waitCom(Customer* a, Customer* b) {
	if (a->item > b->item) {
		return true;
	}
	else if (a->item == b->item && a->time < b->time) {
		return true;
	}
	else {
		return false;
	}
}
void clearZero(list<Customer*>& s) {//清楚s中item为0的元素
	auto it = s.begin();
	while (it != s.end()) {
		auto im = it;
		++it;
		if ((*im)->item == 0) {
			s.erase(im);
		}
	}
	
}
void move(list<Customer*>& winner, list<Customer*>& wait, int k, int i) {//调整获奖区和候选区
	if (wait.empty()) {
		return;
	}
	if (winner.size() < k) {//得奖区不足k个 
		Customer* c = wait.front();
		wait.pop_front();
		c->time = i;
		winner.push_back(c);
	}
	else {
		if (wait.front()->item > winner.front()->item) {
			Customer* wa = wait.front();
			wait.pop_front();
			Customer* wi = winner.front();
			winner.pop_front();
			wa->time = i;
			wi->time = i;
			wait.push_back(wi);
			winner.push_back(wa);
		}
	}
}
void putRe(list<list<int>>& re, list<Customer*>& winner) {//将winner中用户的id加入re
	list<int>ans;
	for (auto it = winner.begin(); it != winner.end(); ++it) {
		
		Customer* lc = new Customer(*it);
		ans.push_back(lc->id);
	}
	re.push_back(ans);
}
//暴力模拟
list<list<int>> topK(vector<int>& arr, vector<bool>& op, int k) {
	unordered_map<int, Customer*>customers;//客户的id 
	list<Customer*> winner;//得奖区 	
	list<list<int>>re;
	list<Customer*> wait;//候选区 
	for (int i = 0; i< arr.size(); ++i) {

		int id = arr[i];
		bool buyOrRefund = op[i];
		if (!buyOrRefund && !customers.count(id)) {//用户退货，并且之前未购买过 

			putRe(re, winner);
			continue;
		}
		/*
		接下来分以下几种情况：
		1. 用户之前没有购买，此时买货
		2. 用户之前购买数>0,此时买货
		3. 用户之前购买数>0,此时退货
		*/
		if (!customers.count(id)) {
			Customer* customer = new Customer(id);
			customers.emplace(id, customer);
		}
		Customer* c = customers[id];
		if (buyOrRefund) {
			++c->item;
		}
		else {
			--c->item;
		}
		if (c->item == 0) {
			customers.erase(customers.find(id));
		}
		//用户购买数大于0，并且此时买货 
		if (!count(winner, c) && !count(wait, c)) {
			if (winner.size() < k) {
				c->time = i;
				winner.insert(winner.end(), c);
			}
			else {
				c->time = i;
				wait.insert(wait.end(), c);
			}
		}
		//删除购买数为0的用户 
		clearZero(winner);
		clearZero(wait);
		winner.sort(winnerCom);
		wait.sort(waitCom);
		move(winner, wait, k, i);
		putRe(re, winner);
	}
	return re;
}
//自动生成数组
void geneArr(vector<int>& arr, vector<bool>& op, int num) {
	srand((unsigned int)time(0));
	arr.resize(num);
	op.resize(num);
	for (int j = 0; j < num; ++j) {
		int val = rand() % 5 + 1;

		arr[j] = val;
		if ((j & 1) == 0) {
			op[j] = true;
		}
		else {
			op[j] = false;
		}
	}
}

//方法2 加强堆
class ReturnWinner {
private:
	unordered_map<int, Customer*>customers;
	Heap<Customer*>* winner;
	Heap<Customer*>* wait;
	int k;
	int* a;
public:
	ReturnWinner(int k) :k(k) {
		winner = new Heap<Customer*>(winnerCom);
		wait = new Heap<Customer*>(waitCom);
		a = new int[10];
	}
	void operate(int time, int id, bool buyOrRefund) {
		if (!buyOrRefund && !customers.count(id)) {
			return;
		}
		//第一次购买
		if (!customers.count(id)) {
			Customer* c = new Customer(id);
			customers.emplace(id, c);
		}
		Customer* c = customers[id];
		if (buyOrRefund) {
			c->item++;
		}
		else {
			c->item-- ;
		}
		if (c->item == 0) {
			customers.erase(id);
		}
		//第一次购买
		if (!winner->contain(c) && !wait->contain(c)) {
			if (winner->getSize() < k) {
				c->time = time;
				winner->push(c);
			}
			else {
				c->time = time;
				wait->push(c);
			}
		}
		//之前在候选区
		else if (wait->contain(c)) {
			if (c->item == 0) {
				wait->remove(c);
			}
			else {
				wait->resign(c);//重新调整
			}
		}
		//之前在获奖区
		else {
			if (c->item == 0) {
				winner->remove(c);
			}
			else {
				winner->resign(c);
			}
		}
		move(time);
	}
	void move(int time) {
		if (wait->getSize() == 0) {
			return;
		}
		if (winner->getSize() < k) {
			Customer* c = wait->top();
			wait->pop();
			c->time = time;
			winner->push(c);
		}
		else {
			if (wait->top()->item > winner->top()->item) {
				Customer* wi = winner->top();
				winner->pop();
				Customer* wa = wait->top();
				wait->pop();
				wi->time = time;
				wa->time = time;
				winner->push(wa);
				wait->push(wi);
			}
		}
	}
	list<int> getList() {//返回获奖用户的id
		list<int>re;
		list<Customer*>origin = winner->returnList();
		for (auto it = origin.begin(); it != origin.end(); ++it) {
			re.push_back((*it)->id);
		}
		return re;
	}
	

};
list<list<int>> topK2(vector<int>& arr, vector<bool>& op, int k) {
	list<list<int>>re;
	ReturnWinner* returnWinner = new ReturnWinner(k);
	for (int i = 0; i < arr.size(); ++i) {
		returnWinner->operate(i, arr[i], op[i]);//一次交易
		re.push_back(returnWinner->getList());
	}
	return re;
}
bool cmp(list<int>& re1,list<int>& re2) {
	re1.sort();
	re2.sort();
	auto it1 = re1.begin();
	auto it2 = re2.begin();
	while (it1 != re1.end() && it2!=re2.end()) {
		if ((*it1) != (*it2)) {
			return false;
		}
		++it1;
		++it2;
	}
	return true;


}
int main() {
	int testTime = 100;
	//比较器
	for (int i = 0; i < testTime; ++i) {
		vector<int> arr;
		vector<bool> op;
		geneArr(arr, op, 60);
		list<list<int>>re1 = topK(arr, op, 3);
		list<list<int>>re2 = topK2(arr, op, 3);
		auto it1 = re1.begin();
		auto it2 = re2.begin();
		while (it1 != re1.end() && it2 != re2.end()) {
			if (!cmp(*it1, *it2)) {
				cout << "error" << endl;
			}
			++it1;
			++it2;
		}
	}
	
	return 0;
}

progressiveFighting

关注

9
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
堆的基础学习

题目给定很多线段，每个线段都有两个数[start, end]，表示线段开始位置和结束位置，左右都是闭区间。规定:1)线段的开始和结束位置一定都是整数值2)线段重合区域的长度必须>=1返回线段最多重合区域中，包含了几条线段例：有三个线段，[1,2],[2,3],[1,3]，其中[1,2]和[1,3]重合或者[2,3]和[1,3]重合，所以返回2,但是[1,2]和[2,3]不重合(因为重合的长度是0)分析：解1 暴力方法先找出所有线段中开始位置的最小值minStart和结束位置的最大值
复制链接

扫一扫