算法笔记之蓝桥杯pat系统备考（2）

news2024/9/25 1:13:27

算法笔记之蓝桥杯&pat系统备考（1）

文章目录

  • 五、数学问题
    • 5.2最大公约数和最小公倍数
      • 5.2.1最大公约数
      • 5.2.2最小公倍数
    • 5.3分数的四则运算
      • 5.3.1分数的表示与化简
      • 5.3.2分数的四则运算
      • 5.3.3分数的输出
    • 5.4素数（质数）
      • 5.4.1[素数的判断](https://blog.csdn.net/Moliay/article/details/132828386?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522170981514616800197021234%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=170981514616800197021234&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-132828386-null-null.nonecase&utm_term=%E7%B4%A0%E6%95%B0&spm=1018.2226.3001.4450)
      • 5.4.2素数表的获取
    • 5.5质因子分解
    • 5.6大整数运算
      • 5.6.1大整数的存储
      • 5.6.2大整数的四则运算
        • 高精度加法
        • 高精度减法
        • 高精度与低精度的乘法
        • 高精度与低精度的除法
  • 六、c++标准模板库（STL）
    • 6.1vector变长数组
      • vector定义
      • vector容器内元素的访问
        • 1.通过下标访问
        • 2.通过迭代器访问
      • vector常用函数
      • vector常见用途
    • 6.2set（升序、去重）
      • set定义
      • set容器内元素的访问
      • set常用函数
      • set常见用途
    • 6.3string字符串
      • string定义
      • string中内容的访问
      • string常用函数
    • 6.4map键值对
      • map定义
      • map中内容的访问
      • map常见函数
      • map常见用途
    • 6.8pair
      • pair定义
      • pair中元素的访问
      • pair常用函数
      • pair常见用途
    • 6.9 algorithm头文件下的常用函数
      • 6.9.1 max(), min()和 abs()
      • 6.9.6sort()
        • sort()使用
        • 实现比较函数
          • （1）基本数据类型数组的排序
          • （2）结构体数组的排序
          • （3）容器的排序
      • 6.9.7 lower_bound() 大于等于 && upper_bound() 大于

五、数学问题

5.2最大公约数和最小公倍数

5.2.1最大公约数

  • 约数，又称因数：整数a除以整数b(b≠0) 除得的商正好是整数而没有余数，就说a能被b整除，或b能整除a。a称为b的倍数，b称为a的约数。
  • 正整数a与b的最大公约数：a和b的所有公约数中最大的那个公约数
#include<stdio.h>
int gcd(int a, int b){//求解最大公约数常用辗转相除法 
	if(b == 0) return a;
	return gcd(b, a % b);
}
int main(){
	int m, n;
	scanf("%d%d", &m, &n);
	printf("%d", gcd(m, n));
	return 0;
}

5.2.2最小公倍数

  • 正整数a和b的最小公倍数：a和b的所有公倍数中最小的那个公倍数

a和b的最小公倍数=ab/gcd(a, b)=a/(gcd(a,b))*b
即最小公倍数的计算在最大公约数的基础上进行。最小公倍数等于a和b的乘积除以a和b的最大公约数。其中ab在实际计算时可能会溢出，则进一步优化：先让其中之一除以最大公约数，再乘另一个数。

5.3分数的四则运算

分数的四则运算：给定两个分数的分子和分母，求它们加减乘除的结果。

5.3.1分数的表示与化简

假分数形式最简洁，用结构体来存储这种只有分子和分母的分数

  • 表示规范：
    • 分母down为非负数。若分数为负，则另分子up为负即可
    • 若分数为0，则分子up为0，分母down为1
    • 分子和分母没有除了1之外的公约数
struct Fraction{//分数
	int up, down;//分别表示分子、分母
}

为了满足上述的三个规范，可能需要化简来实现

  • 分数化简
    • 若分母down为负数，则另分子up和分母down都变为相反数（符号位在分子）
    • 若分子up为0，则林分母down为1
    • 约分：求出分子绝对值和分母绝对值的最大公约数d，再另分子分母同时除以最大公约数d
Fraction reduction(Fraction result){//化简分数 
	if(result.down < 0){//符号位在分子 
		result.down *= -1;
		result.up *= -1;
	}
	if(result.up == 0){//0约定为分子为0，分母为1 
		result.down = 1;
	} 
	else{//分子不为0，进行约分 
		int d = gcd(abs(result.down), abs(result.up));
		result.down /= d;
		result.up /= d;
	} 
	return result;
}

5.3.2分数的四则运算

在这里插入图片描述

Fraction add(Fraction a, Fraction b){//分数相加 
	Fraction c;
	c.down = a.down * b.down;
	c.up = a.up*b.down + b.up*a.down;
	return reduction(c);
} 

Fraction minu(Fraction a, Fraction b){//分数相加 
	Fraction c;
	c.down = a.down * b.down;
	c.up = a.up*b.down - b.up*a.down;
	return reduction(c);
} 

Fraction multi(Fraction a, Fraction b){//分数相乘 
	Fraction c;
	c.down = a.down * b.down;
	c.up = a.up * b.up;
	return reduction(c); 
}

//除法中注意，先判断除数是否为0：
//①除数为0，按照题目要求输出（例如error、inf等）
//②除数非0时，再进入下述函数
Fraction divide(Fraction a, Fraction b){//分数相除 
	Fraction c;
	c.down = a.down * b.up;
	c.up = a.up * b.down;
	return reduction(c);
}

5.3.3分数的输出

  • 注意：
    • 输出分数前，先对其进行化简
    • 若分数的分母为1，说明该分数为整数，一般来说题目会要求直接输出分子
    • 若分数r的分子up大于分母down，则为假分数。需要按带分数的形式输出，即整数部分为r.up / r.down,分子部分为abs(r.up) % r.down
    • 以上均不满足时，则为真分数，按原样输出即可
void showResult(Fraction f){//输出分数f 
	f = reduction(f);
	if(f.down == 1) printf("%lld", f.up);//若为整数，则直接输出分子
	else if(f.down < abs(f.up) printf("%d %d/%d", f.up/f.down, abs(f.up) % f.down, f.down);//若为假分数，则按带分数形式输出 
	else printf("%d/%d", f.up, f.down);//若为真分数，则直接原样输出 
}

简单应用

#include<stdio.h>
#include<math.h>
struct Fraction{//分数表示 
	int down, up;
};

int gcd(int a, int b){//求最大公约数 
	if(b == 0) return a;
	else return gcd(b, a%b);
}

Fraction reduction(Fraction f){//分数化简 
	if(f.down < 0){//若分母为负，则把负号调到分子上 
		f.down *= -1;
		f.up *= -1;
	}
	if(f.up == 0) f.down = 1;//0约定表示为分子为0，分母为1
	else{
		int d = gcd(abs(f.up), abs(f.down));
		f.up /= d;
		f.down /= d;
	} 
	return f;
}

Fraction add(Fraction a, Fraction b){//分数相加 
	Fraction c;
	c.down = a.down * b.down;
	c.up = a.up*b.down + b.up*a.down;
	return reduction(c);
} 

Fraction minu(Fraction a, Fraction b){//分数相加 
	Fraction c;
	c.down = a.down * b.down;
	c.up = a.up*b.down - b.up*a.down;
	return reduction(c);
} 

Fraction multi(Fraction a, Fraction b){//分数相乘 
	Fraction c;
	c.down = a.down * b.down;
	c.up = a.up * b.up;
	return reduction(c); 
}

Fraction divide(Fraction a, Fraction b){//分数相除 
	Fraction c;
	c.down = a.down * b.up;
	c.up = a.up * b.down;
	return reduction(c);
}

void showResult(Fraction f){//输出分数f 
	f = reduction(f);
	if(f.down == 1) printf("%lld", f.up);//若为整数，则直接输出分子
	else if(f.down < abs(f.up)) printf("%d %d/%d", f.up/f.down, abs(f.up) % f.down, f.down);//若为假分数，则按带分数形式输出 
	else printf("%d/%d", f.up, f.down);//若为真分数，则直接原样输出 
}

int main(){
	Fraction f1, f2;
	scanf("%d%d%d%d", &f1.up, &f1.down, &f2.up, &f2.down);
	showResult(f1);
	printf("\nf2 : ");
	showResult(f2);
	printf("\nf1 + f2 : ");
	showResult(add(f1, f2));
	printf("\nf1 - f2 : ");
	showResult(minu(f1, f2));
	printf("\nf1 * f2 : ");
	showResult(multi(f1, f2));
	printf("\nf1 / f2 : ");
	showResult(divide(f1, f2));
	return 0;
}

在这里插入图片描述

5.4素数（质数）

  • 素数（质数）：除了1和本身外，不能被其他数整除的数。换言之，对给定的正整数n，若对任意的正整数 a（1<a<n），都有n%a != 0成立，则a时素数
  • 合数：除了1和本身外，还存在至少一个能被整除的数。例如4，还能被2整除，则为合数
  • 1既不是素数，也不是合数

5.4.1素数的判断

5.4.2素数表的获取

素数筛法，时间复杂度O(nloglogn)

#include<iostream>
#include<vector>
using namespace std;
const int maxN = 101;
int main(){
	vector<int> primes(maxN, 1), p; 
	for(int i = 2; i < maxN; i++){//打印100以内的素数表 
		if(primes[i]){
			p.push_back(i);
			for(int j = i * i; j < maxN; j += i){
				primes[j] = 0;
			}
		}
	}
	for(int i = 0; i < p.size(); i++){
		printf("%d ", p[i]);
	}
	return 0;
}

5.5质因子分解

  • 质因子分解：把一个正整数写为若干个质数相乘的形式
  • 109 内整数本质不同质因数不会超过十个

23571113171923*29超过了int范围

  • 对于一个正整数n而言，若它存在1和本身之外的因子，则一定是在sqrt(n)左右成对出现。
    对于一个正整数n来说，若它存在[2, n]范围内的质因子，要么这些质因子全部小于等于sqrt(n)，要么只存在一个大于sqrt(n)的质因子，而其余质因子全部小于等于sqrt(n)。
    简单应用：
#include<iostream>
#include<map>
typedef long long LL;
using namespace std;
int main(){
	map<LL, int> mp;
	LL n, t;
	int i = 1;
	scanf("%lld", &n);
	t = n;
	for(int i = 2; i * i <= t; i++){
		if(t % i == 0){
			while(t % i == 0){
				mp[i]++;
				t /= i;
			}
		}
	}
	if(t > 1) mp[t]++;
	printf("%lld=", n);
	if(mp.size() != 0){
		for(map<LL, int>::iterator it = mp.begin(); it != mp.end(); it++, i++){
			if(it -> second == 1) printf("%lld", it -> first);
			else printf("%lld^%lld", it -> first, it -> second);
			if(i != mp.size()) printf("*");
		}
	}
	else printf("%lld", n);
	return 0;
}

5.6大整数运算

5.6.1大整数的存储

借助数组存储，一般逆序存储，即数组中的每一位对应整数中的每一位，其中整数的低位存储在数组的低位
为了方便获取大整数的长度，一般会定义一个int型变量记录长度和d数组组合为结构体

struct bign{
	int d[1000];
	int len;
	bign(){//构造函数进行初始化结构体；每次定义结构体变量时，都会自动对该变量进行初始化
		memset(d, 0, sizeof(d));
		len = 0;
	}
}

输入大整数时，一般都是先用字符串读入，再把字符串另存到bign结构体

bign change(char str[]){//输入大整数
	bign b;
	b.len = strlen(str);
	int l = strlen(str);
	for(int i = 0; i < l; i++){
		b.d[i] = str[l - i - 1] - '0';//逆序存储
	}
	return b;
}

比较两个大整数的大小：
首先位数多的大
位数相同时，从高位至低位进行比较，同位数 数值大的更大
全部位数相同，则相等

int compare(bign b1, bign b2){//大整数变量比较大小
	if(b1.len < b2.len) return -1;//b1小
	else if(b1.len > b2.len) return 1;//b2小
	else{
		for(int i = b1.len - 1; i >= 0; i--){
			if(b1.d[i] < b2.d[i]) return -1;
			else if(b1.d[i] > b2.d[i]) return 1;
		}		
	} 
	return 0;//相等 
}

5.6.2大整数的四则运算

高精度加法
bign add(bign b1, bign b2){
	bign b;
	int carry = 0, i;//进位 
	for(i = 0; i < b1.len || i < b2.len; i++){
		b.d[i] = (b1.d[i] + b2.d[i]) % 10 + carry;
		carry = (b1.d[i] + b2.d[i]) / 10;
	}
	if(carry == 1) {
		b.d[i] = 1;
		b.len = i + 1;
	}
	else b.len = i;
	return b; 
}
高精度减法

使用sub函数前，需要先比较b1和b2的大小，确保b1 >= b2.换言之，当b1 < b2时，则输出负号，再交换b1,b2

bign sub(bign b1, bign b2){
	bign b;
	for(int i = 0; i < b1.len; i++){//确保b1 >= b2，以较长的为界限
		if(b1.d[i] < b2.d[i]){//不足则借位 
			b1.d[i] += 10;
			b1.d[i + 1]--; 
		} 
		b.d[b.len++] = b1.d[i] - b2.d[i];
	}
	while(b.len > 1 && b.d[i - 1] == 0){//去掉高位多余的0（有至少两位的时候才需要考虑该问题 ）；数组从0开始 
		b.len --;
	}
	return b; 
}
高精度与低精度的乘法

在这里插入图片描述
如果两个乘数异号，则先记录负号，再用其绝对值带入函数

bign multi(bign b, int n){//高精度和低精度的乘法 
	bign ans;
	int carry = 0, t;//进位 
	for(int i = 0; i < b.len; i++){
		t = b.d[i] * n + carry;
		ans.d[ans.len++] = t % 10;
		carry = t / 10;
	} 
	while(carry){//乘法进位可能不止一位 
		ans.d[ans.len++] = carry % 10;
		carry /= 10; 
	}
	return ans;
}
高精度与低精度的除法
bign divide(bign b, int n, int &r){//高精度和低精度的除法，r为余数（初始为0） 
	bign ans;
	ans.len = b.len;
	for(int i = b.len - 1; i >= 0; i--){//从高位开始 
		r = r*10 + b.d[i];//当前位数值+上一位的余数*10 
		if(r < n){//不够除，商0（注意够不够除，比较的是除数n） 
			ans.d[i] = 0;
		}
		else{//够除 
			ans.d[i] = r / n;//商（注意比较的是除数n） 
			r = r % n;//新的余数 
		} 
	}
	while(ans.len > 1 && ans.d[ans.len - 1] == 0){//当位数至少为2位时，考虑高位是否有多余的0 
		ans.len--;
	}	
	return ans; 
}

简单应用

#include<stdio.h>
#include<string.h>

struct bign{
	int d[1000];
	int len;
	bign(){
		memset(d, 0, sizeof(d));
		len = 0;
	}
};

bign change(char str[]){//输入 
	bign b;
	b.len = strlen(str);
	int l = strlen(str);
	for(int i = 0; i < l; i++){
		b.d[i] = str[l - i - 1] - '0';
	}
	return b;
} 

int compare(bign b1, bign b2){//比较 
	if(b1.len < b2.len) return -1;//b1小
	else if(b1.len > b2.len) return 1;//b2小
	else{
		for(int i = b1.len - 1; i >= 0; i--){
			if(b1.d[i] < b2.d[i]) return -1;
			else if(b1.d[i] > b2.d[i]) return 1;
		}		
	} 
	return 0;//相等 
}

bign add(bign b1, bign b2){//相加 
	bign b;
	int carry = 0, i;//进位 
	for(i = 0; i < b1.len || i < b2.len; i++){
		b.d[i] = (b1.d[i] + b2.d[i]) % 10 + carry;
		carry = (b1.d[i] + b2.d[i]) / 10;
	}
	if(carry == 1) {
		b.d[i] = 1;
		b.len = i + 1;
	}
	else b.len = i;
	return b; 
}

bign sub(bign b1, bign b2){//b1 >= b2
	bign b;
	for(int i = 0; i < b1.len; i++){//以较长的为界限 
		if(b1.d[i] < b2.d[i]){//不够减 
			b1.d[i] += 10;
			b1.d[i+1]--;
		}
		b.d[b.len++] = b1.d[i] - b2.d[i];
	}
	while(b.len > 1 && b.d[b.len-1] == 0) b.len--; 
	return b;
}

bign multi(bign b, int n){//高精度和低精度的乘法 
	bign ans;
	int carry = 0, t;//进位 
	for(int i = 0; i < b.len; i++){
		t = b.d[i] * n + carry;
		ans.d[ans.len++] = t % 10;
		carry = t / 10;
	} 
	while(carry){//乘法进位可能不止一位 
		ans.d[ans.len++] = carry % 10;
		carry /= 10; 
	}
	return ans;
}

bign divide(bign b, int n, int &r){//高精度和低精度的除法，r为余数（初始为0） 
	bign ans;
	ans.len = b.len;
	for(int i = b.len - 1; i >= 0; i--){//从高位开始 
		r = r*10 + b.d[i];//当前位数值+上一位的余数*10 
		if(r < n){//不够除，商0（注意够不够除，比较的是除数n） 
			ans.d[i] = 0;
		}
		else{//够除 
			ans.d[i] = r / n;//商（注意比较的是除数n） 
			r = r % n;//新的余数 
		} 
	}
	while(ans.len > 1 && ans.d[ans.len - 1] == 0){//当位数至少为2位时，考虑高位是否有多余的0 
		ans.len--;
	}	
	return ans; 
}

int main(){
	char str1[1000], str2[1000];
	int n, r = 0;
	scanf("%s%s%d", str1, str2, &n);
	bign b1 = change(str1);
	bign b2 = change(str2);
	bign b = add(b1, b2);
	for(int i = b.len - 1; i >= 0; i--){
		printf("%d", b.d[i]);
	}
	
	printf("\n");
	bign subN;
	if(compare(b1, b2) < 0){
		printf("-");
		subN = sub(b2, b1);
	}
	else subN = sub(b1, b2);
	for(int i = subN.len - 1; i >= 0; i--){
		printf("%d", subN.d[i]);
	}
	
	printf("\n");
	bign m = multi(b1, n);
	for(int i = m.len - 1; i >= 0; i--){
		printf("%d", m.d[i]);
	}
	
	printf("\n");
	bign d = divide(b1, n, r);
	for(int i = d.len - 1; i >= 0; i--){
		printf("%d", d.d[i]);
	}
	return 0;
}

在这里插入图片描述

六、c++标准模板库（STL）

Standard Template Library STL标准模板库

6.1vector变长数组

使用vector需要添加：

#include<vector>
using namespace std;

vector定义

其中typename可以说任意基本类型，也可以是STL标准容器，例如vector、set、queue等。注意，当typename也是STL容器时，定义时要在>>符号之间加上空格。

因为一些使用C++11之前标准的编译器会把它视为移位操作，导致编译错误。

vector<typename> name;

vector<double> name;
vector<node> name;//node是结构体的类型

//二维vector数组，可以理解为两个维都可变长的二维数组
vector<vector<int> > name;//>>之间记得加空格

vector数组的定义
其中Arrayname[0]~Arrayname[arraySize - 1]中每一个都是一个vector容器
。与vector<vector < typename> > name区别在于，该种写法的一维长度已经固定为arraySize，另一维才是变长的。

vector<typename> Arrayname[arraySize];

vector<int> vi[100];

以上定义的为空vector
vector定义并初始化：

  1. 定义并用n个val来初始化的vector
vector<typename> name(n, val);

vector<int> vi(10, 1);//用10个1来初始化vector
  1. 定义并用迭代器区间来初始化的vector
vector<int> vi1(vi.begin(), vi.end());//用vi的迭代器区间来初始化vi1
string s("you are so pretty");
vector<char> v(s.begin(), s.end());//用s的迭代器区间来初始化v
  1. 除了上述两种，还有三种
	//一共有这五种初始化方式
	(1) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
   （2）vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
   （3）vector<int> a(b); //用b向量来创建a向量，整体复制性赋值
   （4）vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
   （5）int b[7]={1,2,3,4,5,9,8};
        vector<int> a(b,b+7); //从数组中获得初值

vector容器内元素的访问

1.通过下标访问

类似于普通数组，对于一个定义为vector< typename> vi的vector容器而言，直接访问vi[index]即可，其中下标index范围为[0, vi.size()-1]
注意，下面这种做法以及类似的做法都是错误的。下标只能用于获取已存在的元素，而现在的vi[i]还是空的对象
在这里插入图片描述

2.通过迭代器访问

所谓迭代器iterator可理解为类似指针的东东
其中，it是一个vector< typename>::iterator型的变量

vector<typename>::iterator it;
  • vi.begin()函数：取vector容器vi的首元素地址
  • vi.end()函数：取vector容器vi的尾元素地址的下一个地址

老外习惯：左闭右开

#include<stdio.h>
#include<vector>
using namespace std;
int main(){
	vector<int> vi;
	
	for(int i = 1; i < 6; i++)
		vi.push_back(i);
	
	vector<int>::iterator it = vi.begin();
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", *(it + i));
		
	printf("\n");
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", *(vi.begin() + i));
		
	printf("\n");
	//vector的迭代器不支持it < vi.end()写法，则循环条件只能用it != vi.end()
	//在常用STL容器中，只有vector和string中，才允许使用vi.begin()+n这种迭代器加上整数的写法 
	for(vector<int>::iterator i = vi.begin(); i != vi.end(); i++){//迭代器实现了自加自减操作(it++或++it) 
		printf("%d ", *i);// 
	}
	
	printf("\n");
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);//通过下标访问 
	return 0;
}

在这里插入图片描述

vector常用函数

  • push_back(x) : 在vector后面添加一个元素x，时间复杂度为O(1)
    • emplace_back(x)c++11新加，可以理解为实现更优雅的push_back()
  • pop_back() : 删除vector的尾元素，时间复杂度为O(1)
#include<stdio.h>
#include<vector>
using namespace std;
int main(){
	vector<int> vi;
	
	for(int i = 1; i < 6; i++)
		vi.push_back(i);//在vector后面插入元素i
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);
		
	vi.pop_back();//删除vector尾元素
	printf("\n");
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);	 
	return 0;
}

