经典基础算法

已于 2022-10-19 17:21:29 修改
阅读量1.3k 收藏 10
点赞数
分类专栏： 算法 文章标签： 算法 蓝桥杯 c++ 排序算法 数据结构
于 2022-03-15 14:48:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45730605/article/details/127219263
版权

目录

基础算法

快速排序

1.快速排序

2.第k个数

归并排序

3.归并排序

4. 逆序对的数量

二分

5.数的范围

6.数的三次方根

高精度

7.高精度加法

8.高精度减法

9.高精度乘法

10.高精度除法

前缀和与差分

11.前缀和

12.子矩阵的和

13.差分

14.差分矩阵

双指针算法

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

16.数组元素的目标和

17.判断子序列

位运算

18.二进制中1的个数

离散化

19.区间和

区间合并

20.区间合并

基础算法

快速排序

1.快速排序

给定你一个长度为 n 的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n 个整数(所有整数均在 1∼109 范围内)，表示整个数列。

输出格式

输出共一行，包含 n 个整数，表示排好序的数列。

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5
//快速排序，从大到小划分，先排两边，递归地向下细分,每次分完 j在i前或者两个相等

#include<iostream>
using namespace std;
const int N=1e5+10;
int q[N];
int n;
//快速排序模板，熟练掌握
void quick_sort(int q[],int l,int r){
    //递归终止条件
    if(l==r) return;
    
    //划分加交换
    int i=l-1,j=r+1,x=q[(l+r)/2];
    while(i<j){
        do i++;while(x>q[i]);
        do j--;while(x<q[j]);
        if(i<j) swap(q[i],q[j]);
    }
    
    //细分
    quick_sort(q,l,j);
    quick_sort(q,j+1,r);
}


int main(){
    cin>>n;
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    quick_sort(q,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",q[i]);
    return 0;
}

2.第k个数

给定一个长度为 n 的整数数列，以及一个整数 k，请用快速选择算法求出数列从小到大排序后的第 k 个数。

输入格式

第一行包含两个整数 n 和 k。

第二行包含 n 个整数(所有整数均在 1∼109 范围内)，表示整数数列。

输出格式

输出一个整数，表示数列的第 k 小数。

数据范围

1≤n≤100000,
1≤k≤n

输入样例：

5 3
2 4 1 5 3

输出样例：

3
//自己做法，直接弄个快速排序求第k个数
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N];
int n,k;
void quick_sort(int q[],int l,int r){
    if(l==r) return;
    int i=l-1,j=r+1,x=q[(l+r)/2];
    while(i<j){
        do i++;while(q[i]<x);
        do j--;while(q[j]>x);
        if(i<j) swap(q[i],q[j]);
    }
    
    quick_sort(q,l,j);
    quick_sort(q,j+1,r);  
}
int main(){
    cin>>n>>k;
    for(int i=0;i<n;i++) cin>>a[i];
    quick_sort(a,0,n-1);
    cout<<a[k-1]<<endl;
}
//快排基础上改进，每次都分到第k个数的那边
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N];
int n,k;
int quick_sort(int q[],int l,int r,int k){
    if(l==r) return q[l];
    int i=l-1,j=r+1,x=q[(l+r)/2];
    while(i<j){
        do i++;while(q[i]<x);
        do j--;while(q[j]>x);
        if(i<j) swap(q[i],q[j]);
    }
    if(j-l+1>=k) quick_sort(q,l,j,k);
    //要注意将第k个数写进函数需替换成当前的第k-(j-l+1)个数
    else quick_sort(q,j+1,r,k-(j-l+1));  
}
int main(){
    cin>>n>>k;
    for(int i=0;i<n;i++) cin>>a[i];
    cout<<quick_sort(a,0,n-1,k)<<endl;
}

归并排序

3.归并排序

给定你一个长度为 n 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n 个整数(所有整数均在 1∼109 范围内)，表示整个数列。

输出格式

