功能简单的优先级队列 堆实现 SCU 3369 SCU 3365

最新推荐文章于 2022-06-14 22:24:25 发布
最新推荐文章于 2022-06-14 22:24:25 发布
阅读量208 收藏
点赞数
分类专栏： 数据结构 学习 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nishisiyuetian/article/details/79275607
版权

最近写 Prim 和 Disjkstra ， 顺便复习一下堆和优先级队列的知识 ：

#include <bits/stdc++.h>
using namespace std ;
#define Init_Data 0     // 设置初始数据
typedef int Data_type ; // 数据类型, 在本程序只是单一类型

class My_Priority_queue{// 优先级队列默认为小顶堆
private:
	int Max_size ;      // 优先级队列的最大容量
	int n ;             // 优先级队列当前的元素个数
	Data_type *a ;      // 数据指针, 顺序表
public:
	My_Priority_queue() ;              // 构造函数
	~My_Priority_queue() ;             // 析构函数
	void push( Data_type weight ) ;    // 往优先级队列中 push 数据
	void pop() ;                       // pop 堆顶
	Data_type top() ;                  // 访问栈顶元素
	bool empty() ;                     // 判断堆是否为空
	int size() ;                       // 堆大小
	void Shift_down( int u ) ;         // 递归   堆向下调整
	void Shift_down_2( int u ) ;       // 非递归 堆向下调整
} ;

My_Priority_queue::My_Priority_queue(){
	n = 0 ;
	Max_size = 256 ;
	a = new Data_type[Max_size] ;
	if( a ){
		for( int i = 0 ; i < Max_size ; ++i ) // 初始化
		    a[i] = Init_Data ;
	    cout << endl << "优先级队列初始化准备完毕 " << endl ;
	}
	else  
		cout << endl << "内存分配失败 !" << endl ;
}

My_Priority_queue::~My_Priority_queue(){
	if( a ) 
	    delete a , a = NULL ;         // 队列分配了空间 , 释放掉
	cout << endl << "优先级队列的内存已释放完毕 " << endl ;
}

void My_Priority_queue::push( Data_type weight ){
	if( n+1 > Max_size ){
		cout << endl << "优先级队列重新分配空间" << endl ;
		int cur = Max_size ;
		Max_size += cur ;
		Data_type *temp = new Data_type[Max_size] ;
		for( int i = 0 ; i < Max_size ; ++i )
			temp[i] = Init_Data ;
		for( int i = 1 ; i <= cur ; ++i )    // 保存原始数据
			temp[i] = a[i] ;
		delete a , a = NULL ;
		a = temp ;
		temp = NULL ;
		cout << endl << "优先级队列已重新就绪" << endl ;
	}
	a[++n] = weight ;                    // push 压入的新元素放在末尾
	int parent = n >> 1 , i = n ;        // 因为前面的都是小顶堆
	while( parent ){               
		if( a[i] < a[parent] ) 
			swap( a[i] , a[parent] ) ;
		i = parent ;
		parent /= 2 ;                    // 从下向上调整, 只要和父亲相比
	}
}

void My_Priority_queue::pop(){
	if( empty() ){
		cout << "It's empty !" << endl ;
		return ;
	}
	swap( a[1] , a[n--] ) ;             // 把最后一个元素交换到堆顶, 堆大小 -1
	Shift_down_2( 1 ) ;                 // 从堆顶开始向下调整
}
 
Data_type My_Priority_queue::top(){     // 取堆顶元素 , 优先级队列中最小的元素
	return a[1] ;
}

bool My_Priority_queue::empty(){        // 判断优先级队列 ( 堆 ) 是否为空
	return n < 1 ;
}

int My_Priority_queue::size(){         // 取优先级队列元素个数
	return n ;
}

void My_Priority_queue::Shift_down( int u ){         // 递归
	int ans = u ;
	if( 2*u <= n && a[2*u] < a[ans] )            // 比较左孩子
		ans = 2*u ;
	if( 2*u+1 <= n && a[2*u+1] < a[ans] )        // 比较右孩子
		ans = 2*u+1 ;
	if( ans != u )                               // 最小的元素 a[ans] 在两个孩子当中
		swap( a[ans] , a[u] ) , Shift_down( ans ) ; // 交换 , 继续向下调整
}

