devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

关于算法的学习以及一些总结（一）_算法学习

作者：我家自动化 | 2024-03-17 07:42:39

赞

踩

算法学习

目录

0x01 基础算法之快速排序

0x02 基础算法之归并排序

0x03 基础算法之二分法

0x04 基础算法之高精度问题

0x05 基础算法之前缀和

0x06 基础算法之双指针算法

0x07 基础算法之位运算

0x08 基础算法之离散化

0x09 基础算法之区间合并

0x01 基础算法之快速排序

快速排序顾名思义就是使其可以快速的从小到大排序，按排序后的数组输出。题型：

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

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

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

输入格式

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

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

输出格式

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

数据范围

1≤n≤1000001≤n≤100000

输入样例：

5
3 2 5 4 1

输出样例：

1 2 3 4 5

步骤：

  • 划清界限：x=[left+right]/2。使左边的值都小于这个值，右边的值都大于这个值。

  • 初始化两个指针，一个指向最左边，一个指向最右边。

  • 如果两个指针中其中都不满足要求，则交换两个指针所指向的值。

  • 之后再将分完的两边再进行一次排序。

那就开始写吧：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N = 1e6+10;
  6.  
  7. int n=0;
  8. int q[N]={0};
  9.  
  10. void quick_sort(int *q,int Left,int Right)
  11. {
  12.     if(Left>=Right)     return;
  13.     
  14.     int x=q[(Left+Right)/2],i=Left-1,j=Right+1;
  15.     
  16.     while(i<j)
  17.     {
  18.         do i++; while(q[i]<x);
  19.         do j--; while(q[j]>x);
  20.         
  21.         if(i<j) swap(q[i],q[j]);
  22.     }
  23.     
  24.     quick_sort(q,Left,j);
  25.     quick_sort(q,j+1,Right);
  26. }
  27.  
  28. int main()
  29. {
  30.     scanf("%d",&n);
  31.     for(int i=0;i<n;i++)    scanf("%d",&q[i]);
  32.     
  33.     quick_sort(q,0,n-1);
  34.     
  35.     for(int i=0;i<n;i++)    printf("%d ",q[i]);
  36.     
  37.     return 0;
  38. }

拓展：求第k个数

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

输入格式

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

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

输出格式

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

数据范围

1≤n≤100000, 1≤k≤n

输入样例：

5 3
2 4 1 5 3

输出样例：

3

步骤：

  • 先使用快速排序进行排序。

  • 判断想要取的数在哪个区间

  • 快排那个区间，不断缩小范围

  • 最后返回快排到最后只剩下一个的数组。

代码：

  1. #include <cstring>
  2. #include <iostream>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. const int N = 100010;
  8.  
  9. int n, k;
  10. int q[N];
  11.  
  12. int quick_select(int l, int r)
  13. {
  14.     if (l == r) return q[l];
  15.  
  16.     int i = l - 1, j = r + 1, x = q[l + r >> 1];
  17.     while (i < j)
  18.     {
  19.         do i ++ ; while (q[i] < x);
  20.         do j -- ; while (q[j] > x);
  21.         if (i < j) swap(q[i], q[j]);
  22.     }
  23.  
  24.     if (k <= j) return quick_select(l, j);
  25.     return quick_select(j + 1, r);
  26. }
  27.  
  28. int main()
  29. {
  30.     scanf("%d%d", &n, &k);
  31.  
  32.     for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);
  33.  
  34.     k -- ;
  35.     cout << quick_select(0, n - 1) << endl;
  36.  
  37.     return 0;
  38. }

0x02 基础算法之归并排序

归并排序与快速排序有什么区别？快速排序是在一段数组空间中进行比大小排序，而归并排序是将数据分为两段，先将两段数据排好序，之后再用两个指针去遍历这两段排好序的数组。将两个数组中指向的值，较为小的值存放进另外一个数组中，之后再将指针指向下一个数。

题目：

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

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

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

输入格式

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

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

输出格式

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

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

步骤：

  • 将输入的数组分为两个部分。

  • 将两个部分进行快排

  • 快排后再使用两个指针进行操作，将较小的那个指针所对应的值存放进另外一个数组中。

  • 若还有一个指针没有遍历完，那么将这个指针后面的值继续存放至数组中。

  • 将另外一个数组的值存放进原数组中。

代码：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N = 1e6+10;
  6.  
  7. int n=0;
  8. int a[N]={0},tmp[N]={0};
  9.  
  10. void merger(int Left,int Right,int *a)
  11. {
  12.     if(Left>=Right)  return;
  13.     
  14.     int mid=(Left+Right)>>1;
  15.     
  16.     merger(Left,mid,a);
  17.     merger(mid+1,Right,a);
  18.     
  19.     int k=0,l=Left,r=mid+1;
  20.     
  21.     while(l<=mid&&r<=Right)
  22.     {
  23.         if(a[l]<=a[r])   tmp[k++]=a[l++];
  24.         else             tmp[k++]=a[r++];
  25.     }
  26.     
  27.     while(l<=mid)        tmp[k++]=a[l++];
  28.     while(r<=Right)      tmp[k++]=a[r++];
  29.     
  30.     for(int i=Left,j=0;i<=Right;i++,j++)
  31.     {
  32.         a[i]=tmp[j];
  33.     }
  34. }
  35.  
  36. int main()
  37. {
  38.     scanf("%d",&n);
  39.     
  40.     for(int i=0;i<n;i++)    scanf("%d",&a[i]);
  41.     
  42.     merger(0,n-1,a);
  43.     
  44.     for(int i=0;i<n;i++)    printf("%d ",a[i]);
  45.     
  46.     return 0;
  47. }

拓展：求逆序对的数量。

其实这道题还有一种方法，就是使用哈希，但是到后面再用哈希解决吧，现在先用归并排序试试看。

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

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

输入格式

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

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

输出格式

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

数据范围

1≤n≤100000 数列中的元素的取值范围 [1,10^9]。

输入样例：

6
2 3 4 5 6 1