输出共一行，包含 n 个整数，表示排好序的数列。

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5
//归并排序，从小到大合并，先划分，再合并。

#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],tmp[N];
int n;
void merge_sort(int a[],int l,int r){
    if(l==r) return;
    //划分，以mid为界限
    int mid=(l+r)/2;
    merge_sort(a,l,mid),merge_sort(a,mid+1,r);

    //归并，
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r){
        if(a[i]<a[j]) tmp[k++]=a[i++];
        else tmp[k++]=a[j++];
    }
    //归并中的扫尾工作
    while(i<=mid) tmp[k++]=a[i++];
    while(j<=r) tmp[k++]=a[j++];
    
    //赋值回原数组
    for(i=l,k=0;i<=r;i++,k++)
        a[i]=tmp[k];
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    merge_sort(a,0,n-1);
    for(int i=0;i<n;i++) cout<<a[i]<<" ";
    return 0;
}

4. 逆序对的数量

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。

输入格式

第一行包含整数 n，表示数列的长度。

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

输出格式

输出一个整数，表示逆序对的个数。

数据范围

1≤n≤100000，
数列中的元素的取值范围[1,109]。

输入样例：

6
2 3 4 5 6 1

输出样例：

5
//求逆序对
//在分治后的每一层合并中顺便求出逆序对数量是这个题想法的由来，
//归并排序分治我们求的是从小到大的顺序，我们所求的逆序对恰好是逆序数量，与归并排序不谋而合。
//例如[3,4,1,2]中q[0]>q[2],则q[0],q[1]都与q[2]成逆序对,而q[mid]与q[i]有mid-i+1个数字，因此逆序对增加mid-i+1
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],tmp[N];
int n;
typedef long long ll;
ll merge_sort(int a[],int l,int r){
    
    //递归结束条件    
    if(l==r) return 0;
    
    //划分
    int mid=(l+r)/2;
    ll res=merge_sort(a,l,mid)+merge_sort(a,mid+1,r);
    
    //归并
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r){
        if(a[i]<=a[j]) tmp[k++]=a[i++];
        else{
            tmp[k++]=a[j++];
            res+=mid-i+1;
        }
    }
    
    
    //收尾
    while(i<=mid) tmp[k++]=a[i++];
    while(j<=r) tmp[k++]=a[j++];
    
    //赋值回原数组
    for(int i=l,j=0;i<=r;i++,j++)  a[i]=tmp[j];
    
    return res;
}

int main(){
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    cout<<merge_sort(a,0,n-1)<<endl;
    return 0;
}

二分

5.数的范围

给定一个按照升序排列的长度为 n 的整数数组，以及 q 个查询。

对于每个查询，返回一个元素 k 的起始位置和终止位置(位置从 0 开始计数)。

如果数组中不存在该元素，则返回 -1。

输入格式

第一行包含整数 n 和 q，表示数组长度和询问个数。

第二行包含 n 个整数(均在 1∼10000 范围内)，表示完整数组。

接下来 q 行，每行包含一个整数 k，表示一个询问元素。

输出格式

共 q 行，每行包含两个整数，表示所求元素的起始位置和终止位置。

如果数组中不存在该元素，则返回 -1。

数据范围

1≤n≤100000
1≤q≤10000
1≤k≤10000

输入样例：

6 3
1 2 2 3 3 4
3
4
5

输出样例：

3 4
5 5
-1 -1
//整数二分
#include<iostream>

using namespace std;
const int N = 1e5 + 10;
int a[N];
int n, q;

int main() {
    cin >> n >> q;
    for (int i = 0; i < n; i++) cin >> a[i];
    while (q--) {
        int x;
        scanf("%d", &x);
        int l = 0, r = n - 1;
        int mid;
        
        //分左边界
        while (l < r) {
            mid = (l + r) / 2;
            if (a[mid] >= x) r = mid;
            else l = mid + 1;
        }
      
        if (a[l] != x) cout << -1 << " " << -1 << endl;
        
        else {
            cout<<l<<" ";
            l = 0, r = n - 1;
            //分右边界
            while (l < r) {
                //因为l=mid,如果不加1,两个值差1的时候会等于l，会陷入死循环
                mid = (l + r + 1) / 2;
                if (a[mid] <= x) l = mid;
                else r = mid - 1;
            }

            cout << r << endl;
        }

    }
    return 0;
}