void My_Priority_queue::Shift_down_2( int u ){          // 非递归
	int i = 2*u ;
	for( ; i <= n ; i = 2*u ){                      // 每次交换之后, i 都恢复为 2*u , 这时候的 u 不是原来的 u
		if( i+1 <= n && a[i+1] < a[i] )         // 比较右孩子
			++i ;
		if( a[i] >= a[u] ) return ;             // 如果最小的元素就是自己, 不在孩子当中
		swap( a[i] , a[u] ) ;
		u = i ;                                 // 交换最小的元素 , 更大的继续向下调整
	}
}

int main(){
	My_Priority_queue One ;
	Data_type weight ;
	int n = 600 ;
	srand( time( NULL ) ) ;
	for( int i = 1 ; i <= n ; ++i ){
		weight = rand() % 100 + 1 ; 
		One.push( weight ) ;
	}
	while( !One.empty() ){
		cout << One.top() << "  " ; 
		One.pop() ;
	}
	cout << endl ;
	return 0 ;
}

 SCU 3369 自主编写最小堆  Prim

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std ;
#define INF 0x3f3f3f
typedef pair<int,int> P ;
int n , m , i , u , v , w ;
vector<P> One[10050] ;
int dis[10050] , C[10050] , book[10050] ;
struct Pair{
	int dis , u ;
	Pair(){}
	Pair( int _dis , int _u ){
		dis = _dis , u = _u ;
	}
} ;

class My_Priority_queue{// 优先级队列默认为小顶堆
private:
	int n ;             // 优先级队列当前的元素个数
	int Max_size ;
	Pair **a ;      // 数据指针, 顺序表
public:
	My_Priority_queue( int _Max_size ) ;              // 构造函数
	~My_Priority_queue() ;             // 析构函数
	void push( Pair *weight ) ;    // 往优先级队列中 push 数据
	void pop() ;                       // pop 栈顶
	Pair *top() ;                  // 访问栈顶元素
	bool empty() ;                     // 判断栈是否为空
	void Shift_down( int u ) ;         // 递归   堆向下调整
} ;

My_Priority_queue::My_Priority_queue( int _Max_size ){
	n = 0 ;
	Max_size = _Max_size ;
	a = new Pair*[3*Max_size] ;
	for( int i = 0 ; i < 3*Max_size ; ++i )
		a[i] = NULL ;
}

My_Priority_queue::~My_Priority_queue(){
	for( int i = 0 ; i < 3*Max_size ; ++i )
		a[i] = NULL ;
	if( a ) delete []  a ;
}

void My_Priority_queue::push( Pair *weight ){
	a[++n] = weight ;                    // push 压入的新元素放在末尾
	int parent = n >> 1 , k = n ;        // 因为前面的都是小顶堆
	while( parent ){               
		if( a[k]->dis < a[parent]->dis ) 
			swap( a[k] , a[parent] ) ;
		k = parent ;
		parent /= 2 ;                    // 从下向上调整, 只要和父亲相比
	}
}

void My_Priority_queue::pop(){
	if( empty() )  return ;
	swap( a[1] , a[n--] ) ;             // 把最后一个元素交换到堆顶, 堆大小 -1
	Shift_down( 1 ) ;                 // 从堆顶开始向下调整
}
 
Pair *My_Priority_queue::top(){     // 取堆顶元素 , 优先级队列中最小的元素
	return a[1] ;
}

bool My_Priority_queue::empty(){        // 判断优先级队列 ( 堆 ) 是否为空
	return n < 1 ;
}

void My_Priority_queue::Shift_down( int u ){
	int ans = u ;
	if( 2*u <= n && a[2*u]->dis < a[ans]->dis )            // 比较左孩子
		ans = 2*u ;
	if( 2*u+1 <= n && a[2*u+1]->dis < a[ans]->dis )        // 比较右孩子
		ans = 2*u+1 ;
	if( ans != u )                               // 最小的元素 a[ans] 在两个孩子当中
		swap( a[ans] , a[u] ) , Shift_down( ans ) ; // 交换 , 继续向下调整
}

