基础算法-双指针、离散化和区间和

双指针

简介

常见问题分类：
1. 对于一个序列，用两个指针维护一段区间
2. 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作
核心代码：

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;
    // 具体问题的逻辑
}

模板题

ITCX7121寒假第一周-K最长连续不重复子序列

模板题分析

1. 用s[N]来记录当前这个区间里每个数出现多少次
2. 写模板，i指针向后移动，每个a[i]的s要加1s[a[i]]++
3. 判断如果a[i]出现的个数大于1 s[a[i]]>1，那么让i指针前面的元素个数s都减1,也就是减到0 s[a[j]]--，同时让j指针向后移 j++，移到i指针的位置，直到让s[a[i]]减到1，才出while循环

模板题代码

//P11最长连续不重复子序列
#include <iostream>
using namespace std;
const int N = 100010;
int n;
int a[N], s[N]; //s[N]记录当前这个区间里每个数出现多少次

int main() {
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> a[i];
	int res = 0;
	for (int i = 0, j = 0; i < n; i++) {
		s[a[i]]++;//i指针向后移动,每个a[i]的s要加1
		while (s[a[i]] > 1) { //如果a[i]出现的个数大于1,那么
			s[a[j]]--;//让i指针前面的元素个数s都减1,也就是减到0
			j++;//让j指针向后移,移到i指针的位置,直到让s[a[i]]减到1,才出while循环
		}
		res = max(res, i - j + 1);
	}
	cout << res << endl;
	return 0;
}

例题

ITCX7121寒假第一周-L数组元素的目标和

例题分析

1. 由于给出的两个数组是递增的，所以指针i从a[0]开始，指针j从b[m-1]开始，如果j>=0&&A[i] + B[j] >x 那么就让j往前走 j--，如果等于x，说明已找到答案

例题代码

//双指针2
//数组元素的目标和

#include <iostream>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N];
int n, m, x;

int main() {
	cin >> n >> m >> x;
	for (int i = 0; i < n; i++)
		cin >> a[i];
	for (int i = 0; i < m; i++)
		cin >> b[i];
	for (int i = 0, j = m - 1; i < n; i++) {
		while ( j >= 0 && a[i] + b[j] > x)
			j--;
		if (j >= 0 && a[i] + b[j] == x) {
			cout << i << " " << j << endl;
			break;//前几次一直错的原因:没加break
		}
	}
	return 0;
}

离散化

简介

与哈希有点相似，好像是一种特殊的哈希
离散化通俗一点就是把离散的点或者说距离很大的点变成紧密的点，压缩数据

模板题

ITCX7121寒假第一周-O区间和

模板题分析

1. 总共有三个位置x、l、r是要进行离散化的，每一个是100000，总共是300000，所以离散化之后有三十万需要储存的数 const int N = 300010;
2. 开数组alls，存所有要离散化的数，add是插入操作，把所有需要用到的下标，也就是要离散化的数，加入到alls数组里去，query数组是要求的
3. 用二分法求出x对应离散化的值，find()函数是求x这个值离散化之后的结果，注意最后映射到1,2,3…n

int find(int x) {//找到第一个大于等于x的位置
	int l = 0, r = alls.size() - 1;
	while (l < r) {
//二分的第一个模板
		int mid = r + l >> 1;
		if (alls[mid] >= x)
			r = mid;
		else
			l = mid + 1;
	}
	return r + 1;//映射到1,2,3...n
}

find函数也可以用STL来写

int find(int x){
	return lower_bound(alls.begin(),alls.end(),x)-alls.begin()+1;
}

4. 将离散化数组alls进行去重：先排序后去重

sort(alls.begin(), alls.end());//将所有值排序
	//如果写了unique()函数也可以写成alls.erase(unique(alls), alls.end());
	//把所有重复的元素删掉,把所有不重复的元素放到前面去,返回新数组的最后一个位置
	//erase()函数把新数组的最后一个位置到原数组的最后一个位置之间的重复元素全都删掉
	alls.erase(unique(alls.begin(), alls.end()), alls.end());

如果没有unique函数，可以手写：

unique()函数实现用的是双指针
vector<int>::iterator unique(vector<int> &a) {
	int j =  0;
	for (int i = 0; i < a.size() - 1; i++)
		if (!i || a[i] != a[i - 1]) //不是第一个数,且不与前一个数相同
			a[j++] = a[i];
//a[0]~a[j-1]是所有a中不重复的数
	return a.begin() + j;
}

5. 最后用前缀和求区间内数字和

模板题完整代码

//离散化
//区间和

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int, int> PII;
//总共有三个位置x,l,r,每一个是100000,所以总共是300000
const int N = 300010;//离散化之后有三十万需要储存的数
int n, m;
int a[N], s[N];//s[N]是前缀和
vector<int>alls;//alls存的所有要离散化的值
vector<PII>add, query;
//add是插入操作,把所有需要用到的下标加入到alls数组里去
// query是求的