输出样例：

5

步骤：

  • 先把整个区间分为两部分。[L,R] => [L,MID],[MID+1,R]

  • 递归排序

  • 归并，将左右两个有序序列合并成一个有序序列。

  • 那么假设在归并的同时又可以读出逆序对的数量，那么可以有三种情况。

  • 第一钟情况是左半边内部的逆序对数量：merge（L，mid）

  • 第二种情况是右半边内部的逆序对数量：merger（mid+1，R）

  • 第三种情况是逆序对一部分存放在左半边，另外一部分存放在右半边，那么对于已经排序好的左右半边，如果存在一个q左>q右，那么就说明从q左往右就是一直是q右的逆序对，只需要求出其长度count = mid-Left+1即可。

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. typedef long long LL;
  6.  
  7. const int N = 100010;
  8.  
  9. int n=0;
  10. int q[N]={0},tmp[N]={0};
  11.  
  12. LL merger(int Left,int Right,int* q)
  13. {
  14.     if(Left>=Right) return 0;
  15.     
  16.     int mid = Left+Right>>1;
  17.     LL res=merger(Left,mid,q)+merger(mid+1,Right,q);
  18.     
  19.     //开始归并
  20.     int k=0,i=Left,j=mid+1;
  21.     while(i<=mid && j<= Right)
  22.     {
  23.         if(q[i]<=q[j])  tmp[k++]=q[i++];
  24.         else
  25.         {
  26.             tmp[k++]=q[j++];
  27.             res += mid-i+1;
  28.         }
  29.     }
  30.     
  31.     //扫尾补齐
  32.     while(i<=mid)   tmp[k++]=q[i++];
  33.     while(j<=Right) tmp[k++]=q[j++];
  34.     
  35.     //返回
  36.     for(int i=Left,j=0;i<=Right;i++,j++)    q[i]=tmp[j];
  37.     
  38.     return res;
  39. }
  40.  
  41. int main()
  42. {
  43.     cin >> n;
  44.     for(int i=0;i<n;i++)    cin>>q[i];
  45.     
  46.     cout<<merger(0,n-1,q)<<endl;
  47.     
  48.     return 0;
  49. }

0x03 基础算法之二分法

二分法可应用于：求数值在数组中所在的位置、高精度算数、数的范围。。。

题目：数的范围

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

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

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

输入格式

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

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

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

输出格式

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

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

数据范围

1≤n≤10000 1≤q≤1000 1≤k≤10000

输入样例：

6 3
1 2 2 3 3 4
3
4
5

输出样例：

3 4
5 5
-1 -1

这种类型的题目，由于其数组已经排列好了，那么就可以划分一条界限，根据那个界限可以去确定所需要的元素在哪个区间，进而可以确定在哪个位置，不断地缩小该区间，知道找到该值的位置为止。这种题存在着数组越界的风险，虽然看着简单，但是数组越界的时候真的让人抓不着头脑。这道题是一个包含了重复元素的有序序列，要求输出某元素的起始位置以及终止位置，如果查找不到，那就返回-1，需要写两个二分，一个需要找到>=x的第一个数，另一个需要找到<=x的最后一个数。

步骤：

  • 确定左右边界

  • 算出中间边界，具有两种情况（Left+Right）/2或者是（Left+Right+1）/2这两种情况。

  • 根据值的范围，不断地缩小左右区间。

那么现在来确定这两种情况需要怎么实现：

情况一：在右半段寻找左边界（即寻找符合性质的第一个点）

当存在有array[mid]<x时，令Left=mid+1，mid及其左边的位置被排除了，那么出现的解的位置就是mid+1及其后面的位置了。区间划分为[Left,mid]和[mid+1,Right]。当查找结束时，Left和Right是会相遇的，Left所在的元素x则一定是x出现的最小位置，因为Left左边的元素必然都小于x。

  1. int Left=0,Right=n-1;
  2. while(Left<Right)
  3. {
  4.     int mid=Left+Right>>1;
  5.     if(array[mid]<x)	Left=mid+1;
  6.     else				Right=mid;
  7. }
  8. return Left;

情况二：在左半段寻找右边界（即寻找不符合性质的最后一个点）

将区间分为[Left,mid-1]和[mid,Right]（如果mid点符合性值，那么划分的右边界必定从mid-1开始）

  1. int Left=0,Right=n-1;
  2. while(Left<Right)
  3. {
  4.     int mid=(Left+Right+1)>>2;
  5.     if(array[mid]>x)	Right=mid-1;
  6.     else				Left=mid;
  7. }
  8. return Left;

其中的mid=（Left+Right+1）/2这里，+1是为了除法向下取整，当在Right=Left+1时更新Left=mid时会出现Left=mid=Left的死循环。+1就实现了向上取整，可以解决这个隐患。

那么上面就已经得出了二分的两个模板了，那么下面开始写题目的程序吧：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N = 1e6+10;
  6.  
  7. int n,m;
  8. int q[N];
  9.  
  10. int main()
  11. {
  12.     scanf("%d %d",&n,&m);
  13.     for(int i=0;i<n;i++)	scanf("%d",&q[i]);
  14.     
  15.     while(m--)
  16.     {
  17.         int x;
  18.         scanf("%d",&x);
  19.         
  20.         int Left=0,Right=n-1;
  21.         
  22.         while(Left<Right)
  23.         {
  24.             int mid=(Left+Right)>>1;
  25.             if(q[mid]>=x)	Right=mid;
  26.             else			Left=mid+1;
  27.         }
  28.         
  29.         if(q[Left]!=x)	cout<<"-1 -1"<<endl;
  30.         else
  31.         {
  32.             cout<<Left<<' ';
  33.             
  34.             int Left=0,Right=n-1;
  35.             while(Left<Right)
  36.             {
  37.                 int mid=(Left+Right+1)>>1;
  38.                 if(q[mid]<=x)	Left=mid;
  39.                 else			Right=mid-1;
  40.             }
  41.             
  42.             cout<<Left<<endl;
  43.         }
  44.     }
  45.     
  46.     return 0;
  47. }