void Prim(){
	memset( dis , INF , sizeof( dis ) ) ;
	memset( book , 0 , sizeof( book ) ) ;
	int ans = 0 , u , v , w ;
	My_Priority_queue Q( n ) ;
	Pair *cur = new Pair( dis[1] = 0 , 1 ) ;
	Q.push( cur ) ;
	while( !Q.empty() ){
		Pair *top = Q.top() ;
		Q.pop() ;
		u = top->u ;
		if( book[u] )
			continue ;
		book[u] = 1 ;
		ans += top->dis ;
		for( i = 0 ; i < (int)One[u].size() ; ++i ){
			v = One[u][i].first , w = One[u][i].second ;
			if( !book[v] && dis[v] > w ){
				Pair *t = new Pair( dis[v] = w , v ) ; 
				Q.push( t ) ;
			}
		}
	}
	printf( "%d\n" , ans+*min_element( C+1 , C+n+1 ) ) ;
}

int main(){
	while( ~scanf( "%d%d" , &n , &m ) ){
		for( i = 1 ; i <= n ; ++i )
			scanf( "%d" , &C[i] ) , One[i].clear() ;
		for( i = 1 ; i <= m ; ++i ){
			scanf( "%d%d%d" , &u , &v , &w ) ;
			w = 2*w + C[u] + C[v] ;
			One[u].push_back( P( v , w ) ) ;
			One[v].push_back( P( u , w ) ) ;
		}
		Prim() ;
	}
	return 0 ;
}

 SCU 3365 Disjkstra  ( LCA 被我用 Disjkstra 做了, haha )

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std ;
#define INF 0x3f3f3f
typedef pair<int,int> P ;
int N , Q ;
vector<P> One[1001] ;
int dp[1001][1001] ;
int dis[1001] ;

struct Pair{
	int dis , u ;
	Pair(){}
	Pair( int _dis , int _u ){
		dis = _dis , u = _u ;
	}
} ;

class My_Priority_queue{// 优先级队列默认为小顶堆
private:
	int n ;             // 优先级队列当前的元素个数
	int Max_size ;
	Pair **a ;      // 数据指针, 顺序表
public:
	My_Priority_queue( int _Max_size ) ;              // 构造函数
	~My_Priority_queue() ;             // 析构函数
	void push( Pair *weight ) ;    // 往优先级队列中 push 数据
	void pop() ;                       // pop 栈顶
	Pair *top() ;                  // 访问栈顶元素
	bool empty() ;                     // 判断栈是否为空
	void Shift_down( int u ) ;         // 递归   堆向下调整
} ;

My_Priority_queue::My_Priority_queue( int _Max_size ){
	n = 0 ;
	Max_size = _Max_size ;
	a = new Pair*[3*Max_size] ;
	for( int i = 0 ; i < 3*Max_size ; ++i )
		a[i] = NULL ;
}

My_Priority_queue::~My_Priority_queue(){
	for( int i = 0 ; i < 3*Max_size ; ++i )
		a[i] = NULL ;
	if( a ) delete []  a ;
}

void My_Priority_queue::push( Pair *weight ){
	a[++n] = weight ;                    // push 压入的新元素放在末尾
	int parent = n >> 1 , k = n ;        // 因为前面的都是小顶堆
	while( parent ){               
		if( a[k]->dis < a[parent]->dis ) 
			swap( a[k] , a[parent] ) ;
		k = parent ;
		parent /= 2 ;                    // 从下向上调整, 只要和父亲相比
	}
}

void My_Priority_queue::pop(){
	if( empty() )  return ;
	swap( a[1] , a[n--] ) ;             // 把最后一个元素交换到堆顶, 堆大小 -1
	Shift_down( 1 ) ;                 // 从堆顶开始向下调整
}
 
Pair *My_Priority_queue::top(){     // 取堆顶元素 , 优先级队列中最小的元素
	return a[1] ;
}

bool My_Priority_queue::empty(){        // 判断优先级队列 ( 堆 ) 是否为空
	return n < 1 ;
}

void My_Priority_queue::Shift_down( int u ){
	int ans = u ;
	if( 2*u <= n && a[2*u]->dis < a[ans]->dis )            // 比较左孩子
		ans = 2*u ;
	if( 2*u+1 <= n && a[2*u+1]->dis < a[ans]->dis )        // 比较右孩子
		ans = 2*u+1 ;
	if( ans != u )                               // 最小的元素 a[ans] 在两个孩子当中
		swap( a[ans] , a[u] ) , Shift_down( ans ) ; // 交换 , 继续向下调整
}


