基础算法---双指针算法、位运算、离散化、区间合并

Next---YOLO

已于 2023-01-03 22:31:25 修改

阅读量78

点赞数

分类专栏： # 算法基础文章标签：算法数据结构排序算法

于 2023-01-02 14:57:40 首次发布

本文链接：https://blog.csdn.net/m0_51366201/article/details/128517147

版权

算法基础专栏收录该内容

20 篇文章 2 订阅

订阅专栏

1.双指针算法

1.1分类

两个指针分别指向不同的序列（归并排序） 对撞指针
两个指针指向一个序列(快排) 快慢指针

1.2模板

所有的双指针算法都是 $O (n)$ 的，将朴素算法优化到 $O (n)$ 。
在这里插入图片描述

1.3核心思想

在这里插入图片描述

1.4最长连续不重复子序列（例题）

给定一个长度为 $n$ 的整数序列，请找出最长的不包含重复的数的连续区间，输出它的长度。

输入格式
第一行包含整数 $n$ 。

第二行包含 $n$ 个整数（均在 $0∼10^{5}$ 范围内），表示整数序列。

输出格式
共一行，包含一个整数，表示最长的不包含重复的数的连续区间的长度。

数据范围
$1≤n≤10^{5}$
输入样例：

5
1 2 2 3 5

输出样例：

3

核心思想

遍历数组a中的每一个元素a[i], 对于每一个i，找到j使得双指针[j, i]维护的是以a[i]结尾的最长连续不重复子序列，长度为i - j + 1, 将这一长度与r的较大者更新给r。
对于每一个i，如何确定j的位置：由于[j, i - 1]是前一步得到的最长连续不重复子序列，所以如果[j, i]中有重复元素，一定是a[i]，因此右移j直到a[i]不重复为止（由于[j, i - 1]已经是前一步的最优解，此时j只可能右移以剔除重复元素a[i]，不可能左移增加元素，因此，j具有“单调性”、本题可用双指针降低复杂度）。
3.用数组s记录子序列a[j ~ i]中各元素出现次数，遍历过程中对于每一个i有四步操作：

cin元素a[i]
将a[i]出现次数s[a[i]]+1
若a[i]重复则右移j（s[a[j]]要减1）
确定j及更新当前长度i - j + 1给r。
代码

#include<iostream>
using namespace std;

const int N = 100010;

int a[N];//原数组
int s[N];//检查重复序列，在此运用了桶排序的思想

int main()
{
    int n;
    cin>>n;
    for(int i = 0;i < n;i++)    cin>>a[i];
    
    int res = 0;
    //双指针算法，j在i前面，j为在i时刻最左边的距离
    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;
}

2.位运算

在这里插入图片描述

2.1二进制中1的个数

给定一个长度为 $n$ 的数列，请你求出数列中每个数的二进制表示中 $1$ 的个数。

输入格式
第一行包含整数 $n$ 。

第二行包含 $n$ 个整数，表示整个数列。

输出格式
共一行，包含 $n$ 个整数，其中的第 $i$ 个数表示数列中的第 $i$ 个数的二进制表示中 $1$ 的个数。

数据范围
$1 \leq n \leq 100000,$
$0 \leq 数列中元素的值 \leq 109$
输入样例：

5
1 2 3 4 5

输出样例：

1 1 2 1 2

#include<iostream>

using namespace std;

//返回x的最后一位1
int lowbit(int x)
{
    return x & -x;
}

int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        int x,res;
        cin>>x;
        //当x不为0时
        while(x) x -= lowbit(x),res++;//每次减去x的最后一位1
        
        cout<<res<<" ";
        res = 0;
    }
    return 0;
}

3.离散化

值域跨度很大，但是很稀疏。
在这里插入图片描述

例题：区间和
假定有一个无限长的数轴，数轴上每个坐标上的数都是 $0$ 。

现在，我们首先进行 $n$ 次操作，每次操作将某一位置 $x$ 上的数加 $c$ 。

接下来，进行 $m$ 次询问，每个询问包含两个整数 $l$ 和 $r$ ，你需要求出在区间 $[l, r]$ 之间的所有数的和。

输入格式
第一行包含两个整数 $n$ 和 $m$ 。

接下来 $n$ 行，每行包含两个整数 $x$ 和 $c$ 。

再接下来 $m$ 行，每行包含两个整数 $l$ 和 $r$ 。

输出格式
共 $m$ 行，每行输出一个询问中所求的区间内数字和。

数据范围
$- 109 \leq x \leq 109,$
$1 \leq n, m \leq 105,$
$- 109 \leq l \leq r \leq 109,$
$- 10000 \leq c \leq 10000$
输入样例：

3 3
1 2
3 6
7 5
1 3
4 6
7 8

输出样例：

8
0
5

在这里插入图片描述

代码

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef pair<int,int> PII;//定义一个二元组来存放插入和删除数据

const int N = 300010;//在此可能很多人对为什么是300010比较疑惑
//因为插入（一个坐标）和查询（有两个坐标）各是100000，所有就要比300000大

int n,m;
int a[N],s[N];//a数组存的数，s数组是前缀和

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开始的自然数
    //因为使用前缀和，其下标要+1可以不考虑边界问题
}

/*
unique底层原理
vector<int>::iterator unique(vector<int> &a) {
    int j = 0;
    for (int i = 0; i < a.size(); ++i) {
        if (!i || a[i] != a[i - 1])//如果是第一个元素或者该元素不等于前一个元素，
        即不重复元素，我们就把它存到数组前j个元素中
            a[j++] = a[i];//每存在一个不同元素，j++
    }
    return a.begin() + j;//返回的是前j个不重复元素的下标
}

*/
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 < m; 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);
        int r = find(item.second);
        cout<<s[r] - s[l - 1]<<endl;
    }
    return 0;
}

4.区间合并

在这里插入图片描述
例题：区间合并
给定 $n$ 个区间 $l_{i},r_{i}]$ ，要求合并所有有交集的区间。

注意如果在端点处相交，也算有交集。

输出合并完成后的区间个数。

例如： $[1, 3]$ 和 $[2, 6]$ 可以合并为一个区间 $[1, 6]$ 。

输入格式
第一行包含整数 $n$ 。

接下来 $n$ 行，每行包含两个整数 $l$ 和 $r$ 。

输出格式
共一行，包含一个整数，表示合并区间完成后的区间个数。

数据范围
$1 \leq n \leq 100000,$
$10^{9}≤l_{i}≤r_{i}≤10^{9}$
输入样例：

5
1 2
2 4
5 6
7 8
7 9

输出样例：

3

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

using namespace std;

typedef pair<int, int> PII;

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

    //两个作用
    //1.是防止n为0，把[-无穷，-无穷]压入
    //2.是压入最后一个（也就是当前）的区间，若n>=1，if可以不要
    if (st != -2e9) res.push_back({st, ed});

    segs = res;
}

int main()
{
    int n;
    scanf("%d", &n);

    vector<PII> segs;
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        segs.push_back({l, r});
    }

    merge(segs);

    cout << segs.size() << endl;

    return 0;
}