拓展：数的三次方根

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

输入格式

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

输出格式

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

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

数据范围

−10000≤n≤10000

输入样例：

1000.00

输出样例：

10.000000

关于浮点数的二分：

  • 确定边界，这里的n的区间为[-10000,10000]

  • 进行二分，对于一个数开三次方根，如果它的数是存在于边界的左边，那么就可以将区间锁定为左边界，如果它的数是存在于边界的右边，那么就将区间锁定为有边界。

  • 保留六位小数的这个细节：这里使用了1e-8，如果使用1e10-7，那么会因为四舍五入第八位到第七位，已经产生误差，输出六位的时候误差会积累。如果使用-8，那么四舍五入第九位到低八位，取前六位的时候，第七位就会被truncate掉，但是第七位是准确值。所以正常要预留小数点多少位的时候，要留出两位四舍五入的空间。

代码如下：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7.     double x;
  8.     cin>>x;
  9.     
  10.     double l=-10000,r=10000;
  11.     while(r-1>1e-8)
  12.     {
  13.         double mid = (l+r)/2;
  14.         if(mid*mid*mid>=x)	r=mid;
  15.         else				l=mid;
  16.     }
  17.     printf("%lf\n",l);
  18.     
  19.     return 0;
  20. }

0x04 基础算法之高精度问题

高精度算法的情景：

  • 两个大整数相加

  • 两个大整数相减

  • 一个大整数乘以一个小整数

  • 求一个大整数除以一个小整数的商和余数

关于大整数的存储：

申请一个数组，从数组的第一个元素开始存放数字的最低位，之后依次向下存放。为什么要将低位放在数组的开头，高位放在数组的后面，因为进位是需要操作高位的，使用push_back这个函数比较方便。

一、高精度加法

对于题目如下：

给定两个正整数（不含前导 00），计算它们的和。

输入格式

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

输出格式

共一行，包含所求的和。

数据范围

1≤整数长度≤100000

输入样例：

12
23

输出样例：

35

步骤：

  • 申请一个大的容器vector

  • 思考我们平时按位加法的步骤，按位加，若有进位，那么下一位+1，现在的这一位取余数。

  • 假设进位为t，那么就存在这这一位的计算为A+B+t。

对于加法：

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. using namespace std;
  5.  
  6. vector<int>	add(vector<int>&A,vector<int>&B)
  7. {
  8. 	vector<int> c;
  9.     
  10.     int t=0;
  11.     for(int i=0;i<A.size()||i<B.size();i++)
  12.     {
  13.         //在有效的位数中相加
  14.         if(i<A.size())	t+=A[i];
  15.         if(i<B.size())	t+=B[i];
  16.         
  17.         //保留
  18.         c.push_back(t%10);
  19.         //进位
  20.         t/=10;
  21.     }
  22.     
  23.     //若到了最后还有进位，那就在最高位+1
  24.     if(t)	c.push_back(1);
  25.     return c;
  26. }
  27.  
  28. int main()
  29. {
  30. 	string a,b;
  31. 	vector<int> A,B;
  32. 	
  33. 	cin>>a>>b;
  34.     
  35.     //实现最高位存放在数组的第一位
  36.     for(int i=a.size()-1;i>=0;i--)	A.push_back(a[i]-'0');
  37. 	for(int i=b.size()-1;i>=0;i--)	B.push_back(b[i]-'0');
  38.     
  39.     auto c=add(A,B);
  40.     
  41.     for(int i=c.size()-1;i>=0;i--)	printf("%d",c[i]);
  42.     
  43. 	return 0;
  44. }

那么对于减法：

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

输入格式

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

输出格式

共一行，包含所求的差。

数据范围

1≤整数长度≤105

输入样例：

32
11

输出样例：