6.数的三次方根

给定一个浮点数 n，求它的三次方根。

输入格式

共一行，包含一个浮点数 n。

输出格式

共一行，包含一个浮点数，表示问题的解。

注意，结果保留 6 位小数。

数据范围

−10000≤n≤10000

输入样例：

1000.00

输出样例：

10.000000
//浮点数二分
//-22~22之间用二分法即可
#include<iostream>
using namespace std;
int main(){
    double x;
    double l=-22,r=22;
    double mid;
    cin>>x;
    //浮点数二分中，区间不能设置r>l,因为r永远也大不了l,只能无限接近。
    while(r-l>1e-10){
        mid=(l+r)/2;
        if(mid*mid*mid>=x) r=mid;
        else l=mid;
    }
   printf("%lf\n",l);
    return 0;
}

高精度

7.高精度加法

给定两个正整数(不含前导 0)，计算它们的和。

输入格式

共两行，每行包含一个整数。

输出格式

共一行，包含所求的和。

数据范围

1≤整数长度≤100000

输入样例：

12
23

输出样例：

35
//只有加法无前导码
#include<iostream>
#include<vector>
using namespace std;
string a,b;
vector<int> A,B;
vector<int> add(vector<int>&A,vector<int>&B){
    int t=0;
    vector<int> C;
    //核心进位加法
    for(int i=0;i<A.size()||i<B.size();i++){
        if(i<A.size()) t+=A[i];
        if(i<B.size()) t+=B[i];
        C.push_back(t%10);
        t=t/10;
    }
    if(t) C.push_back(t);
    return C;
}
int main(){
    cin>>a>>b;
    //输入
    for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
    for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    auto C=add(A,B);
    //输出
    for(int i=C.size()-1;i>=0;i--) cout<<C[i];
    cout<<endl;
    return 0;
}

8.高精度减法

给定两个正整数(不含前导 0)，计算它们的差，计算结果可能为负数。

输入格式

共两行，每行包含一个整数。

输出格式

共一行，包含所求的差。

数据范围

1≤整数长度≤105

输入样例：

32
11

输出样例：

21
//减法有前导码
#include<iostream>
#include<vector>
using namespace std;
vector<int> A, B;
string a, b;

//比较大小
bool cmp(vector<int> A, vector<int> B) {
    if (A.size() != B.size()) return A.size() > B.size();
    for (int i = A.size() - 1; i >= 0; i--) {
        if (A[i] != B[i])
            return A[i] > B[i];
    }
    return true;
}
//做减法
vector<int> sub(vector<int> &A, vector<int> &B) {
    vector<int> C;
    int t = 0;
    for (int i = 0; i < A.size(); i++) {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }
    //删除前导码
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;

}

int main() {
    cin >> a >> b;
    for (int i = a.size()-1; i >= 0; i--) A.push_back(a[i] - '0');
    for (int i = b.size()-1; i >= 0; i--) B.push_back(b[i] - '0');

    if (cmp(A, B)) {
        auto C = sub(A, B);
        for (int i = C.size() - 1; i >= 0; i--) cout << C[i];
        cout << endl;
    } else {
        auto C = sub(B, A);
        cout << "-";
        for (int i = C.size() - 1; i >= 0; i--) cout << C[i];
        cout << endl;

    }


    return 0;
}

9.高精度乘法

给定两个非负整数(不含前导 0) A 和 B，请你计算 A×B 的值。

输入格式

共两行，第一行包含整数 A，第二行包含整数 B。

输出格式

共一行，包含 A×B 的值。

数据范围