//find() 是求x这个值离散化之后的结果
//二分求出x对应的离散化的值
int find(int x) {//找到第一个大于等于x的位置
	int l = 0, r = alls.size() - 1;
	while (l < r) {
//二分的第一个模板
		int mid = r + l >> 1;
		if (alls[mid] >= x)
			r = mid;
		else
			l = mid + 1;
	}
	return r + 1;//映射到1,2,3...n
}

/*

//find函数也可以写成:
int find(int x){
	return lower_bound(alls.begin(),alls.end(),x)-alls.begin()+1;
}
*/

/*
unique()函数实现用的是双指针
vector<int>::iterator unique(vector<int> &a) {
	int j =  0;
	for (int i = 0; i < a.size() - 1; i++)
		if (!i || a[i] != a[i - 1]) //不是第一个数,且不与前一个数相同
			a[j++] = a[i];
//a[0]~a[j-1]是所有a中不重复的数
	return a.begin() + j;
}
*/

int main() {

	cin >> n >> m;
	//先把所有数给读进来,在把需要操作的数离散化
	for (int i = 0; i < n; i++) {
		int x, c;
		cin >> x >> c;//
		add.push_back({x, c});//在下标x的位置加上c
		alls.push_back(x);//先把x加到待离散化的数组alls里去
	}

	for (int i = 0; i < m; i++) {
		int l, r;
		cin >> l >> r;//读入所有的左右区间
		query.push_back({l, r});
		//把左右区间加到待离散化的数组alls里去
		alls.push_back(l);
		alls.push_back(r);
	}

	//去重
	sort(alls.begin(), alls.end());//将所有值排序
	//如果写了unique()函数也可以写成alls.erase(unique(alls), alls.end());
	//把所有重复的元素删掉,把所有不重复的元素放到前面去,返回新数组的最后一个位置
	//erase()函数把新数组的最后一个位置到原数组的最后一个位置之间的重复元素全都删掉
	alls.erase(unique(alls.begin(), alls.end()), alls.end());

	//处理插入
	for (auto item : add) {
		int x = find(item.first);//求x离散化之后的值
		a[x] += item.second;//在离散化之后的坐标位置上加上我们要加上的数
	}

	//预处理前缀和
	for (int i = 1; i <= alls.size() ; i++)
		s[i] = s[i - 1] + a[i];

	//处理查询
	for (auto item : query) {
		int l = find(item.first), r = find(item.second);
		cout << s[r] - s[l - 1] << endl;//中间
	}

	return 0;
}

区间合并

简介

合并所有有交集的区间，可能在某道题目的中间步骤也许会用到区间合并的模板吧

模板题

ITCX7121寒假第一周-P区间合并

模板题分析

1. 先将输入按照区间左侧大小排序排序
2. 当前维护的区间左侧大于老区间右侧ed < seg.first，就说明找到了一个新的区间，就把它加到答案里去，否则当前维护的区间和老区间存在交集，就更新求两个区间，求并集ed = max(ed, seg.second)
3. 核心代码：

for (auto seg : segs)
		if (ed < seg.first) {//此时维护的区间在该区间左端,没有任何交集的话,就说明找到了一个新的区间
			if (st != -2e9)//不能是一开始的初始区间
				res.push_back({st, ed});//就把新的区间加到答案里去
			st = seg.first, ed = seg.second;
		} else//否则,当前维护的区间与该区间有交集,就把当前维护的区间加长,求两个区间的并集
			ed = max(ed, seg.second);

模板题完整代码

//区间合并

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef pair<int, int>PII;
const int N = 100010;
int n;
vector<PII>segs;

//first存区间的左端点,second存区间的右端点
void merge(vector<PII> &segs) {
	vector<PII>res;//答案
	//先把所有区间排序,pair排序在C++里,会优先以左端点排序,其次以右端点排序
	sort(segs.begin(), segs.end());
	int st = -2e9, ed = -2e9;//设边界值,正无穷到f负无穷
	for (auto seg : segs)
		if (ed < seg.first) {//此时维护的区间在该区间左端,没有任何交集的话,就说明找到了一个新的区间
			if (st != -2e9)//不能是一开始的初始区间
				res.push_back({st, ed});//就把新的区间加到答案里去
			st = seg.first, ed = seg.second;
		} else//否则,当前维护的区间与该区间有交集,就把当前维护的区间加长,求两个区间的并集
			ed = max(ed, seg.second);
	if (st != -2e9)//防止输入的区间是空的
		res.push_back({st, ed});//把最后的区间加到答案里去
	segs = res;//把答案区间res更新到segs区间里去
}

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		int l, r;
		cin >> l >> r;//读入每个区间的左右端点
		segs.push_back({l, r});
	}
	merge(segs);//调用区间合并模板

	cout << segs.size() << endl;//返回合并之后的区间的长度
	return 0;
}