21

  • 申请一个容器vector

  • 判断两个数的大小，取决哪个数为被减数。

  • 进行减法运算：模拟我们正常算减法时的情景：当我们减法时，如果需要借位，那么下一位的取值应该时应该有A-B-t。

  • 当有借位的位时，需要补上+10，如果不需要的话，+10后最后余10的出来的数也为0，所以不影响，直接就把两种情况包容了。

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. using namespace std;
  5.  
  6. bool cmp(vector<int>& A, vector<int> &B)
  7. {
  8.     if(A.size() != B.size()) return A.size() > B.size();  //直接ruturn 了就不用else
  9.  
  10.     for(int i = A.size(); i >= 0; i--)
  11.         if(A[i] != B[i])
  12.             return A[i] > B[i];
  13.  
  14.     return true;
  15. }
  16.  
  17. vector <int> sub(vector<int>& A, vector<int> &B)
  18. {
  19.     vector<int> C;
  20.     int t = 0;
  21.     for(int i = 0; i < A.size(); i++)
  22.     {
  23.         t = A[i] - t;
  24.         if(i < B.size()) t -= B[i];
  25.         C.push_back((t + 10) % 10 ); //对于借位的处理，包容了需要借位以及不需要借位的两种情况。
  26.         if(t < 0)  t = 1;
  27.         else t = 0;
  28.  
  29.     }
  30.  
  31.     while(C.size() > 1 && C.back() == 0) C.pop_back();  //去掉前导0
  32.  
  33.     return C;
  34. }
  35.  
  36. int main()
  37. {
  38.     string a ,b;
  39.     vector<int> A, B;
  40.  
  41.     cin >> a >> b ;
  42.  
  43.     for(int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
  44.     for(int i = b.size() - 1; i >= 0; i--) B.push_back(b[i] - '0');
  45.  
  46.     if (cmp(A,B)) 
  47.     {
  48.         auto C = sub(A, B);
  49.         for(int i = C.size() - 1; i >= 0; i--) printf("%d", C[i]);
  50.         return 0;
  51.     }
  52.     else
  53.     {
  54.         auto C = sub(B, A);
  55.         printf("-");
  56.         for(int i = C.size() - 1; i >= 0; i--) printf("%d", C[i]);
  57.         return 0;
  58.     }
  59.  
  60.  
  61. }

那么对于乘法：

给定两个非负整数（不含前导 00） AA 和 BB，请你计算 A×BA×B 的值。

输入格式

共两行，第一行包含整数 AA，第二行包含整数 BB。

输出格式

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

数据范围

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

输入样例：

2
3

输出样例：

6

步骤：

  • 当进行乘法时，相应的位上的数为A*B%10。

  • 下一位时，需要算出进位的值t为A*B/10。那么这一位就是（A * B+ T）%10。

  • 当我们进行乘法时，其实跟我们运算顺序是不一样的，我们正常乘法是会将多位数的B按位进行相乘。但是在程序中不是这样的，这样子太麻烦了，正常是把它看为一个整体进行相乘。

  • 重复

代码如下：

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. using namespace std;
  5.  
  6. vector<int>	mul(vector<int>	&A,int b)
  7. {
  8.     vector<int> c;
  9.     int t=0;
  10.     for(int i=0;i<A.size()||t;i++)
  11.     {
  12.         if(i<A.size())	t+=A[i]*b;
  13.         c.push_back(t%10);
  14.         t/=10;
  15.     }
  16.     
  17.     //除去前导0
  18.     while(c.size()>1&&c.back()==0)	c.pop_back();
  19.     return c;
  20. }
  21.  
  22. int main()
  23. {
  24.     string a;
  25.     int b;
  26.     
  27.     cin >> a >> b;
  28.     
  29.     vector<int>	A;
  30.     for(int i=a.size()-1;i>=0;i--)	A.push_back(a[i]-'0');
  31.     
  32.     auto c=mul(A,b);
  33.     
  34.     for(int i=c.size()-1;i>=0;i--)	printf("%d",c[i]);
  35.     
  36.     return 0;
  37. }

那么对于除法：

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

输入格式

共两行，第一行包含整数 AA，第二行包含整数 BB。

输出格式

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

数据范围

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

输入样例：

7
2

输出样例：

3
1

步骤：

  • 对于正常的除法运算，我们都是先取第一个数，看看这个数是否能除以我们要除的除数，之后将求得的商写在上面，余数保留给下一位用。

  • 求得的余数还需要乘上10再加上下一位数，就可以得到下一位要运算的数值。

  • 同理，后面的位数也是按照这样子进行操作。

代码如下： 

  1. #include <iostream>
  2. #include <vector>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. vector<int>	div(vector<int> &A,int b,int r)
  8. {
  9.     vector<int> c;  //商
  10.     r=0; //余数的引用
  11.     for(int i=A.size()-1;i>=0;i--)
  12.     {
  13.         r = r*10+A[i];
  14.         c.push_back(r/b);
  15.         r%=b;
  16.     }
  17.     
  18.     //与前面存的顺序是反过来的
  19.     reverse(c.begin(),c.end());
  20.     while(c.size()>1 && c.back()==0)	c.pop_back();
  21.     
  22.     return c;
  23. }
  24.  
  25. int main()
  26. {
  27. 	string a;
  28.     int b;
  29.     
  30.     cin >> a >> b;
  31.     
  32.     vector<int> A;
  33.     for(int i=a.size()-1;i>=0;i--)	A.push_back(a[i]-'0');
  34.     
  35.     int r;
  36.     auto c=div(A,b,r);
  37.     
  38.     for(int i=c.size()-1;i>=0;i--)	printf("%d",c[i]);
  39.     cout<<endl<<r<<endl;
  40.     
  41.     return 0;
  42. }

0x05 基础算法之前缀和

一、一维的前缀和

输入一个长度为 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

什么是前缀和？

Si=a1+a2+a3....+ai。令S0=0。其实就像以前所学的等差数列是差不多的道理。将S0定为0可以方便地处理边界。，当要求s[10]时，可以使用s10-s0=s10。要求某个区间内的和，直接sl-sr。

步骤：

  • 求出每一个si的值，公式为s[i]=s[i-1]+a[i]。

  • 之后再根据区间去求出

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N = 100010;
  6.  
  7. int n,m;
  8. int a[N],s[N];
  9.  
  10. int main()
  11. {
  12.     scanf("%d%d",&n,&m);
  13.     for(int i=1;i<=n;i++)	scanf("%d",&a[i]);
  14.     
  15.     for(int i=1;i<=n;i++)	s[i]=s[i-1]+a[i];
  16.     
  17.     while(m--)
  18.     {
  19.         int l,r;
  20.         scanf("%d%d",&l,&r);
  21.         printf("%d\n",s[r]-s[l-1]);
  22.     }
  23.     return 0;
  24. }

 拓展：差分运算

输入一个长度为 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

差分可以看作为前缀和的逆运算，前缀和是不断的求和数组，而对于差分可以说是将求和好的数组，一个一个拆解出来。

那么我们首先要定义一个原数组a：

a[1],a[2],a[3]......a[n];

然后我们构造一个数组b：

b[1],b[2],b[3].....b[n];

最后我们要使得a[i]=b[1]+b[2]+b[3]+.....+b[i];

也就是说，a数组是b数组的前缀和数组，反过来我们把b数组叫做a数组的差分数组。换句话来说，其实每一个a[i]都是b数组从头开始的一段区间和。

那么如何构造这个数组呢？最直接的方法如下，其实跟我们以前学的数学是差不多的：

 

我们只要有b数组，通过前缀和运算，就可以在O(n)的时间内得到a数组。即 a[l] + c , a[l+1] + c , a[l+2] + c .... a[r] + c;

那么知道差分数组到底有什么用呢？

如果给定一个区间[l,r]，让我们把a数组中的[l,r]区间中的每一个数都加上c。也可以暴力求解，for循环l到r的区间，时间复杂度为O(n)，如果我们需要对原数组执行m次这样的操作，考虑时间复杂度就会变成O（n*m）。这样确实会浪费很多时间，那么，我们就需要考虑差分的做法：

我们知道a数组是b数组的前缀和数组，比如说对b数组的b[i]修改，会影响到a数组中从a[i]及往后的每一个数。

首先让差分b数组中的 b[l] + c ,a数组变成 a[l] + c ,a[l+1] + c.... a[n] + c;

然后我们打个补丁，b[r+1] - c, a数组变成 a[r+1] - c,a[r+2] - c....a[n] - c;

为什么要打个补丁？我们可以从图中得到：

b[l] + c，效果使得a数组中 a[l]及以后的数都加上了c(红色部分)，但我们只要求l到r区间加上c, 因此还需要执行 b[r+1] - c,让a数组中a[r+1]及往后的区间再减去c(绿色部分)，这样对于a[r] 以后区间的数相当于没有发生改变。

因此我们就可以得到一维差分的结论：

给a数组中的[l,r]区间中的每一个数都加上c，只需要对差分数组b做b[l]+=c，b[r+1]-=c。时间复杂度为O（1）,提高了效率 。那么其实思路就如下了，很简单：

给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c

代码:

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N=1e5+10;
  6. int a[N],b[N];
  7.  
  8. int main()
  9. {
  10.     int n,m;
  11.     scanf("%d%d",&n,&m);
  12.     for(int i=1;i<=n;i++)
  13.     {
  14.         scanf("%d",&a[i]);
  15.         b[i]=a[i]-a[i-1]; 		//构建差分数组
  16.     }
  17.     int l,r,c;
  18.     while(m--)
  19.     {
  20.         scanf("%d%d%d",&l,&r,&c);
  21.         b[l] += c;
  22.         b[r+1] -= c;
  23.     }
  24.     for(int i=1;i<=n;i++)
  25.     {
  26.         a[i] = b[i]+a[i-1];
  27.         printf("%d",a[i]);
  28.     }
  29.     return 0;
  30. }

二、矩阵的前缀和

输入一个 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

对于这种求二维数组的子矩阵和可以将数组看作一副图像的面积，那么对于一个矩阵的面积可以这么看：

 

紫色的面积代表的是(1,1)左上角到（i,j-1)右下角的矩形面积，绿色面积代表的是(1,1)左上角到(i-1,j)右下角的矩形面积。每一个颜色的矩形面积都代表了它所包围元素的和。