1≤A的长度≤100000,
0≤B≤10000

输入样例：

2
3

输出样例：

6
#include<iostream>
#include<vector>

using namespace std;
string a;
int b;
vector<int> A;
//高精度乘法
vector<int> mul(vector<int> &A, int b) {
    vector<int> C;
    int t = 0;
    //累计加法，不用担心数据丢失
    for (int i = 0; i < A.size(); i++) {
        t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }
    if (t) C.push_back(t);
    //需要去除前导码
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main() {
    cin >> a >> b;

    for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');

    auto C = mul(A, b);
    for (int i = C.size() - 1; i >= 0; i--) cout << C[i];
    cout << endl;
    return 0;
}

10.高精度除法

给定两个非负整数(不含前导 0) A，B，请你计算 A/BA/B 的商和余数。

输入格式

共两行，第一行包含整数 A，第二行包含整数 B。

输出格式

共两行，第一行输出所求的商，第二行输出所求余数。

数据范围

1≤A的长度≤100000，
1≤B≤10000,
B 一定不为 0

输入样例：

7
2

输出样例：

3
1
#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

vector<int> A;

vector<int> div(vector<int> A, int b, int &r) {
    r = 0;
    vector<int> C;
    for (int i = A.size() - 1; i >= 0; i--) {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r = r % b;//求余
    }
    reverse(C.begin(), C.end());
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;

}
//输入，输出基本不变
int main() {
    int r, b;
    string a;
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
    auto C = div(A, b, r);
    for (int i = C.size() - 1; i >= 0; i--) cout << C[i];
    cout << endl << r;
}

前缀和与差分

11.前缀和

输入一个长度为 n 的整数序列。

接下来再输入 m 个询问，每个询问输入一对 l,r。

对于每个询问，输出原序列中从第 l 个数到第 r 个数的和。

输入格式

第一行包含两个整数 n 和 m。

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

接下来 m 行，每行包含两个整数 l 和 r，表示一个询问的区间范围。

输出格式

共 m 行，每行输出一个询问的结果。

数据范围

1≤l≤r≤n,
1≤n,m≤100000,
−1000≤数列中元素的值≤1000

输入样例：

5 3
2 1 3 6 4
1 2
1 3
2 4

输出样例：

3
6
10
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],s[N];
int n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    //求一维前缀和
    for(int i=1;i<=n;i++) s[i]=s[i-1]+a[i];
    while(m--){
        int l,r;
        cin>>l>>r;
        //求一维差值
        cout<<s[r]-s[l-1]<<endl;
    }
    return 0;
}

12.子矩阵的和

输入一个 n 行 m 列的整数矩阵，再输入 q 个询问，每个询问包含四个整数 x1,y1,x2,y2，表示一个子矩阵的左上角坐标和右下角坐标。

对于每个询问输出子矩阵中所有数的和。

输入格式

第一行包含三个整数 n，m，q。

接下来 n 行，每行包含 m 个整数，表示整数矩阵。

接下来 q 行，每行包含四个整数 x1,y1,x2,y2，表示一组询问。

输出格式

共 q 行，每行输出一个询问的结果。

数据范围

1≤n,m≤1000,
1≤q≤200000,
1≤x1≤x2≤n,
1≤y1≤y2≤m,
−1000≤矩阵内元素的值≤1000

输入样例：

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

输出样例：

17
27
21
#include<iostream>

using namespace std;
const int N = 1e3 + 10;
int a[N][N], s[N][N];
int n, m, q;

int main() {
    cin >> n >> m >> q;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> a[i][j];

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            //前缀和二维公式
            s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
    while (q--) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        //求二维差值
        cout << s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1] << endl;
    }
    return 0;
}

13.差分

输入一个长度为 n 的整数序列。

接下来输入 m 个操作，每个操作包含三个整数 l,r,c，表示将序列中 [l,r] 之间的每个数加上 c。

请你输出进行完所有操作后的序列。

输入格式

第一行包含两个整数 n 和 m。

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