int Dijkstra( int src , int des ){
	int i , u , v , w ;
	memset( dis , INF , sizeof( dis ) ) ;
	My_Priority_queue Q( N ) ;
	Pair *cur = new Pair( dis[src] = 0 , src ) ;
	Q.push( cur ) ;
	while( !Q.empty() ){
		Pair *top = Q.top() ;
		Q.pop() ;
		u = top->u ;
		if( dis[u] < top->dis ) 
			continue ;
		for( i = 0 ; i < (int)One[u].size() ; ++i ){
			v = One[u][i].first , w = One[u][i].second ;
			if( dis[v] > dis[u] + w ){
				Pair *t = new Pair( dis[v] = dis[u] + w , v ) ; 
				Q.push( t ) ;
			}
		}
	}
	for( i = 1 ; i <= N ; ++i )
		dp[src][i] = dp[i][src] = dis[i] ;
	return dis[des] ;
}

int main(){
	int i , u , v , w ;
	while( ~scanf( "%d%d" , &N , &Q ) ){
		for( i = 1 ; i <= N ; ++i )
			One[i].clear() ;
		for( i = 1 ; i <= N-1 ; ++i ){
			scanf( "%d%d%d" , &u , &v , &w ) ;
			One[u].push_back( P( v , w ) ) ;
			One[v].push_back( P( u , w ) ) ;
		}
		memset( dp , 0 , sizeof( dp ) ) ;
		while( Q-- ){
			scanf( "%d%d" , &u , &v ) ;
			printf( "%d\n" , dp[u][v] ? dp[u][v] : Dijkstra( u , v ) ) ;
		}
	}
	return 0 ;
}