那么对于一个矩阵的面积可以这么看，整个外围蓝色矩阵的面积s[i] [j]=绿色面积s[i-1] [j]+紫色面积s[i] [j-1]-重复加的红色的面积s[i-1] [j-1]+小方块面积a[i] [j]。

那么就可以得出一条求其子矩阵面积的公式了：

s[i] [j] = s[i-1] [j]+s[i]s[j-1]+a[i] [j]-s[i-1] [j-1]

接下来的回归问题去求以(x1,y1)为左上角和以(x2,y2)为右下角的矩阵的元素的和。我们需要理清楚的是，其中的x1表示的行，而y1表示的是为列。

那么我们可以得出，如下：

紫色面积是指 ( 1,1 )左上角到(x1-1,y2)右下角的矩形面积 ，黄色面积是指(1,1)左上角到(x2,y1-1)右下角的矩形面积。

那么我们可以推出：

绿色矩形的面积 = 整个外围面积s[x2, y2] - 黄色面积s[x2, y1 - 1] - 紫色面积s[x1 - 1, y2] + 重复减去的红色面积 s[x1 - 1, y1 - 1]。

那么二位前缀和的结论就如下：

以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为： s[x2, y2] - s[x1 - 1, y2] - s[x2, y1 - 1] + s[x1 - 1, y1 - 1]。

那么最后敲代码：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N=1010;
  6. int n,m,q;
  7. int a[N][N],s[N][N];
  8. int main()
  9. {
  10.     scanf("%d %d %d",&n,&m,&q);
  11.     
  12.     //要确保从1开始，保证s[0][0]=0
  13.     for(int i=1;i<=n;i++)
  14.     {
  15.         for(int j=1;j<=m;j++)
  16.         {
  17.             scanf("%d",&a[i][j]);
  18.         }
  19.     }
  20.     for(int i=1;i<=n;i++)
  21.     {
  22.         for(int j=1;j<=m;j++)
  23.         {
  24.             s[i][j]=s[i-1][j]+s[i][j-1]+a[i][j]-s[i-1][j-1];
  25.         }
  26.     }
  27.     
  28.     while(q--)
  29.     {
  30.         int x1,y1,x2,y2;
  31.         scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
  32.         printf("%d\n",s[x2][y2]-s[x2][y1-1]-s[x1-1][y2]+s[x1-1][y1-1]);
  33.     }
  34.     return 0;
  35. }

拓展：差分矩阵

