基础算法（三）：双指针/位运算/离散化/区间合并

最新推荐文章于 2024-08-18 16:08:01 发布

ScarboroughFair#

最新推荐文章于 2024-08-18 16:08:01 发布

阅读量1.4k

点赞数 5

分类专栏： Acwing基础课文章标签：算法蓝桥杯 c++

本文链接：https://blog.csdn.net/m0_61548909/article/details/125423928

版权

Acwing基础课专栏收录该内容

3 篇文章 3 订阅

订阅专栏

lowbit(x)操作：返回x二进制表示中的最后一位1

3.离散化

4.区间合并

1.双指针算法

引例

输入一行字符串，输出字符串中的单词，每个单词单独占一行

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

    }
    return 0;
}

最长连续不重复子序列

check含义检查区间中是否有重复元素，有的话j++。区间中每个数出现的次数可以通过开辟一个数组S[N]来计算，i往后移动一格相当于在数组中加上一个新的数，S[a[i]]++;j往后移动一格相当于[j,i]数组中出去一个数字，S[a[j]]-- 。此处check(j,i)可写成a[j]不等于a[i]

#include<iostream>

using namespace std;

const int N = 100010;
int n;
int a[N],s[N];

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

    return 0;
}

当i指针向后移动一个数的时候S[i]=1

i再往后移动一格,S[i]=2,执行while

首先剔除1，[j,i]区间中仍有两个2

剔除2，j再往后移动一格

i往后移动一格，此时区间中无重复元素，成立

i再往后移动一格，仍成立

2.位运算

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

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

using namespace std;

int main()
{
    int n =  10;
    for(int k = 3;k>=0;k--)cout<<(n>>k&1);
    return 0;
}

lowbit(x)操作：返回x二进制表示中的最后一位1

通过x&-x实现。C++中-x的二进制表示和~x+1（x取反加1）表示相同

应用：统计x中1的个数，每一次将x中的最后一位1去掉，当x=0时，减的次数即为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++;//每次减去x的最后一位1
        
        cout<<res<<' ';
    }
    return 0;
}

3.离散化

vector<int> alls; // 存储所有待离散化的值
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
}

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

using namespace std;

typedef pair<int,int>PII;//每个操作是两位数，用pair来储存
const int N = 300010;

int n,m;
int a[N],s[N];//a[N]存储数字，S[N]前缀和

vector<int> alls;
vector<PII>add,query;//插入操作和求解操作

int find(int x)//find函数用于求x值离散后的结果
{
    int l = 0,r = alls.size()-1;
    while(l<r)
    {
        int mid = l+r>>1;
        if(alls[mid]>=x)r = mid;//要找>=x的最小的数
        else l = mid + 1;
    }
    return r + 1;//把所有的数映射到从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});//在下标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});//区间的左右端点都是需要离散化的，此处加到query中去
        alls.push_back(l);
        alls.push_back(r);//把左右区间都加入到待离散化的数组中
    }

    //去重
    sort(alls.begin(),alls.end());//排序
    alls.erase(unique(alls.begin(),alls.end()),alls.end());//去掉重复元素
    //unique函数：删除重复元素，所有不重复的元素放到数组的前面去，返回新数组的最后一个位置，把新数组的位置到结尾位置中的冗余元素全部删除，剩下的就是不重复的元素

    //处理插入
    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;
}

每一段相同数第一个数满足的性质，unique函数即取出所有满足该性质的数：通过一个双指针算法，将数组中所有不重复的元素（满足下列性质的数）放到前j个位置

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])
          a[j++] = a[i];

    //a[0]到a[j-1]包含所有a中不重复的数
    return a.begin() + j;
}

使用unique函数

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

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

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])
          a[j++] = a[i];

    //a[0]到a[j-1]包含所有a中不重复的数
    return a.begin() + 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),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;
}

4.区间合并

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

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

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