二分&前缀和_二分和前缀和

二分和前缀和

一、二分

写在前面：

有单调性一定可以二分，没有单调性有可能也可以二分

思路：

1. mid=l+r+1>>1
   1. 若满足条件则答案在[mid,r]; l=mid
   2. 若不满足则答案在[l,mid-1]; r=mid-1
2. mid=l+r>>1
   1. 若满足条件，则答案在[l,mid]; r=mid;
   2. 若不满足条件，则答案在[mid+1,r];l=mid+1;

//当我们将区间[l, r]划分成[l, mid]和[mid + 1, r]时，其更新操作是r = mid或者l = mid + 1;，计算mid时不需要加1。
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }
    return l;
}

//当我们将区间[l, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是r = mid - 1或者l = mid;，此时为了防止死循环，计算mid时需要加1。
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1.数的范围

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

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

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

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

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

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

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

如果数组中不存在该元素，则返回 -1 -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>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=100010;
int num[N];
int n,q;

int main(){
    cin>>n>>q;
    for(int i=0;i<n;i++) cin>>num[i];
    while(q--)
    {
        int x;
        cin>>x;
       	int l=0,r=n-1;
        while(l<r)
        {
            int mid=l + r >>1;//相当于把l+r后用二进制表示的结果整体右移一位，即整体除以2
           	if(x<=num[mid])//这里x可以等于num[mid],说明x在数组中间的左边
                r=mid;//限制右端点
            else l=mid+1;
        }
        if(x==num[r]) cout<<r<<" ";
        r=n-1;
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(num[mid]<=x) l=mid;//这里是l=mid,所以mid要写成l+r+1>>1
            else r=mid-1;
        }
        if(x==num[l]) cout<<l<<endl;
        else 
        cout<<"-1 -1"<<endl;
    }
   
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2.数的三次方根

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

输入格式
共一行，包含一个浮点数 n。

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

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

数据范围
−10000≤n≤10000
输入样例：
1000.00
输出样例：
10.000000

解题思路：

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