输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1)(x1,y1) 和 (x2,y2)(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

像一维差分那样，我们想实现的是一种O(1)的时间复杂度，给子矩阵中每个元素的值加上c。

同理，a[] []是数组b[] []数组的前缀和数组，那么b[] []是a[] []的差分数组。原数组：a[i] [j]，我们去构造差分数组b[i] [j]。其中a数组中a[i] [j]是b数组左上角(1,1)到右下角(i,j)所包围的矩形元素的和。

那么如何去构造b数组呢？同一维差分，我们构造二维差分数组目的是为了 让原二维数组a中所选中子矩阵中的每一个元素加上c的操作，可以由O(n*n)的时间复杂度优化成O(1)

已知原数组a中被选中的子矩阵为 以(x1,y1)为左上角，以(x2,y2)为右下角所围成的矩形区域;

也是跟前面一样，我们要记得a数组是b数组的前缀和数组，比如对b数组的修改，那么我们就会影响到从a[i] [j]以及往后的每一个数。

那么假设我们已经构造了b数组，类比一维差分，我们执行下面的操作来使被选中的子矩阵中的每个元素的值都加上c：

b[x1] [y1] + = c;

b[x1,] [y2+1] - = c;

b[x2+1] [y1] - = c;

b[x2+1] [y2+1] + = c;

那么每次都对b数组执行以上的操作，等价于：

  1. for(int i=x1;i<=x2;i++)
  2.   for(int j=y1;j<=y2;j++)
  3.     a[i][j]+=c;

我们使用图来表述可能会好理解一点：

  • b[x1] [ y1 ] +=c ; 对应图1 ,让整个a数组中蓝色矩形面积的元素都加上了c。

  • b[x1,] [y2+1]-=c ; 对应图2 ,让整个a数组中绿色矩形面积的元素再减去c，使其内元素不发生改变。

  • b[x2+1] [y1]- =c ; 对应图3 ,让整个a数组中紫色矩形面积的元素再减去c，使其内元素不发生改变。

  • b[x2+1] [y2+1]+=c; 对应图4,,让整个a数组中红色矩形面积的元素再加上c，红色内的相当于被减了两次，再加上一次c，才能使其恢复。

那么我们将上述所表达的封装为一个函数：

  1. void insert(int x1,int y1,int x2,int y2,c)
  2. {
  3. 	//对b数组执行插入操作，等价于对a数组中的(x1,y1)到(x2,y2)之间的元素都加上了c
  4. 	b[x1][y1] += c;
  5.     b[x2+1][y1] -= c;
  6.     b[x1][y2+1] -= c;
  7.     b[x2+1][y2+1] += c;
  8. }

 那么如何构建差分呢？我们每次让以(i,j)为左上角到以(i，j)为右下角面积内元素，其实就是一个小方格的面积去插入c=a[i] [j]，那么这样就等价于原数组a中的(i，j)到(i，j)的范围内加上了a[i] [j]，那么按照这么执行下去，进行n'*m的插入操作，就可以成功构建了差分b数组。

  1.  for(int i=1;i<=n;i++)
  2.   {
  3.       for(int j=1;j<=m;j++)
  4.       {
  5.           insert(i,j,i,j,a[i][j]);    //构建差分数组
  6.       }
  7.   }

代码如下：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N=1e3+10;
  6. int a[N][N],b[N][N];
  7.  
  8. void insert(int x1,int y1,int x2,int y2,int c)
  9. {
  10.     b[x1][y1] += c;
  11.     b[x2+1][y1] -= c;
  12.     b[x1][y2+1] -= c;
  13.     b[x2+1][y2+1] += c;
  14. }
  15.  
  16. int main()
  17. {
  18.     int n,m,q;
  19.     cin>>n>>m>>q;
  20.     for(int i=1;i<=n;i++)
  21.         for(int j=1;j<=m;j++)
  22.        		cin>>a[i][j];
  23.     for(int i=1;i<=n;i++)
  24.         for(int j=1;j<=m;j++)
  25.             insert(i,j,i,j,a[i][j]);
  26.     while(q--)
  27.     {
  28.         int x1,y1,x2,y2,c;
  29.         cin>>x1>>y1>>x2>>y2>>c;
  30.         insert(x1,y1,x2,y2,c);
  31.     }
  32.     for(int i=1;i<=n;i++)
  33.         for(int j=1;j<=m;j++)
  34.             b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];  //二维前缀和
  35.     for(int i=1;i<=n;i++)
  36.     {
  37.         for(int j=1;j<=m;j++)
  38.         {
  39.             printf("%d ",b[i][j]);
  40.         }
  41.         printf("\n");
  42.     }
  43.     
  44.     return 0;
  45. }

0x06 基础算法之双指针算法

这种常见的问题分类：

  • 对于一个序列，用两个指针维护一段区间。

  • 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

一、最长连续不重复子序列：

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

输入格式

第一行包含整数 n。

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

输出格式

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

数据范围

1≤n≤10^5

输入样例：

5
1 2 2 3 5

输出样例：

3

  • 指定两个指针 ，一个是指向元素i的指针，另外一个是指向最长连续不重复的子序列j。之后我们就可以得知长度为i-j+1，将这一长度与r的较大者更新给r。

  • 对于每一个i，如何确定j的值呢，由于[j,i-1]提前一步得到的最长连续不重复子序列，所以如果[j,i]中有重复的元素，那么一定是a[i]，那我们就将j指针一直移动直到不重复为止。（由于[j,i-1]已经是前一步的最优解，此时只可能剔除重复元素a[i]，不可能左移增加元素，所以j这个指针式具有单调性）。

  • 用数组s记录子序列中a[j~i]各元素出现次数，遍历过程中对于每一个i有四步操作：cin元素[i]->将a[i]出现次数s[a[i]]加一->若a[i]重复则右移j（s[a[j]]要减一）->确定j以及更新当前长度i-j+1给r。

需要注意的细节是：当a[i]重复时，先把a[j]次数减1，再右移j。

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N = 100010;
  6. int a[N],s[N];
  7.  
  8. int main()
  9. {
  10. 	int n,r=0;
  11. 	cin >> n;
  12. 	
  13. 	for(int i=0,j=0;i<n;++i)
  14. 	{
  15. 		cin>>a[i];
  16. 		++s[a[i]];
  17. 		while(s[a[i]]>1)	--s[a[j++]];//先减次数后右移j
  18. 		r=max(r,i-j+1);
  19. 	}
  20. 	cout << r;
  21. 	
  22. 	return 0;
  23. }

二、数组元素的目标和

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

数组下标从 0 开始。

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

数据保证有唯一解。

输入格式

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

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

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

输出格式

共一行，包含两个整数 i 和 j。

数据范围

数组长度不超过 10^5。 同一数组内元素各不相同。 1≤数组元素≤109

输入样例：

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

输出样例：

1 1