在这里插入图片描述

  • size() : 获得vector中元素的个数，时间复杂度为O(1)。size()返回的是unsigned类型，不过用%d一般木得问题，该点适用于所有STL容器。
  • clear() ： 清空vector中的所有元素，时间复杂度为O(N),其中N为vector中元素的个数
  • insert(it, x) : 向vector中的任意迭代器it处插入一个元素x，时间复杂度为O(1)
  • erase
    • erase(it)删除迭代器为it处的元素
    • erase(first, last)删除[first, last)内的所有元素
#include<stdio.h>
#include<vector>
using namespace std;
int main(){
	vector<int> vi;
	
	for(int i = 1; i < 6; i++)
		vi.push_back(i);
	printf("vi长度：%d", vi.size());
	vi.insert(vi.begin() + 3, 0);//把元素0插入到vi[3]的位置    
	printf("\n");
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);	 
	
	vi.erase(vi.begin() + 1);//删除vi[1]处的元素
	printf("\n");
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);
		
	vi.erase(vi.begin(), vi.begin() + 2);//删除vi[0]到vi[1]的所有元素 
	printf("\n");
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);
	vi.clear();//清除所有元素 
	printf("\n%d", vi.size()); //0 
	return 0;
}

在这里插入图片描述

vector常见用途

  1. 作为数组使用，尤其是元素个数不确定的场合；当需要输出部分数据且中间用空格隔开而末尾不能有多余空格时，可以先用vector记录所有需要输出的数据，再一次性输出
  2. 用邻接表存储图

