双指针算法，位运算，离散化和区间合并

最新推荐文章于 2024-08-15 22:41:27 发布

黒猫.

最新推荐文章于 2024-08-15 22:41:27 发布

阅读量221

点赞数 1

分类专栏：数据结构与算法文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/linjianshaonian_/article/details/125806394

版权

数据结构与算法专栏收录该内容

17 篇文章 0 订阅

订阅专栏

双指针算法

双指针算法常用模板：
for（int i=0,j=0;i<n;i++)
{
while(ij<i&&check(i,j)) j++;

//题目具体逻辑
}

双指针算法的目的是将使用两个循环嵌套的时间复杂度O(N^2)优化到O(N),

使用一道简答的题目举例：
题目：输入若干个字符串，字符串与字符串之间用空格隔开，将这些字符串输出到屏幕上。
simplecase 中用到了输入函数gets(),这里也简单介绍一下gets()和 scanf(“%s”,&str) 的区别：

gets()函数

char *gets(char *str) 从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。
gets(str) 约等于 scanf(“%s”,&str) 会把读到的字符串写入数组，但又不同。
区别：
scanf(“%s”,&str) ：读到空格便停止。
gets(str) ：一直读到敲回车（不管中间是否有空格，也就是将空格也读了进去）。

代码实现：

#include<iostream>
#include<string.h>
using namespace std;
const int N=1010;

int main()
{
    char str[N];
    gets(str);

    int len=strlen(str);
    for(int i=0;i<len;i++)
    {
        int j=i;
        while(j<len&&str[j]!=' ')
        {
            j++;
        }

        for(int k=i;k<j;k++)
        {
            cout<<str[k];
        }
        cout<<endl;

        i=j;
    }
    return 0;
}

最长连续不重复子序列

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

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

第二行包含 n 个整数（均在 0∼105 范围内），表示整数序列。

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

数据范围
1≤n≤105
输入样例：
5
1 2 2 3 5
输出样例：
3

直接附上代码（解释在注释中）：

//最长连续子序列
#include<iostream>
using namespace std;
const int N=100010;
int a[N];
int s[N];//表示当前区间内每个元素出现的次数

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }

    int res=0;

    for(int i=0,j=0;i<n;i++)
    {
        s[a[i]]++;//指针I指向元素的出现次数加一
        while(j<i&&s[a[i]]>1)//如果当前指针I所指向的元素的出现次数大于1并且要把j刀i上的所有元素的出现次数都进行统计
        {
            s[a[j]]--;
            j++;
        }
        res=max(res,i-j+1);//比较当前的res和i-j+1获得最大值，
    }

    printf("%d",res);

    return 0;

}

数组元素的目标和

双指针算法有两种法，一种是上边的一个序列由两个指针共同处理，另一种是类似于归并的两个序列分别由两个指针进行处理，

如题目：给定两个升序排序的有序数组 A 和 B，以及一个目标值 x。

数组下标从 0 开始。

请你求出满足 A[i]+B[j]=x 的数对 (i,j)。

数据保证有唯一解。

输入格式
第一行包含三个整数 n,m,x，分别表示 A 的长度，B 的长度以及目标值 x。

第二行包含 n 个整数，表示数组 A。

第三行包含 m 个整数，表示数组 B。

输出格式
共一行，包含两个整数 i 和 j。

数据范围
数组长度不超过 105。
同一数组内元素各不相同。
1≤数组元素≤109
输入样例：
4 5 6
1 2 4 7
3 4 6 8 9
输出样例：
1 1

代码如下：

//数组元素的目标和


/*
双指针算法解决问题的思想都是一样的：先找到题目的暴力做法，然后根据单调性进行优化，
像这道题的，根据已有性质：数组A,数组B都是单调递增的，所以要满足Ai+Bj==x,在A中i不
断增大的过程中，B中j只有不断左移，才能始终满足Ai+Bj>=x;
*/

#include<iostream>
using namespace std;

const int N=100010;

int a[N];//储存数组元素
int b[N];