接下来 m 行，每行包含三个整数 l，r，c，表示一个操作。

输出格式

共一行，包含 n 个整数，表示最终序列。

数据范围

1≤n,m≤100000,
1≤l≤r≤n,
−1000≤c≤1000,
−1000≤整数序列中元素的值≤1000

输入样例：

6 3
1 2 2 1 2 1
1 3 1
3 5 1
1 6 1

输出样例：

3 4 5 3 4 2
#include<iostream>

using namespace std;
const int N = 1e5 + 10;
int a[N], b[N];

void insert(int l, int r, int x) {
    b[l] += x;
    b[r + 1] -= x;
}

int main() {
    int n, m;
    cin >> n >> m;
    //难点，差分数组初始为0，插入类似于区间加值而已
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        insert(i, i, x);
    }
    while (m--) {
        int l, r, x;
        cin >> l >> r >> x;
        insert(l, r, x);
    }
    for (int i = 1; i <= n; i++)
        a[i] = a[i - 1] + b[i];
    for (int i = 1; i <= n; i++)
        cout << a[i] << " ";
    cout << endl;
    return 0;
}

14.差分矩阵

输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。

每个操作都要将选中的子矩阵中的每个元素的值加上 c。

请你将进行完所有操作后的矩阵输出。

输入格式

第一行包含整数 n,m,q。

接下来 n 行，每行包含 m 个整数，表示整数矩阵。

接下来 q 行，每行包含 5 个整数 x1,y1,x2,y2,c，表示一个操作。

输出格式

共 n 行，每行 m 个整数，表示所有操作进行完毕后的最终矩阵。

数据范围

1≤n,m≤1000,
1≤q≤100000,
1≤x1≤x2≤n,
1≤y1≤y2≤m,
−1000≤c≤1000,
−1000≤矩阵内元素的值≤1000

输入样例：

3 4 3
1 2 2 1
3 2 2 1
1 1 1 1
1 1 2 2 1
1 3 2 3 2
3 1 3 4 1

输出样例：

2 3 4 1
4 3 4 1
2 2 2 2
#include<iostream>

using namespace std;
const int N = 1e3 + 10;
int a[N][N], b[N][N];

void insert(int x1, int y1, int x2, int y2, int x) {
    //二维数组的添加和打补丁 4步法
    b[x1][y1] += x;
    b[x1][y2 + 1] -= x;
    b[x2 + 1][y1] -= x;
    b[x2 + 1][y2 + 1] += x;
}

int main() {
    int n, m, q;
    cin >> n >> m >> q;

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) {
            int x;
            cin >> x;
            insert(i, j, i, j, x);
        }
    while (q--) {
        int x1, y1, x2, y2, x;
        cin >> x1 >> y1 >> x2 >> y2 >> x;
        insert(x1, y1, x2, y2, x);
    }
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            //求前缀和的公式
            a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1] + b[i][j];

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++)
                cout << a[i][j]<<" ";
            cout << endl;
        }
        return 0;
}

双指针算法

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

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

输入格式

第一行包含整数 n。

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

输出格式

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

数据范围

1≤n≤105

输入样例：

5
1 2 2 3 5

输出样例：

3
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;

int a[N],s[N];
int n,res;
int main(){
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0,j=0;i<n;i++){
        s[a[i]]++;
        //不需要判断j<=i,同时满足单调性，因为若大区间无重复的数所以小区间也无重复的数
        while(s[a[i]]>1){
            s[a[j]]--;
            j++;
        }
        res=max(res,i-j+1);
    }
    cout<<res;
    return 0;
}

16.数组元素的目标和

给定两个升序排序的有序数组 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
//有序数组，一个往右遍历，一个往左遍历即可,绝对能保证唯一性
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],b[N];
int main(){
    int n,m,s;
    cin>>n>>m>>s;
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<m;i++) cin>>b[i];
    for(int i=0,j=m-1;i<n;i++){
        //每一个i找一个最靠左的j
        while(j>=0&&b[j]+a[i]>s) j--;
        if(a[i]+b[j]==s) {
            cout<<i<<" "<<j<<endl;
            return 0;
        }
    }
    return 0;
}