6.2set（升序、去重）

若使用set，需要添加：

#include<set>
using namespace std;

整体和vector容器非常相似，下述简化描述

set定义

set<typename> name;

set<int> name;
set<node> name;

set数组定义

set<typename> Arrayname[arraySize];

set<int> a[100];

set容器内元素的访问

set只能通过迭代器(iterator)访问元素

set<typename>::iterator it;

#include<stdio.h>
#include<set>
using namespace std;
int main(){
	set<int> st;
	st.insert(5);
	st.insert(3);
	st.insert(4);
	st.insert(3);
	st.insert(1);
	//除了vector和string之外的STL容器都不支持*(it + i)的访问方式，则只能按照如下方式枚举 
	for(set<int>::iterator it = st.begin(); it != st.end(); it++){//同vector，不支持it < st.end()的写法 
		printf("%d ", *it);
	}
	return 0;
}

在这里插入图片描述

set常用函数

  • insert(x) : 把x插入set容器中，且自动增序和去重，时间复杂度O(logN)，其中N是set内的元素个数
  • find(value) : 返回set中对应值为value的迭代器，时间复杂度为O(logN)，N为set内的元素个数
  • erase()
    • erase(it) ： it是所需要删除元素的迭代器，时间复杂度为O(1)。可以结合find()函数来使用
    • erase(value) : value是所需要删除的元素的值，时间复杂度为O(logN)，N为set内的元素个数
    • erase(first, last)删除区间[ first, last)内的所有元素，时间复杂度为O(last - first)
  • size() : 获得set内的元素个数，时间复杂度为O(1)
  • clear() : 清空set中的所有元素，时间复杂度为O(N)，其中N为set内元素的个数