int main()
{
    int n,m,x;
    scanf("%d%d%d",&n,&m,&x);
    for(int i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }

    for(int j=0;j<m;j++)
    {
        scanf("%d",&b[j]);
    }

    for(int i=0,j=m-1;i<n;i++)//i从左向右，j从右向左
    {
        while(j<m&&a[i]+b[j]<x) j++;
        if(a[i]+b[j]==x) cout<<i<<" "<<j<<endl;
    }

    return 0;
}

判断子序列

给定一个长度为 n 的整数序列 a1,a2,…,an 以及一个长度为 m 的整数序列 b1,b2,…,bm。

请你判断 a 序列是否为 b 序列的子序列。

子序列指序列的一部分项按原有次序排列而得的序列，例如序列 {a1,a3,a5} 是序列 {a1,a2,a3,a4,a5} 的一个子序列。

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

第二行包含 n 个整数，表示 a1,a2,…,an。

第三行包含 m 个整数，表示 b1,b2,…,bm。

输出格式
如果 a 序列是 b 序列的子序列，输出一行 Yes。

否则，输出 No。

数据范围
1≤n≤m≤105,
−109≤ai,bi≤109
输入样例：
3 5
1 3 5
1 2 3 4 5
输出样例：
Yes

代码如下：

//判断子序列

/*
两个子序列都从左向右走，如果两个元素的相等，就让短序列的指针向右挪一位，无论两个元素是否相等，
都让长序列的指针向右挪一位，当循环结束时，如果短序列走到了最后一个位置n，说明短序列的每一个元
素都可以按照顺次序对应到长序列的某一个元素（这个对应的元素一定是第一个如果后边存在相同元素的话）
即说明了这个短序列是长序列的某一个子序列。
*/
#include<iostream>
#include<cstring>
using namespace std;

const int N=100010;

int a[N],b[N];

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    for(int i=0;i<m;i++) scanf("%d",&b[i]);

    int i=0,j=0;
    while(i<n&&j<m)
    {
        if(a[i]==b[j])
            i++;
        j++;
    }

    if(i==n)
        cout<<"Yes"<<endl;
    else
        cout<<"No"<<endl;

    return 0;
}

位运算

位运算的常用操作:
1.求数字n的二进制表示的第K位是几。
1.1先把第k位元素移到最后一位：n>>k;
1.2看数x的个位是几，x&1，比如x=5=101(2),二进制数字的个位是1,因为相当于101&001=1,合并操作：n>>k&1即可得到数字N的第K的数字是多少

2.lowbit(x)操作，属于树状数组的操作，作用是返回数字x的二进制表示的最后一位1，比如：
x=101,返回1；
x=1010;返回10；
x=101000;返回1000;
返回的是一个二进制数，这个1所在的位置就是x的最右边的1的位置
因此可以通过lowbit（x）操作得到数字x的二进制数字中1的个数：

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

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

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

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

数据范围
1≤n≤100000,
0≤数列中元素的值≤109
输入样例：
5
1 2 3 4 5
输出样例：
1 1 2 1 2

代码如下：

//二进制数字中1的个数
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

const int N=100010;
int a[N];
int res[N];

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

int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }

    for(int i=0;i<n;i++)
    {
        while(a[i])
        {
        //每次减掉最右边1的二进制数字，就让1的个数加一
            a[i]-=lowbit(a[i]);
            res[i]++;
        }
    }

    for(int i=0;i<n;i++)
    {
        cout<<res[i]<<" ";
    }

    return 0;
}

离散化

离散化就是把一些很离散的点给重新分配。离散化的特点是可能有很大的值域，但要分配的点的个数很少，将一个长的区间离散化之后获得一个较短的区间，原数组a中的每一个元素都在新数组b中有一个对应位置的元素。离散化的两步操作：

1.由于原数组a中的元素可能是无序并且有重复元素的，需要先对a进行排序和去重：
vector a;//通常使用vector容器存储原数组，
sort(a.begin(),a.end());//排序
a.erase(unique(a,begin(),a,end()),a,end());//去重
有关去重代码的解释：erase()函数的作用是删除这个区间范围内的元素，unique（）的作用是对这个区间内的元素进行去重，并将重复的元素放到数组的尾端，最后返回去重后数组尾端的索引，因此，a.erase()会完成去重工作得到去重后的数组a。
2.二分求出x对应的离散化后的值：
///