可能很多人会想到这个暴力求解：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N=10010;
  6.  
  7. int main()
  8. {
  9.     int n=0,m=0,x=0;
  10.     int a[N],b[N];
  11.     scanf("%d%d%d",&n,&m,&x);
  12.     for(int i=0;i<n;i++)
  13.     {
  14.         scanf("%d",&a[i]);
  15.     }
  16.     for(int j=0;j<m;j++)
  17.     {
  18.         scanf("%d",&b[j]);
  19.     }
  20.     
  21.     for(int i=0;i<n;i++)
  22.     {
  23.         for(int j=0;j<m;j++)
  24.         {
  25.             if(a[i]+b[j]==x)
  26.             {
  27.                 printf("%d %d",i ,j);
  28.             }
  29.         }
  30.     }
  31.     
  32.     return 0;
  33. }

 由题意可得，这是一个升序的数组，那么我们可以定义两个指针，第一个指针i从前往后遍历，一个指针j从m-1开始从后向前遍历。那么和纯暴力求解的区别就在于，我们的j指针不会回退，不会一直在重复遍历。当我们使用两个指针进行遍历时，如果存在这个时候有a[i]+b[j]>k，那么就说明，指针j需要往前移动。

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N=1e5+10;
  6.  
  7. int n,m,k;
  8. int a[N],b[N];
  9.  
  10. #define read(x)	scanf("%d",&x);
  11.  
  12. int main()
  13. {
  14.     read(n);read(m);read(k);
  15.     for(int i=0;i<n;i++)	read(a[i]);
  16.     for(int i=0;i<m;i++)	read(b[i]);
  17.     
  18.     for(int i=0,j=m-1;i<n;i++)
  19.     {
  20.         while(j>=0&&a[i]+b[j]>k)	j--;
  21.         if(j>=0&&a[i]+b[j]==k)		printf("%d %d",i,j);
  22.     }
  23.     return 0;
  24. }

三、判断子序列

给定一个长度为 nn 的整数序列 a1,a2,…,ana1,a2,…,an 以及一个长度为 mm 的整数序列 b1,b2,…,bmb1,b2,…,bm。

请你判断 aa 序列是否为 bb 序列的子序列。

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

输入格式

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

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

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

输出格式

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

否则，输出 No。

数据范围

1≤n≤m≤10^5 −10^9≤ai,bi≤10^9

输入样例：

3 5
1 3 5
1 2 3 4 5

输出样例：

Yes

使用双指针算法：

  • 使用j指针来扫描整个b数组，i指针用来扫描a数组。若发现a[i]=b[j]，则让i指针后移一位。

  • 整个过程中，j指针不断后移，而i指针只有当匹配成功时才后移一位，到最后如果i==n时，那就说明匹配成功

代码：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. const int N=1e5+10;
  5. int a[N],b[N];
  6. int main()
  7. {
  8.     int n,m;
  9.     scanf("%d%d",&n,&m);
  10.     for(int i=0;i<n;i++)	scanf("%d",&a[i]);
  11.     for(int j=0;j<m;j++)	scanf("%d",&b[j]);
  12.     
  13.     int i=0;
  14.     for(int j=0;j<m;j++)
  15.     {
  16.         if(i<n&&a[i]==b[j])		i++;
  17.     }
  18.     if(i==n)	puts("Yes");
  19.     else		puts("No");
  20.     
  21.     return 0;
  22. }

0x07 基础算法之位运算

题目：二进制中1的个数

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

输入格式

第一行包含整数 n。

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

输出格式

共一行，包含 n 个整数，其中的第 i 个数表示数列中的第 i 个数的二进制表示中 11的个数。

数据范围

1≤n≤100000, 0≤数列中元素的值≤109

输入样例：

5
1 2 3 4 5

输出样例：

1 1 2 1 2

我们先思考如何得到一个数的二进制数：

  1. int n=10;
  2. for(int k=3;k>=0;k--)	cout<<(n>>k&1);

那么上面就是一种思路：

先把第k位移到最后一位 n>>k，再看个位是几，那就要进行与上1。

lowbit原理

作用是返回x的最后一位1。比如说x=1010，那么lowbit(x)=10，如果x=101000，那么返回的是1000。

这涉及到了原码、补码和反码，当我们一个负数要存储时，我们正常是先将它对应的正数取反后再加上1。那么lowbit其实就可以表达为(x&(~x+1))。比如说一个数字的原码是10001000，它的负数形式表达就是补码，那就是反码+1，反码是01110111，加1则是01111000，二者按位与得到了1000。应用就是可以求出二进制中1的个数。

那么代码如下：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int lowbit(int x)
  6. {
  7.     return x & -x;
  8. }
  9.  
  10. int main()
  11. {
  12.     int n;
  13.     cin>>n;
  14.     int res=0;
  15.     while(n--)
  16.     {
  17.         int x;
  18.         cin >> x;
  19.         
  20.         int res=0;
  21.         while(x)	x-=lowbit(x),res++;		//计算一共减去了多少次1
  22.         cout << res << ' ' ;
  23.     }
  24.     return 0;
  25. }

其实也可以暴力求解：

这个思路就很简单了，就像上面的得到了每个数的最后一位，之后就将a右移一位，直到位等于0，就得到了1的个数。

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int n;
  6. int a,k;
  7. int main()
  8. {
  9.     scanf("%d",&n);
  10.     
  11.     for(int i=0;i<n;i++)
  12.     {
  13.         scanf("%d",&a);
  14.         k=0;
  15.         while(a)
  16.         {
  17.             k += a&1;
  18.             a=a>>1;
  19.         }
  20.         printf("%d",k);
  21.     }
  22.     return 0;
  23. }

0x08 基础算法之离散化

先看看题目：区间和

假定有一个无限长的数轴，数轴上每个坐标上的数都是 0。

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

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

输入格式

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

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

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

输出格式

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

数据范围

−10^9≤x≤10^9 1≤n,m≤10^5 −10^9≤l≤r≤10^9 −10000≤c≤10000

输入数据：

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

输出样例：

8
0
5

首先为什么要实现离散化？

  • 存储下标太大了，开这么大的数组不是很现实。

  • 数轴中存在负数，如果采用数组下标，那就是会存在负值，这不可能。

  • 那能不能用哈希？哈希无法像离散化一样缩小数组空间，导致我们需要从-1e9到1e9，需要从前到后去枚举。

  • 哈希表也无法实现排序，所以我们一般不能提前直到哪些数轴上的点存在哪些不存在，所以一般是从负的最小值到正的最大值都枚举一遍，那么这样时间复杂度太高了。

  • 离散化的本质，就是映射，将间隔很大的点，映射到相邻的数组元素中，减少对空间的需求，也减少计算量。