#include<stdio.h>
#include<set>
using namespace std;
int main(){
	set<int> st;
	st.insert(5);//set(x)把元素x插入到set容器中，且自动实现增序和去重 
	st.insert(3);
	st.insert(4);
	st.insert(3);
	st.insert(1);
	for(set<int>::iterator it = st.begin(); it != st.end(); it++){
		printf("%d ", *it);
	}
	
	set<int>::iterator it = st.find(3);//find(value) 返回set中对应值为value的迭代器 
	printf("\n%d\n", *it); //3
	
	//erase(it) 其中it是要删除元素的迭代器 
	st.erase(it);//先利用find()函数找到3，再用erase()删除
	for(set<int>::iterator it = st.begin(); it != st.end(); it++){
		printf("%d ", *it);
	}
	
	//erase(value) 其中value是要删除元素的值 
	st.erase(4);//删除set中值为4的元素 
	printf("\n");
	for(set<int>::iterator it = st.begin(); it != st.end(); it++){
		printf("%d ", *it);
	}
	
	//erase(first, last)删除区间[ first, last)内的所有元素 
	st.erase(st.find(5), st.end());//删除元素5到set末尾之间的所有元素 
	printf("\n");
	for(set<int>::iterator it = st.begin(); it != st.end(); it++){
		printf("%d ", *it);
	}
	
	//size() 返回set内的元素个数 
	printf("\nset长度：%d", st.size());
	
	//clear() 清空set中的所有元素
	st.clear();
	printf("\n清空后的set长度：%d", st.size());
	return 0;
}

在这里插入图片描述

set常见用途

set最主要的作用就是自动去重且按升序排序

6.3string字符串

使用string,需要添加：

#include<string>
using namespace std;

string定义

定义string的方式跟基本数据类型相同，直接在string后跟变量名即可

string str;

若初始化，可以直接给string类型的变量进行赋值

string str = "harder";

string中内容的访问

  1. 通过下标访问
    一般而言，可以直接像字符数组那样去访问string
#include<stdio.h>
#include<string>
using namespace std;
int main(){
	string str = "fighting!";
	for(int i = 0; i < str.length(); i++){
		printf("%c ", str[i]);
	}
	return 0;
}

在这里插入图片描述
读入和输出整个字符串

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str;
	cin>>str;
	cout<<str;
	printf("\n%s", str.c_str());
	return 0;
}

在这里插入图片描述

  1. 通过迭代器访问
    一般情况下用下标进行访问即可，但有些函数比如insert()和erase()要求以迭代器为参数，需要了解string迭代器的用法
string::iterator it;

#include<stdio.h>
#include<string>
using namespace std;
int main(){
	string str = "fighting!";
	for(string::iterator it = str.begin(); it != str.end(); it++){
		printf("%c ", *it);
	}
	printf("\n");
	for(int i = 0; i < str.length(); i++){
		//string和vector一样，支持直接对迭代器进行加减某个数字 
		printf("%c ", *(str.begin() + i));
	}
	return 0;
}

在这里插入图片描述

