C++ 算法基础课 03 —— 基础算法_双指针/位运算/离散化/区间合并

1 双指针算法(滑动窗口)

1.1 模板

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;

    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

1.2 习题1 —— 799.最长连续不重复序列

Acwing 799.最长连续不重复子序列

• 红色指针和绿色指针中间是没有重复数字的，绿色指针是 j，红色指针是 i。判断红绿色指针之间有没有重复数字。红色指针向后移动的话，绿色指针也一定会向后移动，它们之间具有单调性。
• 如果判断之间有重复元素的话，就 j++。
  
• 这里应该是i - j +1, 不是j - i + 1
  
• 使用s[N]来保存a[N]所对应数字的数量，无论是a[i]还是a[j]都会找到相同的对应数字

#include<iostream>
using namespace std;

const int N = 100010;

int n;
int a[N];// 原来数组
int s[N];// j 到 i之间每个数出现的次数

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所指的数字的数量增加1次
        while(s[a[i]] > 1)// 判断哪个数重复了
        {
            s[a[j]] --;// 重复之后，指针j向右移动，所指的数字的数量减少1次，直到a[i]所指的数字的数量降到1为止，表明没有重复
            j ++;//  指针j向右移动1次
        }
        
        res = max(res, i - j + 1);
    }
    cout << res << endl;
    return 0;
}

1.3 习题2 —— 800.数组元素的目标和

Acwing 800.数组元素的目标和

1.4 习题3 —— 816.判断子序列

Acwing 816.判断子序列

2 位运算

2.1 模板

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

求n的第k位数字: n >> k & 1
返回n的最后一位1：lowbit(n) = n & -n

2.1.1 求n的第k位数字

2.1.2 返回n的最后一位1(lowbit函数)

返回n的最后一位1：lowbit(n) = n & -n，相当于lowbit(n) = n & (~n + 1) 取反+1

• lowbit函数
  
• 具体实现步骤
  

2.2 习题1 —— 801.二进制中1的个数(lowbit函数)

Acwing 801.二进制中1的个数

#include<iostream>
using namespace std;

int lowbit(int x)// lowbit函数，返回x的最后一位1。x应该是二进制
{
    return x & -x;// lowbit(n) = n & -n 就是lowbit(n) = n & ~n + 1, 就是取反加1
}

int main()
{
    int n;
    cin >> n;

    while(n--)
    {
        int x;
        cin >> x;
        
        int res = 0;// 最后要置零，否则会叠加
        while(x) x -= lowbit(x), res++;// 每次减去x的最后一个1，这里的x是二进制
        
        cout << res << ' ';
    }
    return 0;
}

• 源码、补码、反码
  

3 离散化(重要!)

3.1 模板

• erase的地方是重复的元素
• unique函数会返回不重复的前面那段最后数字的下标

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

// 二分求出x对应的离散化的值
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(加1表示从1开始映射，不加1表示从0开始映射)
}

3.2 习题1 —— 802.区间和

Acwing 802.区间和

• 特点是数字非常稀疏，需要用离散化方式做
  
• 在x位置加上c，只需要a[x] += c
• 做n次操作，需要n个下标，m次询问，需要2m个下标。所以总共只需要2m+n个下标
• 把用到数组下标映射到从1开始的自然数
  

#include<iostream>
#include<vector>// 使用vector做离散化
#include<algorithm>

using namespace std;

typedef pair<int,int> PII;// 输入n次操作和m次询问，输入对象都是一对int值

const int N = 300010;// 做n次操作，需要n个下标，m次询问，需要2m个下标, 总共只需要2m+n个下标. n好m的范围都是小于100000
int a[N], s[N];

vector<int> alls;// 存入所有需要离散化值的坐标
vector<PII> add, query;// 前面是n次的添加操作，后面是m次的查询操作

// find函数求这个值离散化之后的结果
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;// 将原来的位置x按照大小映射到1, 2, ...n(加1表示从1开始映射)
}

int main()
{
    // 先读入所有的数据，然后将用到的数据进行离散化处理
    int n, m;
    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);// 将坐标x加入到离散化的数组里面
    }
    
    for(int i = 0; i < m; i++)
    {
        int l, r;
        cin >> l >> r;
        query.push_back({l, r});
        
        alls.push_back(l);
        alls.push_back(r);// 把所有需要用到的值的下标都放在了alls里面
    }
    
    // alls数组去重，数的下标值有可能有重复(需要用到模板)
    sort(alls.begin(),alls.end());// 先进行排序
    // unique函数是把里面所有的重复元素删掉，把不重复的数组放到前面去，返回的是新数组最后的位置
    alls.erase(unique(alls.begin(),alls.end()),alls.end());
    
    
    // 处理插入
    for(auto item : add)
    {
        int x = find(item.first);// item.first下标位置x, 使用find函数返回位置x映射的值
        a[x] += item.second;// 在位置x进行值的相加c
    }
    
    // 预处理前缀和
    for(int i = 1; i <= alls.size(); i++) s[i] = s[i - 1]+ a[i];// 这里的i可以取到alls.size()
    
    // 处理查询
    for(auto item : query)
    {
        int l = find(item.first), r = find(item.second);// [l, r]分别映射到左右，item.first就是[l,r]的l
        // 前缀和公式，求[l,r]之间的数字和
        cout << s[r] - s[l-1] << endl;
    }
    return 0;
}

4 区间合并

4.1 模板

// 将所有存在交集的区间合并
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 (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;
}

4.2 习题1 —— 803.区间合并

Acwing 803.区间合并

• 三种情况分析
  

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

using namespace std;

typedef pair<int, int> PII;// 左边first存区间左端点，右边second存区间右端点

const int N = 100010;

vector<PII> segs;

void merge(vector<PII>&segs)// vector本质上是一个动态数组，
{
    vector<PII> res;// 存合并之后结果
    
    sort(segs.begin(),segs.end());// 把所有区间按照左端点从小到大顺序排列
    
    int st = -2e9, ed = -2e9;// 数据范围是大于-1e9, 这里是设计边界值
    for(auto seg : segs)// 从左往右扫描所有区间线段
    {
        if(ed < seg.first)// 维护的区间右端点ed是严格小于枚举的区间的左端点，没有任何交集
        {
            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;// 区间更新为segs
}

int main()
{
    int n;
    cin >> n;// 读入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;
}