那么我们先看看思路：

  • 读输入：将每次读入的x c，使用push_back()到add中，将每次读入的位置x，push_back()到alls中，将每次读入的l r ，使用push_back()到query中。

  • 排序、去重。

  • 通过遍历add，完成在离散化的数组映射到a数组上进行加上c的操作，使用find函数。

  • 初始化s数组。

  • 通过数组query，完成求区间[l,r]的和。

先看看代码：

  1. #include <iostream>
  2. #include <vector>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. typedef pair<int,int>	PII;
  8. const int N=30010;
  9.  
  10. int n,m;
  11. int a[N],s[N];
  12.  
  13. vector<int>	alls;
  14. vector<PII>	add,query;
  15.  
  16. int find(int x)
  17. {
  18.     int l=0,r=alls.size()-1;
  19.     while(l<r)
  20.     {
  21.         int mid=l+r>>1;
  22.         if(alls[mid]>=x)	r=mid;
  23.         else				l=mid+1;
  24.     }
  25.     return r+1;
  26. }
  27.  
  28. //实现c++中的unique去重函数
  29. vector<int>::iterator unique(vector<int> &a)
  30. {
  31.     int j=0;
  32.     for(int i=0;i<a.size();i++)
  33.         if(!i || a[i]!=a[i-1])
  34.             a[j++]=a[i];
  35.     //a[0]~a[j-1]所有a中不重复的数
  36.     return a.begin()+j;
  37. }
  38.  
  39. int main()
  40. {
  41.     cin >> n >> m;
  42.     for(int i=0;i<n;i++)
  43.     {
  44.         int x,c;
  45.         cin >> x >> c;
  46.         add.push_back({x,c});
  47.         alls.push_back(x);
  48.     }
  49.     for(int i=0;i<m;i++)
  50.     {
  51.         int l,r;
  52.         cin >> l >> r;
  53.         query.push_back({l,r});
  54.         alls.push_back(l);
  55.         alls.push_back(r);
  56.     }
  57.     
  58.     //去重以及排序
  59.     sort(alls.begin(),alls.end());
  60.     alls.erase(unique(alls),alls.end());
  61.     
  62.     //处理插入
  63.     for(auto item:add)
  64.     {
  65.         //找到下标
  66.         int x=fine(item.frist);
  67.         //插入下标对应的值
  68.         a[x] += item.second;
  69.     }
  70.     
  71.     //预处理前缀和
  72.     for(int i=);i<=alls,size();i++) s[i]=s[i-1]+a[i];
  73.     
  74.     //处理访问
  75.     for(auto item:query)
  76.     {
  77.         int l=find(item.first),r=find(item.second);
  78.         cout<<s[r]-s[l-1]<<endl;
  79.     }
  80.     return 0;
  81. }

那么首先我们应该确定的是，我们在alls中存放的是位置而不是值，也就是存放的是x而不是c。

所以我们需要alls.push_back(l)\alls.push_back(r)去保存我们所要询问的值的位置。

在求区间和时，我们提前分析到可以使用前缀和来做，求前缀和就需要下标l r，如果不加入l r到alls中的话，第五步中遍历query时就没有办法通过l r去访问a或者s。因为find函数就是输入映射前的下标，返回alls中的下标+1。

那么为什么要去重还有排序？

对于一个要进行二分的离散数组，是需要进行排序的。find函数的功能就是在一个排好序的数组下，输入一个离散数组位置（映射前的位置）x返回连续数组的位置+1也就是映射后的位置+1。+1的目的是在于求区间和时少一步下标为0的判断。

0x09 基础算法之区间合并

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

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

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

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

输入格式

第一行包含整数 n。

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

输出格式

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

数据范围

1≤n≤100000

−10^9≤li≤ri≤10^9

输入样例

5
1 2
2 4
5 6
7 8
7 9

输出样例：

3

快速将具有交集的区间合并为一个区间。区间与区间的关系：

  • 包含

  • 交集

  • 无关

按照左端点从小到大的顺序进行遍历（这样就不会有区间会出现左端起点位置会小于下一个要遍历区间的起始位置）。比如我们输入了一个区间，还有另外一个区间，如果这个区间有交集，那么我们就把这个区间的结尾存放在后面，如果这个区间完全没有交集，那么就有当前起点定为下一个区间的起点。

那么就看看代码：

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6.  
  7. typedef pair<int,int>	PII;
  8. const int N=100010;
  9.  
  10. int n;
  11. vector<PII>	segs;
  12.  
  13. void merge(vector<PII> &segs)
  14. {
  15.     vector<PII> res;
  16.     //排序
  17.     sort(segs.begin(),segs.end());
  18.     //定义左右边界
  19.     int st=-2e9,ed=-2e9;
  20.     for(auto seg:segs)
  21.     {
  22.         //说明我们的区间里面没有这个，需要外扩
  23.         if(ed<seg.first)
  24.         {
  25.             if(st!=-2e9)	res.push_back({st,ed});
  26.             st = seg.first,ed=seg.second;
  27.         }
  28.         //包含区间
  29.         else
  30.         {
  31.             ed = max(ed,seg.second);
  32.         }
  33.     }
  34.     if(st!=-2e9)	res.push_back({st,ed});
  35.     
  36.     segs = res;
  37. }
  38.  
  39. int main()
  40. {
  41.     cin>>n;
  42.     for(int i=0;i<n;i++)
  43.     {
  44.         int l,r;
  45.         cin >> l >> r;
  46.         segs.push_back((l,r));
  47.     }
  48.     merge(segs);
  49.     
  50.     cout<<segs.size()<<endl;
  51.     
  52.     return 0;
  53. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/254910
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号