17.判断子序列

给定一个长度为 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
//思路 两个都从0开始，匹配成功了a就往后走一步，匹配不成功b就往后走一步，到最后只要a走完了就输出yes，否则就输出no
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],b[N];
int n,m;
int main(){
    cin>>n>>m;
    
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<m;i++) cin>>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;
}

位运算

18.二进制中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
最常用的两种操作
整数n的二进制表示中第k位是几
n=15=1111 个位是第0位，十位是第一位
n>>k&1 

lowbit(x):返回x的最后一位1
x&-x  返回二进制从最后一个1开始的十进制的值
x=1010-->10
x=101000-->1000
#include<iostream>
using namespace std;
const int N=1e5+;
int a[N],b[N];
int lowbit(int x){
    return x&-x;
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
         cin>>a[i];
        while(a[i]){
            a[i]-=lowbit(a[i]);//求最后一位1
            b[i]++;
        }
    }
    for(int i=0;i<n;i++) cout<<b[i]<<" ";
    cout<<endl;
    return 0;
}

离散化

19.区间和

假定有一个无限长的数轴，数轴上每个坐标上的数都是 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<vector>
#include<algorithm>

using namespace std;
const int N = 3e5 + 10;
int a[N], s[N];
typedef pair<int, int> PII;
vector<int> alls;
vector<PII> add, query;

int find(int x) {
    int l = 0, r = alls.size() - 1;
    int mid;
    //返回的是第一个大于等于x的下标
    while (l < r) {
        mid = (l + r) / 2;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 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);
    }
    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());
    //将x中的下标加上数
    for (int i = 0; i < n; i++) {
        int x = find(add[i].first);
        a[x] += add[i].second;
    }
    for (int i = 1; i <= alls.size(); i++)
        s[i] = s[i - 1] + a[i];
    for (int i = 0; i < m; i++) {
        int l = find(query[i].first);
        int r = find(query[i].second);
        cout << s[r] - s[l - 1] << endl;
    }

    return 0;
}

区间合并

20.区间合并

给定 n 个区间 [li,ri]，要求合并所有有交集的区间。

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

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

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

输入格式

第一行包含整数 n。

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

输出格式

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

数据范围

1≤n≤100000,
−109≤li≤ri≤109

输入样例：

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;
vector<PII> segs;

void merge(vector<PII> &segs) {
    vector<PII> c;
    int l = -2e9, r = -2e9;
    sort(segs.begin(), segs.end());
    for (auto item:segs) {
        if (r < item.first) {
            if (r != -2e9) c.push_back({l, r});
            l = item.first;
            r = item.second;
        } else
            r = max(item.second, r);
    }
    if (l != -2e9) c.push_back({l, r});
    segs = c;
}

