基础算法学习之路（四）

双指针算法

双指针算法分为两类：
1.两个指针指向同一条线段
2.两个指针分别指向不同的线段

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

核心思想：将暴力做法优化到时间复杂度为O(n)的双指针算法

思路：当i作为区间的右端点时，看j最左能在什么位置，使得i,j之间的距离最大并且ij之间没有重复数字。

int res =0;//先将答案初始化为0
for(int i = 0,j = 0; i < n; i++){
	s[a[i]]++;//s数组表示a数组中每个数出现的次数
	while(s[a[j]] > 1){ //如果一个数出现的次数大于一，
			s[a[j]]--;//就把这个数移出去
			j++;//j指针向后移一位，然后再判断
	 }
	 res = max(res,i-j+);//将答案更新为区间长度的最大值
}

位运算

求n的二进制表示中第k位是几？
如：n = 15 二进制表示为1111
①先把第k位移到最后一位 n>>k
②看个位是几 x &1;
①②结合，即为 n >> k &1;

lowbit(x):返回x的最后一位1
x = 1010 lowbit(x) = 10;
x = 101000 lowbit(x) = 1000;
应用：统计x里1的个数，每一次把x的最后一位1减去，直到x等于零，统计减了多少次。

int lowbit(int x)
{
	return x & -x;
}

int main()
{
	int x; cin >> x;
	int res = 0;
	while(x) x-= lowbit(x),res ++;
	cout << res <<' ';
return 0;
}

离散化

离散化适用于值域比较大，个数比较少，有些需要以值作为下标的题目。
例如：

这个题就是区间长度大，单数用到的点比较少，因此需要对其进行离散化处理。（就是把用到的下标重新映射成从0开始或从1开始的序列，过滤掉那些不用的点）
要解决两个核心问题：
1.下标可能会有重复，（假设本题中，在3这个点多次插入数值） 去重
2.如何算出x离散化后的值是多少（二分法）

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;
const int N = 300010;//离散化之后最多有300000个数，插入操作10^5 （插入操作一次只用到一个坐标） 查询操作10^5*2（左右区间，共两个坐标）
typedef pair<int,int> PII;
vector<int> alls;//用来存储所有要离散化的值
vector<PII> add,query;//存储插入和查询操作
int a[N],s[N];//用来存储数据和前缀和
int n,m;//n次操作，m次询问

int find(int x){//求x离散化后的结果是多少
	int l =0, r = alls.size()-1;
	while(l<r){
	int mid = l + r >> 1;
	if(alls[mid] >= x) r = mid;
	else l = mid + 1;
	}
	return r+1;//映射到1,2,...,n
}

int main(){
	cin >> n >> m;//读入数据
	while(n--){
		int x,c;
		cin >> x >> c;
		alls.push_back(x);
		add.push_back({x,c});
	}
	while(m--){
		int l,r;
		cin >> l >> r;
		alls.push_back(l);
		alls.push_back(r);
		query.push_back({l,r});
	}

	//去重
	sort(alls.begin(),alls.end());
	alls.erase(unique(alls.begin(),alls.end()),alls.end());
	//unique函数将[alls.begin(),alls.end()]区间内不重复的元素放到前面，并且返回重复元素的地址
	
	//插入操作
	for(auto item : add){
	int x = find(item.first);
	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;
}

C++中pair的用法：
1.将两个数据合并成一个数据
2.当一个函数需要返回两个数据的时候，可以返回pair
pair的实现是一个结构体，主要的两个成员是first 和second。因为是使用struct而不是class，所以可以直接使用pair的成员变量

区间合并

思路：
1.将所有区间按照左端点排序
2.扫描所有区间，看是否能够合并
①能够合并的话更新右端点（如果新区间的右端点比原区间的右端点大）
②不能合并的话，区间数加一，再更新左右端点

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

void merge(vector<PII> &segs){
	vector<PII> res;//用来记录所有的区间
	//按照左端点排序
	sort(segs.begin(),segs.end());
	int st = -2e9, ed = -2e9;//将原始左右区间初始化为负无穷
	for(auto seg : segs){
		if(ed<seg.first){//如果不能合并
		if(ed!= -2e9) res.push_back({st,ed});
		st = seg.first,ed = seg.second;
		}
		else{//如果能合并，就把右端点更新为最大的一个
		ed = max(ed,seg.second);
		}
	}
	if(st!=-2e9)//剩下还有一个序列，但循环中未放入res数组，因为他是最后一个序列
	res.push_back({st,ed});
	segs = res;
}

int main(){
	scanf("%d",&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;
}