int main(){
    double n;
    cin>>n;
    double l=-10000,r=10000;
    while(r-l>1e-8)
    {
        double mid=(l+r)/2;//double 类型不能使用移位运算
        if(mid*mid*mid>=n) r=mid;
        else l=mid;
    }
    printf("%.6f",l);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

二、前缀和

前缀和主要分为;

一维前缀和：

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

二维前缀和：

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

3.前缀和

输入一个长度为 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>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=100010;
int sum[N];
int a[N];
int n,m;



int main(){

    cin>>n>>m;
    
    //预处理
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        sum[i]=sum[i-1]+x;
    }
    
    
    while(m--)
    {
        int l,r;
        cin>>l>>r;
        cout<<sum[r]-sum[l-1]<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4.子矩阵的和

输入一个 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>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=1010;
int n,m;
int q;
int g[N][N];
int sum[N][N];

int main(){
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++) 
        for(int j=1;j<=m;j++)//为避免出现越界问题，我一般习惯将数组从1开始计数
        {
            cin>>g[i][j];
            sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+g[i][j];//处理前缀和数组
            
        }
    
    
    while(q--)
    {
        int x1,x2,y1,y2;
        cin>>x1>>y1>>x2>>y2;
        //利用前缀和数组计算某个子矩阵的和
        cout<<sum[x2][y2]-sum[x2][y1-1]-sum[x1-1][y2]+sum[x1-1][y1-1]<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

三、进阶

5.机器人跳跃问题

机器人正在玩一个古老的基于 DOS 的游戏。

游戏中有 N+1 座建筑——从 0 到 N 编号，从左到右排列。

编号为 0 的建筑高度为 0 个单位，编号为 i 的建筑高度为 H(i) 个单位。

起初，机器人在编号为 0 的建筑处。

每一步，它跳到下一个（右边）建筑。

假设机器人在第 k 个建筑，且它现在的能量值是 E，下一步它将跳到第 k+1 个建筑。

如果 H(k+1)>E，那么机器人就失去 H(k+1)−E 的能量值，否则它将得到 E−H(k+1) 的能量值。

游戏目标是到达第 N 个建筑，在这个过程中能量值不能为负数个单位。

现在的问题是机器人至少以多少能量值开始游戏，才可以保证成功完成游戏？

输入格式
第一行输入整数 N。

第二行是 N 个空格分隔的整数，H(1),H(2),…,H(N) 代表建筑物的高度。

输出格式
输出一个整数，表示所需的最少单位的初始能量值上取整后的结果。

数据范围
1≤N,H(i)≤105,

输入样例1：
5
3 4 3 2 4
输出样例1：
4
输入样例2：
3
4 4 4
输出样例2：
4
输入样例3：
3
1 6 4
输出样例3：
3

解题思路：

两种情况：

1.若H(k+1)>E：则跳完之后的能量为E-(H(k+1)−E)=2E-H(k+1).

2.若H(k+1)<E: 则跳完之后的能量为E+(E-H(k+1))=2E-H(k+1).

可以发现两种情况最后所得到的能量值是相同的由此可得：

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;
const int N=100010;
int n;
int arr[N];


bool check(int e)
{
    for(int i=0;i<n;i++){
        e=e*2-arr[i];
        if(e>1e5) return true;//若当前能量e大于1e5（最大值），则两倍的e减一个数必定还是大于1e5（最大值）
        if(e<0) return false;//能量值非负
    }
    return true;
}

int main(){
    cin>>n;
    for(int i=0;i<n;i++) cin>>arr[i];
    
    //二分查找能量值
    int l=0,r=1e5;
    while(l<r)
    {
        int mid=r+l>>1;
        if(check(mid)) r=mid;
        else l=mid+1;
    }
    cout<<l<<endl;//cout<<r<<endl一样的，因为此时l=r了
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

6.四平方和

四平方和定理，又称为拉格朗日定理：

每个正整数都可以表示为至多 4 个正整数的平方和。

如果把 0 包括进去，就正好可以表示为 4 个数的平方和。

比如：

5=02+02+12+22
7=12+12+12+22
对于一个给定的正整数，可能存在多种平方和的表示法。

要求你对 4 个数排序：

0≤a≤b≤c≤d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法。

输入格式
输入一个正整数 N。

输出格式
输出4个非负整数，按从小到大排序，中间用空格分开。

数据范围
0<N<5∗106
输入样例：
5
输出样例：
0 0 1 2

解题思路：

若用暴力算法，要用4个for循环，题目要求输出第一个按字典序排列的4个数，因此可以先从后面两个c和d开始选择，然后记录两个数的平方和已经出现过并赋值，再对a和b两个数进行选择

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=5000010;
int C[N],D[N];//哈希表，两个数组记录c*c+d*d是否出现过
int n;

int main(){
    cin>>n;
    //可能存在多对c和d使s相同，保留第一对方案
    memset(C,-1,sizeof C);
    for(int c=0;c*c<=n;c++)
    {
        for(int d=c;d*d+c*c<=n;d++)
        {
            int s=c*c+d*d;
            if(C[s]==-1)//若当前s还没有出现过
            C[s]=c,D[s]=d;
        }
    }
      
    //
    for(int a=0;a*a<=n;a++)
    {
        for(int b=a;b*b+a*a<=n;b++)
        {
            int s=n-a*a-b*b;
            if(C[s]!=-1)//判断s已经出现过
            {
                printf("%d %d %d %d\n",a,b,C[s],D[s]);
                return 0;
                
            }
        }
    }
      
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

7.分巧克力

儿童节那天有 K 位小朋友到小明家做客。

小明拿出了珍藏的巧克力招待小朋友们。

小明一共有 N 块巧克力，其中第 i 块是 Hi×Wi 的方格组成的长方形。

为了公平起见，小明需要从这 N 块巧克力中切出 K 块巧克力分给小朋友们。

切出的巧克力需要满足：

形状是正方形，边长是整数
大小相同
例如一块 6×5 的巧克力可以切出 6 块 2×2 的巧克力或者 2 块 3×3 的巧克力。

当然小朋友们都希望得到的巧克力尽可能大，你能帮小明计算出最大的边长是多少么？

输入格式
第一行包含两个整数 N 和 K。

以下 N 行每行包含两个整数 Hi 和 Wi。

输入保证每位小朋友至少能获得一块 1×1 的巧克力。

输出格式
输出切出的正方形巧克力最大可能的边长。

数据范围
1≤N,K≤105,
1≤Hi,Wi≤105
输入样例：
2 10
6 5
5 6
输出样例：
2

解题思路：

题目中给定的是每块巧克力的数量，不能把巧克力拼接，只能将每块巧克力都分隔开

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=100010;
int n,k;
int h[N],w[N];//存储巧克力长宽


bool check(int mid){
    int res=0;
    for(int i=0;i<n;i++)
    {
        res+=(h[i]/mid)*(w[i]/mid);
        if(res>=k) return true;
    }
    return false;
}

int main(){
	cin>>n>>k;
    for(int i=0;i<n;i++) cin>>h[i]>>w[i];
    
    //二分查找巧克力的边长
    int l=1,r=1e5;//此处l从1开始，因为巧克力最小边长为1，最大边长为1e5
    while(l<r)
    {
        int mid=l+r+1>>1;
        if(check(mid)) l=mid;//此处是l=mid所以对应的mid应该加1后除以2
        else r=mid-1;
    }
    cout<<l<<endl;
    return 0;
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

8.激光炸弹

地图上有 N 个目标，用整数 Xi,Yi 表示目标在地图上的位置，每个目标都有一个价值 Wi。

注意：不同目标可能在同一位置。

现在有一种新型的激光炸弹，可以摧毁一个包含 R×R 个位置的正方形内的所有目标。

激光炸弹的投放是通过卫星定位的，但其有一个缺点，就是其爆炸范围，即那个正方形的边必须和 x，y 轴平行。

若目标位于爆破正方形的边上，该目标不会被摧毁

求一颗炸弹最多能炸掉地图上总价值为多少的目标。

输入格式
第一行输入正整数 N 和 R，分别代表地图上的目标数目和正方形的边长，数据用空格隔开。

接下来 N 行，每行输入一组数据，每组数据包括三个整数 Xi,Yi,Wi，分别代表目标的 x 坐标，y 坐标和价值，数据用空格隔开。

输出格式
输出一个正整数，代表一颗炸弹最多能炸掉地图上目标的总价值数目。

数据范围
0≤R≤109
0<N≤10000,
0≤Xi,Yi≤5000
0≤Wi≤1000
输入样例：
2 1
0 0 1
1 1 1
输出样例：
1

解题思路：

本题是一个二维前缀和的问题。只有在框里能够框起来的交点（目标物体）才能被炸弹炸掉。其中炸弹最多只能炸掉RxR范围内的目标，若方框与边重合则只能炸（R-1）x（R-1）范围内的目标。

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=5010;//因为X，Y最大不超过5000，所以R不需要那么大的范围,只需要比5000大1的数即可
int n,m;
int s[N][N];

int main(){
    int cnt,r;
    cin>>cnt>>r;
    r=min(5001,r);
    
    n=m=r;
    while(cnt--)
    {
        int x,y,w;
        cin>>x>>y>>w;
        x++,y++;//为防止出现边界问题，将x，y整体都向后移动一位
        n=max(n,x),m=max(m,y);
        s[x][y]+=w;
    }
    
    //预处理前缀和
    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];//为节省内存空间，这里将前缀和数组和原始数组合并了
    
    int res=0;
    
    //枚举所有边长是R的矩形，枚举（i，j）为右下角
    for(int i=r;i<=n;i++)
        for(int j=r;j<=m;j++)
        {
            res=max(res,s[i][j]-s[i-r][j]-s[i][j-r]+s[i-r][j-r]);
        }
        
    cout<<res<<endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

10.K倍区间

给定一个长度为 N 的数列，A1,A2,…AN，如果其中一段连续的子序列 Ai,Ai+1,…Aj 之和是 K 的倍数，我们就称这个区间 [i,j] 是 K 倍区间。

你能求出数列中总共有多少个 K 倍区间吗？

输入格式
第一行包含两个整数 N 和 K。

以下 N 行每行包含一个整数 Ai。

输出格式
输出一个整数，代表 K 倍区间的数目。

数据范围
1≤N,K≤100000,
1≤Ai≤100000
输入样例：
5 2
1
2
3
4
5
输出样例：
6

解题思路：

本题可以先用暴力的算法：

for(int R=1;R<=n;R++)
{
    for(int L=1;L<=R;L++)
    {
        int s=sum[R]-sum[L-1];
        if(s%k==0) res++;
    }
}
1
2
3
4
5
6
7
8

此时算法时间复杂度为O(n^2)也就是 (10⁵⁾²此时已经可以过60%的数据了，但是可不可以进行优化呢，这里可以发现，(sum[r]-sum[l-1])%k==0就相当于sum[r]%k==sum[l-1]%k,也就是说前缀和%等于k0的组合，以及两相同前缀和%k的组合都是满足条件的，因此，可以用cnt数组来记录相同前缀和%k的数目，再用res递加cnt数组得到答案。

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=100010;
typedef long long LL;
LL sum[N],cnt[N];

int main(){
    int n,k;
    cin>>n>>k;
    for(int i=1;i<=n;i++){
        cin>>sum[i];
        sum[i]+=sum[i-1];//构建前缀和数组
    }
    
    LL res=0;
    cnt[0]=1;//特判，当sum[i]=0时也是k的倍数
    for(int i=1;i<=n;i++)
    {
        res+=cnt[sum[i]%k];
        cnt[sum[i]%k]++;
    }
    cout<<res<<endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28