string常用函数

  • += ：把两个string直接拼接起来
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "fighting,", str2 = "blue!";
	str1 += str2;//fighting,blue!
	str2 += str2;//blue!blue!
	cout<<str1<<endl;
	printf("%s", str2.c_str());
	return 0;
}
  • 比较操作==、!=、<、<=、>、>= : 比较规则是字典序
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "aa", str2 = "ab", str3 = "aaa", str4 = "yz";
	if(str1 < str2) printf("%s小于%s\n", str1.c_str(), str2.c_str());
	if(str1 < str3) printf("%s小于%s\n", str1.c_str(), str3.c_str());
	if(str1 < str4) printf("%s小于%s\n", str1.c_str(), str4.c_str());
	return 0;
}

在这里插入图片描述

  • length()/size() ： 返回string的长度
  • insert()
    • insert(pos, string) 在pos号位置上插入字符串string（pos从0开始
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str = "123456";
	str.insert(3, "abc");
	cout<<str;
	return 0;
}

在这里插入图片描述

  • insert()续
    • insert(it, it1, it2) ： 串[ it1, it2)将会插在it的位置上
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str = "123456", str1 = "abcdef";
	str.insert(str.begin() + 3, str1.begin(), str1.begin() + 3);
	cout<<str;
	return 0;
}

在这里插入图片描述

  • erase()
    • erase(it) : 用于删除单个元素，其中it是需要删除的元素的迭代器
    • erase(first, last) : 删除区间[first, last)内的所有元素
    • erase(pos, length) : 删除从pos开始,length个字符
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str = "123456", str1 = "abcdef";
	//erase(it) 删除单个元素 
	str.erase(str.begin() + 1);	//13456	即删除1号位置的元素（位置从0开始） 
	cout<<str<<endl;
	
	//erase(first, last) 删除区间[first, last)内的所有元素 
	str.erase(str.end() - 3, str.end());//13 
	cout<<str<<endl;
	
	//erase(pos, length) 删除从pos开始的length个字符 
	str1.erase(3, 3);//abc 即删除从3号位开始的3个字符 
	cout<<str1;
	return 0;
}

在这里插入图片描述

  • clear() ： 清空string中的数据
  • substr(pos, len) : 返回从pos位置开始，长度为len的子串，时间复杂度为O(len)
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "abcdef123", str2;
	str2 = str1.substr(6, 3);
	cout<<str2<<endl;//123
	str1.clear();
	cout<<str1.size();//0
	return 0;
}
  • string::npos 是一个常数，本身的值是-1，但由于是unsigned_int类型，则也可以认为是unsigned_int类型的最大值。string::pos是find()函数失配时的返回值。
#include<iostream>
#include<string>
using namespace std;
int main(){
//	unsigned int n = -1;
//	cout<<n<<endl;
	if(string::npos == -1) cout<<"string::npos == 1为真"<<endl;
//	if(string::npos == n) printf("string::npos == %u为真", n);
//	else cout<<"err";

//[Warning] this decimal constant is unsigned only in ISO C90
	if(string::npos == 4294967295) printf("string::npos == 4294967295为真");
	return 0;
}

在这里插入图片描述

  • find()
    • str.find(str1) :
      • 当str1是str的子串时，返回其在str中第一次出现的位置；
      • 当str1不是str的子串时，返回string::npos
    • str.find(str1, pos) ： 从str的pos号位开始匹配str1,返回值和上个函数相同
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "fighting, blue!", str2 = "ing", str3 = "give up";
	if(str1.find(str2) != string::npos) cout << str1.find(str2) << endl;
	if(str1.find(str3) != string::npos) cout << str1.find(str3) << endl;
	else printf("no words:%s\n", str3.c_str());
	if(str1.find(str2, 6) != string::npos) cout << str1.find(str2, 6) << endl;
	else cout<<"early";
	return 0;
}

在这里插入图片描述

  • replace() 时间复杂度为O(str.length())
    • str.replace(pos, len, str1) : str从pos号位开始、长度为len的子串替换为str1
    • str.replace(it1, it2, str1) : 把str的迭代器[it1, it2)范围的子串替换为str1
#include<iostream>
#include<string>
using namespace std;
int main(){
	string str = "1234567890", str1 = "abc", str2 = "DEF";
	cout << str.replace(3, 3, str1) << endl;//123abc7890
	cout << str.replace(str.begin() + 6, str.begin() + 7, str2);//123abcDEF890 位置不够也会把str2替换 
	return 0;
}

在这里插入图片描述

6.4map键值对

若map使用，需要添加：

#include<map>
using namespace std;

map可以把任何基本类型（包括STL容器）映射到任何基本类型（包括STL容器）

map定义

定义一个map,其中前类型为key类型，后类型为value类型

map<typename1, typename2> mp;

当int型映射到int型，也就相当于普通的int型数组了。
注意当字符串到整型的映射时，必须使用string而不能使用char数组。
因为char数组作为数组，是不能被作为键值的。若想用字符串做映射，必须用string。

map<string, int> mp;

map<set<int>, string>  mp;//map的键和值也可以是STL容器

map中内容的访问

  • 通过下标进行访问
    和普通数组的访问同理，例如对一个定义为map<char, int> mp的map来说，就可以直接使用mp[‘c’]的方式来访问它对应的整数。注意，map中的键是唯一的。
#include<iostream>
#include<map>
using namespace std;
int main(){
	map<char, int> mp;
	mp['a'] = 1;
	mp['a'] = 2;//更新,因为键是唯一的 
	printf("%d", mp['a']);//2
	return 0;
}
  • 通过迭代器访问
    map可使用it->first来访问键，使用it->second来访问值。map会以键从小到大的顺序自动排序

因为map内部使用红黑树实现（set也是），在建立映射的过程中会自动实现从小到大的排序功能

map<typename1, typename2>::iterator it;

#include<iostream>
#include<map>
using namespace std;
int main(){
	map<char, int> mp;
	mp['c'] = 4;
	mp['a'] = 2;
	mp['b'] = 5;
	for(map<char, int>::iterator it = mp.begin(); it != mp.end(); it++){
		printf("%c : %d\n", it->first, it->second);
	}
	return 0;
}

在这里插入图片描述

map常见函数

  • find(key) : 返回键为key的映射的迭代器
#include<iostream>
#include<map>
using namespace std;
int main(){
	map<char, int> mp;
	mp['b'] = 4;
	mp['a'] = 1;
	mp['c'] = 3;
	//find(key)返回键为key的映射的迭代器
	//小复习：map可以使用it -> first访问键， it -> second访问值 
	map<char, int>::iterator it = mp.find('a');
	printf("%c %d", it -> first, it -> second);//a 1 
	return 0;
}
  • erase()
    • erase(it) : it是要删除元素的迭代器，时间复杂度为O(1)
    • erase(key) : key是要删除的映射的键，时间复杂度为O(logN)
    • erase(first, last) : 删除区间[ first, last)内的元素。其中first是要删除区间的起始迭代器，last是要删除的区间的末尾迭代器的下一个地址。