atuo的使用

c++11引入了auto类型说明符，auto让编译器通过初始值来推算变量的类型，所以auto定义的变量必须有初始值。
使用auto也能在一条语句中声明多个变量，因为一条声明语句只能有一个基本数据类型，所以该语句中所有变量的初始基本数据类型都必须一样：
eg: auto i=0,*p=& i; //正确 auto sz=0,pi=3.14;//错误，sz和pi的类型不一样。
范围for循环，遍历给定序列中的每个元素并对序列中的每个值执行某种操作。

for(declaration:expression)
statement

declaration表示定义的变量，可以使用auto定义，expression表示一个序列，这个序列可以是STL容器中的序列,expression 部分是一个对象，用于表示一个序列，declaration部分负责定义一个变量，该变量被用于访问序列中的基础元素，每次迭代declaration部分的变量会被初始化为expression部分的下一个元素值。
比如for(auto x:query) statement；每次迭代x变量都会被初始化为vector数组中的query部分的下一个元素。
下面通过一个题目来介绍区间合并：
题目：假定有一个无限长的数轴，数轴上每个坐标上的数都是 0。

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

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

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

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

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

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

数据范围
−109≤x≤109,
1≤n,m≤105,
−109≤l≤r≤109,
−10000≤c≤10000
输入样例：
3 3
1 2
3 6
7 5
1 3
4 6
7 8
输出样例：
8
0
5

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

//开了30万个是因为alls数组中除了存储x还存储了L,r 所以开了3*10^5个
const int N=300010;
//a保存离散化之后的位置对应的内容，s保存前缀和
int a[N],s[N];

typedef pair<int,int> PII;

//保存N次插入操作都插在了哪个位置
vector<int> alls;
//分别存储插入和查询的操作
vector<PII> add,qurey;

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

int main()
{
    int n,m;
    scanf("%d%d",&m,&n);
    for(int i=0;i<n;i++)
    {
        int x,c;
        scanf("%d%d",&x,&c);
        add.push_back({x,c});
        alls.push_back(x);
    }
    
    for(int i=0;i<m;i++)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        qurey.push_back({l,r});
        
        //因为查询的l，r可能不在插入值所给的区间内，所以，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:qurey)
    {
        //l,r对应离散化后的坐标
        int l=find(item.first),r=find(item.second);
        //离散化后到来到10^5的区间，可以使用前缀和求解
        cout<<s[r]-s[l-1]<<endl;
    }
    
    return 0;
}

区间合并

区间合并大概分为两步：
1.对区间进行排序，通常使用pair保存一个区间的左端点和右端点，然后使用vector保存多对这样的值，对vector进行排序是按照先根据区间左端点进行排序，再根据区间右端点进行排序。
2.分类进行处理：在这之前先维护一个区间[st,ed]区间的左右端点的初始值都设置为-2e9,使用这个维护的区间进行处理。
（1）如果当前维护的区间和下一个区间没有交集，则将当前维护区间更新到下一个区间，
（2）如果当前维护的区间和下一个区间有交集，则左端点不变，右端点设置为当前右端点和下一个区间的右端点中较大的那个。
如此反复，直到最后一个区间处理完成，再额外加上最后一个区间。
至此，区间合并完成。
题目：

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

typedef pair<int,int> PII;

vector<PII> segs;

//返回合并后的区间
void merge(vector<PII> &segs)
{
    vector<PII> res;
    
    //pair排序会优先以左端点进行排序，再以右端点进行排序。
    sort(segs.begin(),segs.end());
    
    //分情况讨论：1。如果当前维护区间的右端点小于下一个区间的左端点说明，两个区间没有交集，直接更新到下一个区间
    //2.如果当前维护区间的右端点大于或等于下一个区间的左端点说明，两个区间有交集，使用前一个区间的左端点（左端点不变）
    //和后一个区间的右端点（右端点更新）
    //完成区间的合并，
    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;
    
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        segs.push_back({l,r});
    }
    
    merge(segs);
    
    printf("%d\n",segs.size());
    
    return 0;
}