当前位置：首页 > news >正文

STD::pair＜＞的使用

news 来源：原创 2024/5/16 5:02:04

pair的使用

#include<iostream>
#include<vector>
#include<string>
排序引入头文件：
#include<algorithm>
using namespace std;
说明：comp2:对的第一个成员排序（升序）
bool/int comp2(pair<int,int>&a,pair<int,int>&b)
{
	return a.first < b.first;
}
说明：comp1:对的第一个成员排序（降序）
bool/int comp1(pair<int,int>&a,pair<int,int>&b)
{
	return a.first >b.first;
}
说明：comp3:对的第二个成员排序
bool/int comp3(pair<int, int>& a, pair<int, int>& b)
{
	return a.second < b.second;
}
int main()
{
	初始化数据：
	vector<pair<int, int>>tmp = { {1,2},{4,9},{3,7} };
	vector<pair<int, int>>tmp1;
	插入数据方式：
	tmp1.push_back(pair<int, int>(11, 6));
	tmp1.push_back(pair<int, int>(6, 5));
	tmp1.push_back(pair<int, int>(2, 3));
	sort(tmp1.begin(), tmp1.end(), comp1);
	for (int i = 0; i < tmp.size(); i++)
	{ 
	cout << tmp1[i].first<<" "<<tmp1[i].second << endl;
	}
	return 0;

说明：comp:对的第一个成员排序（降序）

tmp1.push_back(pair<int, int>(1, 6));
tmp1.push_back(pair<int, int>(6, 5));
tmp1.push_back(pair<int, int>(2, 3));

bool/int comp(pair<int,int>&a,pair<int,int>&b)
{
	return a.first >b.first;
}`

在这里插入图片描述

例题：射击气球

2.射击气球已知在一个平面上有一定数量的气球，平面可以看做一个坐标系，在平面的X轴的不同位置安排弓箭手向Y轴方向射箭，弓箭可以向y轴走无穷远，给定气球的宽度xstart<=x<=xend，问至少需要多少弓箭手，将全部气球打爆？
例如：四个气球，[[10,16],[2,8],[1,6],[7,12]],至少需要2个弓箭手。

/*
贪心规律：
1.对于一个气球，至少需要一个弓箭将它射击
2.在射击当前气球的同时，贪心的尽可能多的射击其他的气球—贪心
算法思想：
1.先对各个气球的区间，以起始点进行从小到大进行排序
2.遍历气球数组，同时要维护一个射击范围，在满足可以射击当前气球的同时，尽可能多的射击下一个气球，每次
射击一个气球，就要更新一次新的射击范围(保证新的范围可以射击新的气球)
3.如果当前的范围没有办法射击新的气球的，那么就要增加一个弓箭手，还要重新维护一个射击范围。
*/

#include<vector>
#include<algorithm>
#if 0
int mycmp(pair<int,int> &a,pair<int,int>&b)
{
	return a.first < b.first;
}
void main()
{
	vector<pair<int,int> > arr;
	arr.push_back(pair<int,int>(10,16));
	arr.push_back(pair<int,int>(2,8));
	arr.push_back(pair<int,int>(1,6));
	arr.push_back(pair<int,int>(7,12));
	arr.push_back(pair<int,int>(13,15));
	//1 排序
	sort(arr.begin(),arr.end(),mycmp); //按照气球的起始区间进行排序
	//射击范围

int shoot_begin = arr[0].first;
	int shoot_end = arr[0].second;
	int shoot_num = 1; //弓箭手个数
	for(int i = 1;i<arr.size();++i)
	{
		//看下一个气球的区间是否在当前范围，并更新射击范围
		if(arr[i].first <= shoot_end)
		{
			shoot_begin = arr[i].first;
			if(shoot_end > arr[i].second)
			{
				shoot_end = arr[i].second;
			}
		}
		else
		{
			//当前要射击的气球的起始区间>射击范围，增加弓箭手，并且将当前气球的区间作为新的射击范围
			shoot_num++;
			shoot_begin = arr[i].first;
			shoot_end = arr[i].second;
		}
	}
	cout<<"需要弓箭手个数为 : "<<shoot_num<<endl;
}

#endif

/*
1.最简单：有1元，5元，10元，20元，100元，200元的钞票无穷多张，现使用这些钞票支付X元，最少需要多少张？
例如：X = 628
2.射击气球
已知在一个平面上有一定数量的气球，平面可以看做一个坐标系，在平面的X轴的不同位置安排弓箭手向Y轴方向射箭，
弓箭可以向y轴走无穷远，给定气球的宽度xstart<=x<=xend，问至少需要多少弓箭手，将全部气球打爆？
例如：四个气球，[[10,16],[2,8],[1,6],[7,12]],至少需要2个弓箭手。
3.已知一些孩子和一些糖果，每个孩子有需求因子g，每个糖果有大小s，当某个糖果的大小s>=某个孩子的需求因子g时，
代表该糖果可以满足该孩子，求使用这些糖果，最多能满足多少孩子（注意，某个孩子最多只能用1个糖果满足）
例如：需求因子数组g={5,10,2,9,15,9};糖果大小数组s={6,1,20,3,8}；最多可以满足3个孩子。
4.移除k个数字
已知一个使用字符串表示的非负整数num，将num中的k个数字移除，求移除k个数字后，可以获得的最小的可能
的新数字(nun不会以0开头，num长度小于10002)
输入：num=“1432219”,k=3,在去掉3个数字后得到的很多很多里，如1432,4322,2219,1219,1229等，
去掉数字4,3,2得到的1219最小。

分析：要让得到数字最小，需要尽可能让得到数字的最高位最小，次高位最小…----最优的
贪心：从高位开始向低位遍历，如果对应的数字大于下一位数字，那么就将该位数字去掉，贪心的保留小的，去掉大
12345 k=3
100300 k=1

/
/
贪心—遵循某种规律，不断贪心的选择当前最优策略的方法
*/
#include
using namespace std;

/*
贪心—贪心的使用面额较大的钞票,以达到最优解
原因：较大的面额是较小面额的倍数关系，当能用一张较大的面额来实现，如果用较小的面额来替换，则一定需要
更多的张数
600–200+200+200 —>3
600–100+100+100+100+100+100–>6
…
找零钱不一定都能用贪心----
如果面值没有规律(不是倍数关系)，则贪心不成立
*/
#if 0
void main()
{
int money[] = {200,100,20,10,5,1}; //面额
int n = sizeof(money)/sizeof(money[0]);
int num = 628;
int count = 0;
int j = 0;
for(int i = 0;i<n;++i)
{
j = num / money[i];
count += j;
num = num - money[i] * j;
if(j != 0)
cout<<“需要”<<j<<“张”<<money[i]<<endl;
}
cout<<“最少需要张数为：”<<count<<endl;
}
#endif

思想：
1.排序–从小到大排序
需求因子更小的更容易满足，从需求因子小的尝试，可以得到更多的结果(目标是为了让更多的孩子满足)
2.如果该糖果不能满足该孩子，则该糖果也一定不能满足它后面的孩子(需求因子更大的孩子)
糖果1不能满足需求因子2，那么一定不能满足2后面的孩子
3.如果孩子可以用更小的糖果来满足，则没有必要用更大的糖果满足，贪心的将更大的糖果保留满足需求
因子更大的孩子

代码：
1.排序
2.按照从小到大的顺序使用各个糖果尝试是否可以满足某个孩子，每个糖果只尝试一次，当尝试成功时，就可以换下一个
孩子来尝试，直到没有更多的糖果或者孩子，则结束
*/
#if 0
void main()
{
int g[] = {5,10,2,9,15,9};
int s[] = {6,1,20,3,8};
int n = sizeof(g)/sizeof(g[0]);
int m = sizeof(s)/sizeof(s[0]);
sort(g,g+n);
sort(s,s+m);
int childnum = 0;
int cookienum = 0;
while(cookienum < m && childnum < n)
{
if(g[childnum] <= s[cookienum])
{
childnum++;
}
cookienum++;
}
cout<<"childnum = "<<childnum<<endl;
}
#endif