#include<iostream>
#include<map>
using namespace std;
int main(){
	map<char, int> mp;
	mp['b'] = 4;
	mp['a'] = 1;
	mp['c'] = 3;
	mp['d'] = 2;
	mp['y'] = 4;
	mp['x'] = 1;
	mp['z'] = 3;
	mp['o'] = 2;
	for(map<char, int>::iterator it = mp.begin(); it != mp.end(); it++){
		printf("%c %d, ", it -> first, it -> second);
	} 
	printf("\n");
	map<char, int>::iterator it = mp.find('a');
	//mp.erase(it) it是要删除元素的迭代器 
	mp.erase(it);
	mp.erase(mp.find('d'));
	//mp.erase(key) key是要删除的映射的键 
	mp.erase('c');
	 
	//mp.erase(first, last)删除区间[first, last)区间内的元素 
	//注意，这里的迭代器不能用mp.begin()或者mp.end()加整数
	//string和vector才支持对迭代器进行加减某个数字，例如str.begin()+3 
	mp.erase(mp.find('x'), mp.end());
	for(map<char, int>::iterator it = mp.begin(); it != mp.end(); it++){
		printf("%c %d, ", it -> first, it -> second);
	} 
	printf("\n"); 
	return 0;
}

在这里插入图片描述

  • size() ： 返回的是map中映射的对数，时间复杂度O(1)
  • clear() : 清空map中的所有元素，复杂度为O(n)，其中N为map中元素的个数
#include<iostream>
#include<map>
#include<string>
using namespace std;
int main(){
	map<string, int> mp;
	mp["are"] = 1;
	mp["you"] = 3;
	mp["ok"] = 2;
	for(map<string, int>::iterator it = mp.begin(); it != mp.end(); it++)
		printf("%s %d\n", it -> first.c_str(), it -> second);
	//mp.clear() 清空mp中的所有元素 
	mp.clear();
	//mp.size() 返回mp中的映射对数 
	printf("%d", mp.size());
	return 0;
}

在这里插入图片描述

map常见用途

  • 需要建立字符（字符串）与整数之间映射的题目，可以使用map减少代码量
  • 判断大整数或者其他类型数据是否存在的题目，可以把map当bool数组用
  • 字符串和字符串的映射也有可能会遇到

6.8pair

若用pair,需添加

#include<map>
using namespace std;

或

#include<utility>
using namespace std;

由于map的内部实现中设计pair，则添加mao头文件会自动添加utility头文件，故可以直接偷懒用map头文件来代替utility头文件，好记~

pair定义

pair有俩参数，分别对应first和second的数据类型，它们可以是任意基本数据类型或容器

pair<typename1, typename2> name;

pair<string, int> p;

若在定义pair时进行初始化，只需跟上一个小括号，里面填写两个想要初始化的元素即可

pair<string, int> p("harder", 1);

若想要在代码中临时构建一个pair，有如下两种方法

  • 把类型定义写在前面，后面用小括号内两个元素的方式
pair<string, int>("blue", 2)
  • 使用自带的make_pair函数
make_pair("first", 1)

pair中元素的访问

pair中只有两个元素，分别是first和second，只需要按正常结构体的方式去访问即可

#include<iostream>
#include<map>
using namespace std;
int main(){
	pair<string, int> p;
	p.first = "fighting";
	p.second = 1;
	cout << p.first << " " << p.second << endl;
	p = pair<string, int>("coming", 1);
	cout << p.first << " " << p.second << endl;
	p = make_pair("harder", 111);
	cout << p.first << " " << p.second;
	return 0;
}

在这里插入图片描述

pair常用函数

两个pair类型数据可以直接使用== , !=, < , <= , >, >=比较大小。

  • 比较规则：先以first的大小作为标准，只有当first相等时才去判别second的大小
#include<iostream>
#include<map>
using namespace std;
int main(){
	pair<int, int> p1(3, 1);
	pair<int, int> p2(3, 2);
	pair<int, int> p3(2, 3);
	if(p1 < p2) cout << p1.first << " " << p1.second << "小于" << p2.first << " " << p2.second << endl;
	if(p1 > p3) cout << p1.first << " " << p1.second << "大于" << p3.first << " " << p3.second;
	return 0;
}

在这里插入图片描述

pair常见用途

  • 用来替代二元结构体及其构造函数，可以节省编码时间
  • 作为map键值对来进行插入
#include<iostream>
#include<map>
#include<string>
using namespace std;
int main(){
	map<string, int> mp;
	//mp.insert("that", 4);报错 
	mp.insert(pair<string, int>("this", 2));
	mp.insert(make_pair("it", 3));
	for(map<string, int>::iterator it = mp.begin(); it != mp.end(); it++){
		cout << it->first << " " << it->second << endl;
	}
	return 0;
}

在这里插入图片描述

6.9 algorithm头文件下的常用函数

若使用algorithm头文件，需要在头文件下添加

using namespace std;

6.9.1 max(), min()和 abs()

  • max(x, y) 返回x和y中的最大值（且参数必须是两个，可以是浮点数）
  • min(x, y) 返回x和y中的最小值
  • abs(x) 返回x的绝对值
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
	int x, y, z;
	cin >> x >> y >> z;
	cout << max(x, y) << endl;
	cout << max(x, max(y, z)) << endl;
	cout << min(x, y) << endl;
	cout << abs(x) << endl;
	cout << fabs(x);
	return 0;
}

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
//	int x, y, z;
	double x = -1, y = -3, z = -2;
//	cin >> x >> y >> z;
	cout << max(x, y) << endl;
	cout << max(x, max(y, z)) << endl;
	cout << min(x, y) << endl;
	cout << abs(x) << endl;
	cout << fabs(x);
	return 0;
}

在这里插入图片描述

  • swap(x, y) 交换x和y的值
  • reverse(it1, it2) 把[ it1, it2)之间的元素或容器的迭代器在该范围内反转
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main(){
	string str = "abcdefg";
	int a[10] = {1, 2, 3, 4, 5};
	swap(a[0], a[1]);
	reverse(a + 2, a + 5);
	for(int i = 0; i < 5; i++){
		printf("%d ", a[i]);
	}
	reverse(str.begin(), str.begin() + 4);
	cout << endl << str;
	return 0;
}

在这里插入图片描述

  • next_permutation(first, last) : 给出一个序列在[first, last]范围内全排列中的下一个序列
    在这里插入图片描述
    next_permutation在已经到达全排列的最后一个时会返回false。使用do…while语句是为了输出最有一组序列后再退出。
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
	int a[5] = {3, 2, 1}, b[5] = {1, 2, 3};
	do{
		printf("逆序：%d %d %d\n", a[0], a[1], a[2]);
	}while(next_permutation(a, a + 3));
	do{
		printf("正序：%d %d %d\n", b[0], b[1], b[2]);
	}while(next_permutation(b, b + 3));
	return 0;
}

在这里插入图片描述

  • fill(first, last, value) : 把[first, last]区间内皆赋值为value
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
	vector<int> vi;
	for(int i = 1; i < 6; i++)
		vi.push_back(i);
	fill(vi.begin(), vi.end(), 6);
	for(int i = 0; i < 5; i++)
		cout << vi[i] << " ";
	return 0;
}

在这里插入图片描述

6.9.6sort()

sort()使用
  • 需要加#include<algorithm>和using namespace std;
sort(首元素地址，尾元素地址的下一个地址， 比较函数（选填）);