int main() {
    int n;
    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;
}
迟意..
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python常见基础算法题
海里鱼的技术博客
07-06 4373
1.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数. 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 示例 3: 输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。 def is_num(num): ''' 判断传递的参数是否是回文数 :param num: 传递的
718. 实验
一个字，学
04-15 990
718. 实验 医学部一共进行了 N 场动物实验。 共有三种小动物可用来实验，分别是青蛙、老鼠和兔子。 每次实验都会选取其中一种动物来参与实验，选取数量若干。 现在请你统计一下医学部一共用了多少小动物，每种分别用了多少，每种动物使用数量占总量的百分比分别是多少。 输入格式 第一行包含整数 N，表示实验次数。 接下来 N 行，每行包含一个整数 A（表示一次实验使用的小动物的数量）和一个字符 T（表示一次实验使用的小动物的类型，C 表示兔子(coney)，R 表示老鼠(rat)，F 表示青蛙(frog)）。 输
PAT甲级刷题记录-(AcWing)-(Day04排序)
Weary_PJ的博客
05-18 353
PAT甲级刷题记录-(AcWing)-(Day04排序) 课程来源AcWing 其中AcWing中的题目为翻译好的中文题目 今日刷题列表 1012 The Best Rank 1012 The Best Rank AcWing链接 PAT链接 英语单词 evaluate 评估 评价 At the mean time 与此同时 with respect to 关于 解析 使用map来存储学生的信息 分别对每个成绩建立一个vecor 对其排序,在查询学生成绩的时候在排好序的vector里面找
AcWing 刷题计划：0x10 基本数据结构—— AcWing 135. 最大子序和
weixin_46175963的博客
06-16 231
1.题目描述： 2.题意： 略。 3.思路： 单调队列+前缀和。 （看标签做题系列 TTwTT）这道题目乍一看以为要dp，但是认真看题，发现他要求长度在m以内，这种在某个长度以内或者某个长度以外的，一般都是单调队列。 我们维护一个递增的单调队列，维护前缀和。 为啥维护递增的前缀和队列呢？由于我们要求一段连续区间的最大和，那么我们维护前缀和的最小值，对于某些区间，我们可以直接减去最小值，就是符合条件的区间和了呀！又由于是最小值，得到的值必定是最大值。 算法思路： 1）我们预处理出所有的前缀和。 2）对于1-
AcWing 刷题计划：0x00基础算法——AcWing 113. 特殊排序
weixin_46175963的博客
06-03 229
1.题目描述： 2.题意： 给你一个cmp函数，你可以进行不超过10000次的调用，然后输出所需要的序列，这个序列满足左边的值小于右边的值，但是并不具有传递性，就是a<b,b<c,a≮ c，所以答案不唯一。 3.思路： 二分+插入排序。 对于一个排序好的数列，如果来了一个数k，我们就是要找到 t 和 l 使得 t<k<l，因为有序，我们对于t<k 那么t的右边一定存在 l 使得k<l 。那么我们就二分找到这样的位置，然后通过插入排序到达就行了。 4.代码： // For
Acwing 刷题指南
Harrytsz的博客
02-12 1677
Acwing 刷题指南 1. 二分 LeetCode 69. Sqrt(x) LeetCode 35. Search Insert Position LeetCode 34. Find First and Last Position of Element in Sorted Array LeetCode 74. Search a 2D Matrix LeetCode 153. Find Mini...
08-2：Python课程 教程 进阶 案例 算法：经典基础算法、2048游戏核心算法
最新发布
03-12
首先，让我们关注经典基础算法。算法是解决问题或执行任务的明确步骤，是编程的基础。在Python中，常见的基础算法包括排序（如冒泡排序、快速排序）、搜索（如二分查找）、图算法（如Dijkstra算法、Floyd-Warshall...
经典基础算法教案教程
06-04
### 经典基础算法教案教程知识点详析 #### 一、算法简介 算法是计算机科学中的核心概念之一，它是一系列解决特定问题的步骤或规则集合。在算法设计与分析中，我们关注的是如何有效地解决问题，包括但不限于排序、...
C语言的100个经典算法
03-27
C语言的100个经典算法，面试必考，c coder掌握，经典c算法程序讲解
基础算法acwing刷题指南6
Demilly123的博客
05-05 918
acwing刷题指南6（基础算法）
AcWing 算法基础课 排序总结（持续更新中······）
峰峰爱吃肉
10-28 559
本博客只基于AcWing刷题总结，话不多说，先上总图 快速排序 题目链接:AcWing 785.快速排序 快速排序思想：主要思想是分治。先任意取一个数x（一般取区间中间那个数），然后把小于x的数放在x的左边，大于x的数放在x的右边，然后依次递归下去，最后得到的就一定是有序的。(PS:快排最差时间复杂度为O(n2)O(n^{2})O(n2)。 AC代码如下： #include<bits/stdc++.h> using namespace std; const int MAXN = 1e5 +
AcWing刷题笔记（一）基础算法
一个憨憨写的胡言乱语
05-20 1029
算法基础课基础算法快速排序快速排序第K个数归并排序三级目录 基础算法 快速排序 快速排序 #include <iostream> using namespace std; const int N=1e6+10; int q[N]; int n; void quick_sort(int q[],int l,int r) { if(l>=r)return; int x=q[(l+r)/2],i=l-1,j=r+1; while(i<j) { do i++;while(q[
简单的排序算法
csdnwqy030429的博客
01-12 1334
快速排序、归并排序与桶排序快速排序归并排序桶排序 已经不知道多长时间没写博客了，，，，期末考完的我当然要开始继续写了（虽然期末考的很垃圾），前段时间给蓝桥杯捐了300r，寒假不学点算法感觉对不起这钱，就写写博客来记录学习历程并当作复习吧。 使用C++更适合参加这类比赛，我们也不用担心要学一门新语言，因为只是学算法的话用的也就是C和C++的STL，而这些STL我们只需要一个一个积累就行了，就是用到一个就学习一个，而且也可以自己用数组实现，所以算法学习应该是不需要太多基础的，但是，请一定要熟悉递归、递推等基本内
【AcWing算法基础】第二讲 数据结构
flowral的博客
10-20 683
1、单链表 2、双链表 3、栈 3.1 模拟栈 3.2 表达式求值 4、队列 5、单调栈 6、单调队列 7、KMP 8、Trie 9、并查集
数据结构进阶
qq_45382931的博客
02-04 656
并查集 朴素版 const int N = 1e5 + 10; int p[N]; //返回x的祖宗节点 int find(int x){ //只有根节点才会有p[x]=x if(p[x] != x) p[x] = find(p[x]); return p[x]; } //初始化 void init(){ //初始每个点都是根节点 for (int i = 1; i <= n; i ++ )p[i] = i; } //合并a，b的两个根节点 void m
快速排序（双指针算法和递归）C++
weixin_60291058的博客
09-21 400
思想讲解：在一个线性数组上，设置两个指针（双指针算法），一个指向数组开头，一个指向数组末尾，然后选一个中间值，用中间值作为一个标准，把数组分为两个部分，中间值左边比中间值小，中间值右面的比中间值大。 进行的操作就是不断比较两端的值和中间值的关系，如果发现有不符合这个标准的数组值，则进行两个指针的交换。 下面看代码，c++实现的。 #include <iostream> #include <algorithm> #include <cstring> using nam
c++编程小常识
time_limited的博客
06-02 460
记录一些c++编程中用得着的小常识，先说一下环境： 系统：windows 10 x64 1909 编译软件：CodeBlocks 20.03 编程语言：C++ 编译器：编程软件自带编译器 int的最大值、最小值 int占4字节 32bit int 的最大值 2147483647 int 的最小值 -2147483648 系统中有定义好的int型的最大值与最小值，其他类型有没有我没看，不常用。 #include<iostream> using namespace std; int main()
ACWing基础算法第一课
qq_44653420的博客
02-25 616
ACWing基础算法第一课 算法模板先背调，写过的题目再写一遍 一、排序算法 1.快速排序 一般做法： 确定分界点x:q[l],q[(l+r)/2],q[r] 随机 调整范围：使得x左边的数都小于或者等于x,使得x右边的数都大于或者等于x 递归处理左右两段。 最难的是第二步，有一种简单的做法： * 首先开辟两个空数组a,b， * 之后循环遍历q[l~r],将小于x的放进a,大于x的放进b * 之后将a,b的内容放进q 算法模板： #include<iostream> using name
C语言编程：10大经典基础算法解析
"这篇文章主要介绍了C语言中的10大基础算法，包括Fibonacci数列、简易计算器、回文检查和质数检查等经典算法，旨在帮助程序员掌握基础算法，提升编程技能。" C语言是计算机编程的基础，而算法则是编程的灵魂。熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

迟意..

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值