acwing算法基础课学习笔记1

想在这里分享一些AcWing算法基础课学习时的笔记。第一章一开始没有想到要做笔记，所以笔记很少~
欢迎访问我的主页https://hjh645.github.io/
(>w<)~

双指针算法

所有双指针算法都是O（n）

for(int i = 0; i < n; i++){
	for(int j = 0; j < n; j++)
}

将暴力算法（n2）优化到O（n)

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

eg. 读入一个字符串，读出里面的单词

“abc def ghi”

#include <iostream>
#include <string.h>

using namespace std;

int main() {
	char str[1000];
    
    gets(str);
    
    int n = strlen(str);
    
    for(int i = 0; i < n; i++) {
		int j = i;
        while(j < n && str[j] != ' ') j++;
        
        //这道题的具体逻辑
        for(int k = i; k < j; k++) cout<<str[k];
        
        cout<<endl;
        
        i = j;
    }
}

eg.最长连续不重复子序列

给定一个长度为n的整数序列，找出最长的不包含重复数字的连续子序列，输出它的长度

i:从头往后枚举 j：最左能到什么地方 j是一直往右的。

for(int i = 0, j = 0; i < n; i++) {
	while(j <= i && check(i, j)) j++;
    res = max(res, i - j + 1);
}

#include <iostream>
using namesace std;

int n;
int a[N], s[N]; // s[N]用来确保i j之间没有重复的数字,s[N]表示i,j之间数字的出现次数

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]]++;
		while (s[a[i]] > 1) {
			s[a[j]] --;
			j ++;
		}
		
		res = max(res, i - j + 1);
	}
	
	cout << res;
	return 0;
}

位运算

n的二进制表示中第k位是几

n = 15 = (1111)2

1. 先把第k位移到最后一位 n>>k
2. 看个位是几 x&1
3. 1+2 => n>>k & 1

lowbit(x) : 返回x的最后一位1 实质：取反x+1

x = 1010 lowbit(x) = 10

x= 101000 lowbit(x) = 1000

求x的二进制表示中1的个数

#include <iostream>
using namespace std;

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

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

离散化

整数离散化 保序的离散化

a[] 1 3 100 2000 500000 -> 0 1 2 3 4

1. a[]中可能有重复元素 去重
2. 如何算出x中的值离散化后的值 二分

vector<int> alls; //存储所有待离散化的值
sort(alls.begin(), alls.end());  //将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end()); //去掉重复元素

//二分求出x对应的离散化的值
int find(int 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
}

区间和

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

using namespace std;

typedef pair<int, int> PII;

const int N = 300010;

int n, m;
int a[N], s[N];

vector<int> alls;
vector<PII> add, query; //用来存储询问
// 找大于等于x的最小的数
int find(int 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开始
}

int main() {
    cin >> n >> m;
    for(int i = 0; i < n; i ++ ) {
        int x, c;
        cin >> x >> c;
        add.push_back({x, c});
        
        alls.push_back(x);
    }
    
    for(int i = 0; i < n; i ++ ) {
        int l , r;
        cin >> l >> r;
        query.push_back({l, r});
        
        alls.push_back(l);
        alls.push_back(r);
    }
    
    //去重
    sort(alls.begin(), alls.end());
    alls.erase(unique(alls.begin(), alls.end()), 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;
    }
}

区间合并

给出一组区间，将有重叠的区间合并（端点重叠了也要合并）然后输出合并之后的区间个数

做法：

1. 按区间左端点排序
2. 从左到右扫描区间，每次维护一个区间，其他区间与当前区间的关系有：1. 在区间内部（不用管），2. 与区间有交集（将当前维护的区间右端点换成这个区间的右端点），3. 无交集。之后，再将当前区间放入答案，将当前区间设置为下一个区间

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

using namespace std;

typedef pair<int, int> PII;

const int N = 100010;

int n;
vector<PII> segs;

void merge(vactor<PII> &segs) {
    vector<PII> res;
    
    sort(segs.begin(), segs.end()); //优先以左端点排序
    
    int st = 2e9, ed = -2d9;
    for (auto seg : segs) {
        //已经排序了，所以只要和下一个seg比较，不需要和每个seg比较
        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);
}

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;
}