若比较函数不填，默认从小到大（序列元素一定要有可比性）（对于char型数组默认为字典序）对于结构体这种本身没有大小关系，需要手动制定比较规则。
①整型数组

#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
	int a[6] = {9, 4, 2, 5, 6, -1};
	sort(a, a + 4);//默认从小到大 
	for(int i = 0; i < 6; i++){
		printf("%d ", a[i]);//2 4 5 9 6 -1
	} 
	printf("\n");
	sort(a, a + 6);
	for(int i = 0; i < 6; i++){
		printf("%d ", a[i]);//-1 2 4 5 6 9
	}
	return 0;
}

②char型数组

#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
	char c[] = "harder";
	sort(c, c + 6);
	for(int i = 0; i < 6; i++) printf("%c ", c[i]);
	return 0;
}
实现比较函数
（1）基本数据类型数组的排序

从大到小a>b
①整型数组

#include<cstdio>
#include<algorithm>
using namespace std;
bool cmp(int a, int b){
	return a > b;
}
int main(){
	int a[6] = {9, 4, 2, 5, 6, -1};
	sort(a, a + 4, cmp);//默认从小到大 
	for(int i = 0; i < 6; i++){
		printf("%d ", a[i]);//9 5 4 2 6 -1
	} 
	printf("\n");
	sort(a, a + 6, cmp);
	for(int i = 0; i < 6; i++){
		printf("%d ", a[i]);//9 6 5 4 2 -1
	}
	return 0;
}

②字符型数组

#include<cstdio>
#include<algorithm>
using namespace std;
bool cmp(char a, char b){
	return a > b;
}
int main(){
	char c[] = "harder";
	sort(c, c + 6, cmp);
	for(int i = 0; i < 6; i++) printf("%c ", c[i]);//r r h e d a
	return 0;
}
（2）结构体数组的排序

以该结构体为例：

struct node{
	int x, y;
}ssd[10];
  • 一级排序
    以ssd数组按照x从大到小排序
bool cmp(node a, node b){
	return a.x > b.x;
}
  • 二级排序
    以ssd数组先按x从大到小排序；当x相等时，按照y从小到大排序
bool cmp(node a, node b){
	if(a.x != b.x) return a.x > b.x;
	else return a.y < b.y;
}
（3）容器的排序

在STL标准容器中，只有vector,string,deque可以使用sort

对于像set,map这种容器是用红黑树实现的，元素本身有序，则不运行使用sort排序

//以vector为例
#include <stdio.h>
#include <vector>
#include <algorithm>
using namespace std;
bool cmp(int a, int b){//vector中的元素为int型，则仍然是int的比较 
	return a > b;
}
int main(){
	vector<int > vi;
	vi.push_back(3);
	vi.push_back(2);
	vi.push_back(4);
	sort(vi.begin(), vi.end(), cmp);//对整个vector排序
	for(int i = 0; i < 3; i++)
		printf("%d ", vi[i]);//4 3 2 
	return 0;
}

//以string按字典序从小到大输出为例
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
	string str[3] = {"better", "a", "person"};
	sort(str, str + 3);//把string型数组按照字典序从小到大输出
	for(int i = 0; i < 3; i++)
		cout<<str[i]<<endl; //a better person
	return 0;
} 

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
bool cmp(string str1, string str2){
	return str1.length() < str2.length();//按string的长度从小到大排序	
}
int main(){
	string str[3] = {"better", "a", "person"};
	sort(str, str + 3, cmp);//把string型数组按照字典序从小到大输出
	for(int i = 0; i < 3; i++)
		cout<<str[i]<<endl; //a better person
	return 0;
}

简单应用

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
bool cmp1(int a, int b){
	return a > b;
}

bool cmp2(string s1, string s2){
	return s1.length() < s2.length();
}
int main(){
	vector<int> vi;
	vi.push_back(2);
	vi.push_back(-1);
	vi.push_back(1);
	sort(vi.begin(), vi.end(), cmp1);
	for(vector<int>::iterator it = vi.begin(); it != vi.end(); it++)
		cout << *it << " ";
		
	string str[5] = {"dd", "dad", "a", "baab"};
	sort(str, str + 5, cmp2);
	for(int i = 0; i < 5; i++)
		cout << str[i] << endl;
	return 0;
}

在这里插入图片描述

6.9.7 lower_bound() 大于等于 && upper_bound() 大于

  • lower_bound(first, last, val) : 返回在数组或容器中的[first, last)范围内第一个值大于等于val元素的数组位置或容器迭代器
  • upper_bound(first, last, val) : 返回在数组或容器中的[ first, last)范围内第一个值大于val元素的数组位置或容器迭代器
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
	vector<int> vi;
	for(int i = 1; i < 10; i++)
		vi.push_back(i);
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);
	printf("\n");
	vi.erase(vi.begin() + 4);
	for(int i = 0; i < vi.size(); i++)
		printf("%d ", vi[i]);
	printf("\n");
	printf("%d %d", *lower_bound(vi.begin(), vi.begin() + 10, 5), *upper_bound(vi.begin(), vi.begin() + 10, 5));
	printf("\n");
	printf("%d %d", *lower_bound(vi.begin(), vi.begin() + 9, 6), *upper_bound(vi.begin(), vi.begin() + 9, 6));
	return 0;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1517734.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python基于 opencv 的人脸识别考勤系统（V1.0），附源码

Python基于 opencv 的人脸识别考勤系统（V1.0），附源码

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝12W、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
O2OA(翱途)开发平台系统安全-用户登录IP限制

O2OA(翱途)开发平台系统安全-用户登录IP限制

O2OA(翱途)开发平台[下称O2OA开发平台或者O2OA]支持对指定的用户设置可以连接的客户端计算机的IP地址&#xff0c;以避免用户在不安全的环境下访问系统。本篇主要介绍如何开启O2OA用户登录IP限制。 一、先决条件&#xff1a; 1、O2Server服务器正常运行&#xff0c;系统安装部…
阅读更多...
mac安全干净卸载Anaconda3

mac安全干净卸载Anaconda3

使用which python显示当前使用的是/Users/username/anaconda3/bin/python 现在想卸载Anaconda&#xff0c;恢复使用mac系统自带的Python 删除隐藏文件目录 rm -rf ~/.anaconda修改~/.bash_profile文件&#xff0c;将anaconda相关删除 也有可能不是~/.bash_profile而是~/.zs…
阅读更多...
WEB三大组件之Filter

WEB三大组件之Filter

在很多项目中通常需要用到filter来实现用户身份识别&#xff0c;并将识别出来的用户信息&#xff0c;保存到ThreadLocal对应的上下文&#xff0c;这样在后续的请求链路中&#xff0c;在任何地方都可以直接获取当前的登录用户了。 来看一下Java WEB三大组件之一的过滤器Filter&…
阅读更多...
flutter环境搭建实践

flutter环境搭建实践

Dart Dart 是一种客户端和服务器端的编程语言&#xff0c;最早由 Google 提出。它被设计用于构建高性能、高度可伸缩和可靠的应用程序。Dart 可以编译成本地代码或者在虚拟机中直接运行。在移动应用开发中&#xff0c;Dart 主要用于开发 Flutter 应用。 Flutter 和 Dart 的关…
阅读更多...
【数据结构和算法初阶(C语言)】队列实操（概念实现+oj题目栈和队列的双向实现，超级经典！！！）