胆识与智慧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
scu 优先队列
loooooog的博客
07-29 379
Description 　　Sidney想去Gandtom家玩。但Sidney家和Gandtom家之间是高低不平、坑坑洼洼的土路。所以他需要用他的背包装几袋稀的泥，在路上铺平一些干的土，使路变成平整的泥土，才能到Gandtom家见到Gandtom。 　　已知现在有n袋稀的泥，第i袋稀的泥的质量为wi。初始时，第i个分组只有第i袋稀的泥。接下来Sidney每一次会把质量最小（如果质量相同取编号...
CJ1W-SCU模块协议宏做Modbus-RTU主站
08-17
本资源总结了使用OMRON的CJ1W-SCU模块通过协议宏功能，实现Modbus-RTU主站与变频器的通讯控制。该资源详细介绍了硬件搭建和接线、软件操作步骤、协议宏配置等方面的知识点。 一、硬件搭建和接线 * CJ1W-SCU41-V1...
SCU 3369 Cheering up the Cows 最小生成树的遍历
Fluence_YHL
02-06 304
题目描述:Time Limit:3000ms Memory Limit:65536KBDescription Farmer John has grown so lazy that he no longer wants to continuemaintaining the cow paths that currently provide a way to visiteach of his N ...
SCU3139——Sliding Window【单调队列or线段树】
C++的星空
07-29 160
Time Limit: 3000 MS Memory Limit: 65536 K Description An array of size n ≤ 10^6 is given to you. There is a sliding window of size k which is moving from the very left of the array to the very righ...
SCU操作系统复习
Kirito_UGO的博客
06-14 469
操作系统期末复习
SCU - 3968 Mowing the Lawn （单调队列优化 DP）
兜率工的博客
08-23 429
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=1e5+10; ll e[maxn]; ll que[maxn]; ll dp[maxn]; ll sum[maxn]; int main(){ int n,k; while(scanf...
PriorityQueue优先队列——堆结构的优秀实现类
xzp_12345的博客
06-27 272
最近在牛客网上做题时，遇到求中位数。看到使用到了优先队列PriorityQueue类，于是就在网上查阅了一些资料。PriorityQueue是Java.util包中的一个类，它逻辑上是使用堆结构（完全二叉树）实现，物理上使用动态数组实现。并不是像TreeMap一样完全有序，堆不是完全有序的（由堆的结构决定的）。接下来我们就通过分析堆的实现原理和PriorityQueue类源码来分析。以下是涉及的主...
SCU-3968 Mowing the Lawn（DP+单调队列）
Paulliant的博客
07-23 222
题意 有 nnn 个非负整数，选若干个数保证连续的数不超过 kkk 个，求选的数总和最大是多少。 1≤n≤1000001≤n≤1000001 \leq n \leq 100000 思路 为了方便考虑问题，我们把题干转化为选若干个数，且间隔的数不超过 kkk个，求选的数总和最小是多少。 设 dpidpidp_i 为最后一个选的数为 iii 时的最小总和，按照题设不难列出方程： dpi=m...
SCU 4110 / POJ 3687 反向拓扑排序 + 优先队列
03-29 491
题目链接： SCU 4110 POJ 3687 分析：拓扑排序，注意根据题的要求，要先保证1号球最轻，如果我们由轻的向重的连边，然后我们依次有小到大每次把重量分给一个入度为0的点，那么在拓扑时我们面对多个入度为0的点，我们不知道该把最轻的分给谁才能以最快的速度找到1号（使1号入度为0），并把当前最轻的分给1号。所以我们要由重的向轻的连边，然后从大到小每次把一个重量分给一个入度为0
SCU.zip_scu_scu底层
09-14
仿真机器人底层平台的一些基本函数以及已经写好的底层
FT3DR写频线SCU19的DIY.doc
03-16
FT2DR FT3DR的写频线DIY，用于连接电脑，写频和修改配置。原厂写频线型号是SCU-19，这个DIY的写频线可以用电脑的RS232串口，也可以通过RS232转USB的转接线使用。
CJ1W-SCU模块协议宏做上载，下载,数据收集
最新发布
08-17
本文档主要介绍了 OMRON 的 CJ1W-SCU 模块协议宏的上载、下载和数据收集操作，使用 CX-Protocol 软件和 CP1H-XA40DT-D PLC 实现数据交换。 一、系统概述和硬件设置 本案例使用 CJ1W-SCU41-V1 模块的 485 口连接至 ...
SCU-19_PC_Connection_Cable_Driver.zip
02-17
八重洲ft1dr，2dr,3dr数据线SCU-19驱动程序。SCU-19_PC_Connection_Cable_Driver.zip
设计模式(3) 策略模式 初步实现多种登陆策略
Fluence_YHL
05-12 2802
现在我要实现教师，学生，管理员不同登录方式的系统 设计思路 一个抽象策略类，由多种登录策略继承 一个登录系统，内含一种策略作为参数 可以更改策略 未解决的问题 暂不支持多用户，因为只允许一时间一种策略 抽象策略类 class Strategy { public: virtual void Login () = 0 ; ...
C++ 学习笔记（3） const_cast
Fluence_YHL
03-30 2112
const_cast C++的四种类型转换关键字之一, const_cast , static_cast , dynamic_cast, reinterpret_cast 。 可以去除一个 const 变量的 const 属性。 很容易理解错的一个例子： #include using namespace std ; int main () { const int data = 100
设计模式(2) 工厂模式 ( 一 ) 学生成绩管理系统设计
Fluence_YHL
05-11 1687
最近在做课程设计——学生成绩管理系统角色有：老师，学生，课程老师，学生，课程都继承同一个接口 Entity我采用工厂模式，一个接口工厂，三种不同的工厂，每种工厂分别产老师，学生和课程通过工厂把产生的不同种类的 Entity 收集起来，由接口的工厂统一释放内存。以下是程序分块：Entity 实体定义：class Entity { protected: int NO ; public: strin...
机器学习 决策树 ID3 算法 C++ 实现
Fluence_YHL
10-20 1595
最近学习了 ＱＴ 下如何做一个 QQ, 以及学的课程（机器学习，机器智能，模式识别），愈发感到了数学的重要性． 在偏工程和偏算法两者之间抉择．．．．．． 今天，用 C++ 实现了决策树中的 ID3 算法．快一年不写递归了，这次还是复习了不少东西． 代码如下：希望日后有时间写个总结，最近一个月学习了不少 C++ 的东西，全放在 github了 #include &lt;iostream&gt...
C++ -学习笔记（15）SFINAE 匹配失败并不是错误
Fluence_YHL
08-13 1390
SFINAE 意为“匹配失败并不是错误”。 常用于编译期间，模板参数类型的判断和查找——会遍历查找所有可能匹配的参数类型，如果找不到，就编译失败。 C++11 中的 type traits 库中大量运用了 SFINAE。例如 is_class, is_pointer, is_member_function_pointer, is_const 等。对类型的 SFINAE 主要通过在类内部定义的 ...
dicom scu 模拟
07-25
模拟DICOM SCU主要通过以下步骤实现： 1. 配置模拟SCU设备的参数：包括设备的IP地址、端口号、传输协议等。这些参数需要与要模拟的DICOM设备相匹配。 2. 创建DICOM消息：模拟SCU设备需要根据具体的需求和场景，创建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值