【数据结构和算法初阶(C语言)】队列实操（概念实现+oj题目栈和队列的双向实现，超级经典！！！）

1. 队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c; 队列具有先进先出 FIFO(First In First Out) 入队列&#xff1a;进行插入操作的一端称为队尾 出队列&#xff1a;进行删除操作的一端称为…
阅读更多...
基于单片机的车载酒精含量自检系统设计与实现

基于单片机的车载酒精含量自检系统设计与实现

摘要：调查显示，大约50%的交通事故与酒后驾车有关，酒后驾车已成为车祸致死的首要原因。为从根本上杜绝酒后驾车，设计了一款基于STC89C52 单片机的车载酒精含量自检系统，该系统能很好地解决酒驾问题，控制简单、使用方便，具有很好的应用价值。 关键词：STC89C52 单片机；车…
阅读更多...
Redis：持久化、线程模型、大 key

Redis：持久化、线程模型、大 key

Redis持久化方式有什么方式&#xff1f; Redis 的读写操作都是在内存中&#xff0c;所以 Redis 性能才会高&#xff0c;但是当 Redis 重启后&#xff0c;内存中的数据就会丢失&#xff0c;那为了保证内存中的数据不会丢失&#xff0c;Redis 实现了数据持久化的机制&#xff0c…
阅读更多...
【计算机视觉】二、图像形成：1、向量和矩阵的基本运算：线性变换与齐次坐标

【计算机视觉】二、图像形成：1、向量和矩阵的基本运算：线性变换与齐次坐标

文章目录 一、向量和矩阵的基本运算1、简单变换1. 平移变换2. 缩放变换3. 旋转变换4. 一般线性变换 2、齐次坐标0. 齐次坐标表示1. 2D点的齐次坐标变换2. 投影空间 ( x , y , w ) (x, y, w) (x,y,w)3. 2D直线的齐次坐标表示a. 直线的参数方程表示b. 直线的法向量和原点距离表示…
阅读更多...
React——react 的基本使用

React——react 的基本使用

前提&#xff1a;安装全局的脚手架&#xff0c;通过create-creat-app 项目名&#xff0c;我们创建好一个新项目&#xff0c;cd进去&#xff0c;通过npm start去运行该项目 注意&#xff1a;简单看下demo的配置&#xff0c;在根目录我们可以看到&#xff0c;没有任何webpack的…
阅读更多...
html5cssjs代码 018颜色表

html5cssjs代码 018颜色表

html5&css&js代码 018颜色表 一、代码二、效果三、解释 这段代码展示了一个基本的颜色表&#xff0c;方便参考使用&#xff0c;同时也应用了各种样式应用方式。 一、代码 <!DOCTYPE html> <html lang"zh-cn"> <head><title>编程笔记…
阅读更多...
15. jwt认证中间件

15. jwt认证中间件

在上一篇登录功能的实现中&#xff0c;我们使用了jwt作为鉴权组件&#xff0c;其中登录后会颁发token。前端在访问后续请求时&#xff0c;可以带上这个token。对于一些需要权限校验的请求&#xff0c;我们就需要验证这个token&#xff0c;从token中获取到用户id&#xff08;有了…
阅读更多...
8-图像放大

8-图像放大

其实&#xff0c;就是开辟一个zoomwidth&#xff0c;zoomheight的内存&#xff0c;再分别赋值即可。 void CDib::Maginify(float xZoom, float yZoom) { //指向原图像指针 LPBYTE p_data GetData(); //指向原像素的指针 LPBYTE lpSrc; //指向缩放图像对应像素的指针 LPBYTE l…
阅读更多...
实验二 基本搜索技术 五星图案节点填上数字+遍历所有黑点+门牌号

实验二 基本搜索技术 五星图案节点填上数字+遍历所有黑点+门牌号

目的&#xff1a; 1. 掌握递归和排序 2. 掌握BFS与队列 3. 掌握DFS和递归 4. 熟悉并理解回溯问题 实验内容&#xff1a; 1.在五星图案节点填上数字&#xff1a;1~12&#xff0c;不包括7和11。 要求每条直线上数字和相等。 如图就是一个恰当的填法。 请搜索所有可能的填…
阅读更多...
SpringMVC请求、响应和拦截器的使用

SpringMVC请求、响应和拦截器的使用

SpringMVC请求 RequestMapping注解 RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系 RequestMapping注解可以作用在方法和类上 1. 作用在类上&#xff1a;第一级的访问目录 2. 作用在方法上&#xff1a;第二级的访问目录 3. 细节&#xff1a;路径可以不编写…
阅读更多...
在Django中使用PyJWT实现登录及验证功能

在Django中使用PyJWT实现登录及验证功能

目录 1、安装PyJWT 2、对信息加密及解密 3、配置登录视图和及url 4、登录装饰器 5、在验证有登录权限的的视图中登录 PyJWT的使用 1、安装PyJWT pip isntall pyjwt 2、对信息加密及解密 import jwt import datetime from jwt import exceptions# 加密盐 JWT_SALT &qu…
阅读更多...
深入探索Java中的MarkWord与锁优化机制——无锁、偏向锁、自旋锁、重量级锁

深入探索Java中的MarkWord与锁优化机制——无锁、偏向锁、自旋锁、重量级锁

引言 在Java并发编程领域&#xff0c;有效管理对共享资源的访问显得尤为关键。为了保障线程安全&#xff0c;Java虚拟机&#xff08;JVM&#xff09;引入了一系列精妙的锁机制&#xff0c;这其中的核心概念就是Java对象头中的MarkWord。本文将详尽解析MarkWord的作用&#xff…
阅读更多...
CVPR2024 | 大核卷积新高度101x101，美团提出PeLK

CVPR2024 | 大核卷积新高度101x101，美团提出PeLK

https://arxiv.org/pdf/2403.07589.pdf 本文概述 最近&#xff0c;一些大核卷积网络以吸引人的性能和效率进行了反击。然而&#xff0c;考虑到卷积的平方复杂度&#xff0c;扩大内核会带来大量的参数&#xff0c;而大量的参数会引发严重的优化问题。由于这些问题&#xff0c;当…
阅读更多...
code摘录日记[矩阵变元素，变列向量，3D表面图，table行列设置] Matlab

code摘录日记[矩阵变元素，变列向量，3D表面图，table行列设置] Matlab

矩阵变元素&#xff0c;变列向量 W1(Z1 < Z2) nan; % Z1,Z2 all matrix,Only plot points where Z1 > Z2;Z1 < Z2位置值填为NaNx x(:); % Now x is a 30-by-1 vector; matrix变列vector技巧3D表面图 hand figure; % Handle to the figure, for more plotting later…
阅读更多...
QComboBox相关的qss学习

QComboBox相关的qss学习

QT有关QCobobox控件的样式设置&#xff08;圆角、下拉框&#xff0c;向上展开、可编辑、内部布局等&#xff09;_qcombobox样式-CSDN博客 原始图&#xff1a; 红色边框&#xff1a; QComboBox{ border:2px solid rgb(255, 85, 0); } 绿色背景&#xff1a; QComboBox{ border…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023