二分+高精度+前缀和
二分
整数二分
二分的本质是边界。假设在一个区间上定义了某种性质，整个区间可以被一分为二，使得这个性质在右半段区间满足而在左半段不满足。二分可以寻找边界，既可以找到左半段的右边界a，也可以找到右半段的左边界b。
在右半段寻找左边界
每次将区间划分为[l, mid]和[mid + 1, r]（[l, mid]是因为mid点可能就是左边界，所以这里不用[l, mid - 1]
{
while(l < r){
int mid = (l + r) / 2;
if(check(mid)) r = mid; //如果符合性质
else l = mid + 1;
}
return l;
}
在左半段寻找右边界
每次将区间划分为[l, mid - 1]和[mid, r]（这是因为如果mid点符合性质，那么下次划分右边界肯定从mid-1开始）
{
while(l < r){
int mid = (l + r + 1) / 2;
if(check(mid)) l = mid;
else r = mid - 1;
}
return l;
}
现在我们来看一下二分的题：
给定一个按照升序排列的长度为 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<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int q[N];
int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);
for (int i = 0; i < m; i ++ )
{
int x;
scanf("%d", &x);
// 二分x的左端点
int l = 0, r = n - 1; // 确定区间范围
while (l < r)
{
int mid = l + r >> 1;
if (q[mid] >= x) r = mid;
else l = mid + 1;
}
if (q[r] == x)
{
cout << r << ' ';
// 二分x的右端点
r = n - 1; // 右端点一定在[左端点, n - 1] 之间
while (l < r)
{
int mid = l + r + 1 >> 1; // 因为写的是l = mid，所以需要补上1
if (q[mid] <= x) l = mid;
else r = mid - 1;
}
cout << r << endl;
}
else cout << "-1 -1" << endl;
}
return 0;
}
浮点数二分
浮点数二分比较简单
给定一个浮点数 n，求它的三次方根。
输入格式
共一行，包含一个浮点数 n。
输出格式
共一行，包含一个浮点数，表示问题的解。
注意，结果保留 6 位小数。
数据范围
−10000≤n≤10000
输入样例：
1000.00
输出样例：
10.000000
下面请看代码：
#include<bits/stdc++.h>
using namespace std;
int main()
{
double x;
cin >> x;
double l = -10000, r = 10000;
while (r - l > 1e-8)
{
double mid = (l + r) / 2;
if (mid * mid * mid >= x) r = mid;
else l = mid;
}
printf("%lf\n", l);
return 0;
}
高精度
高精度加法
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> A,B;
vector<int> add(vector<int> &A, vector<int> &B)
{
vector<int> res; //定义一个存放结果
int t = 0; //进位
for (int i = 0; i<A.size() || i<B.size(); i ++ )//遍历A,B每一位数，当i都大于两个数的数位，才结束
{
if(i<A.size()) t += A[i]; //加上对应位的数字
if(i<B.size()) t += B[i];
res.push_back(t%10); //加完后模10，剩余的做进位
t /= 10; //进位
}
if(t) res.push_back(t); // for循环结束后，还有进位，说明溢出了一位
return res;
}
int main()
{
string a,b; //读入数据
cin >> a >> b; // a = "123456" b = "123"
for (int i = a.size()-1; i >= 0; i -- ) A.push_back(a[i]-'0'); //A = [6,5,4,3,2,1]
for (int i = b.size()-1; i >= 0; i -- ) B.push_back(b[i]-'0'); //B = [3,2,1]
vector<int> c = add(A,B);
for (int i = c.size()-1; i >= 0; i -- ) printf("%d",c[i]); //倒序输出
return 0;
}
高精度减法
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> A,B;
bool cmp(vector<int> &A,vector<int> &B) //比较A是否大于等于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) // A>=B 的减法
{
vector<int> res;
int t = 0; //借位
for (int i = 0; i < A.size() || i < B.size(); i ++ )
{
t = A[i]-t; //被减数上的每一位数先减去借位
if(i < B.size()) t -= B[i]; //减去减数
res.push_back((t+10)%10); // t>0，差的对应数位就为t
// t<0, 差的对应数位应该为t+10
if(t >= 0) t = 0; // t>0 说明够减 借位为0
else t = 1; // t>0 说明不够减，需要借位 借位为1
}
return res;
}
int main()
{
string a,b;
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)) // A>=B时
{
auto C = sub(A,B);
while (C.size() > 1 && C.back() == 0) C.pop_back();
for (int i = C.size()-1; i >= 0; i -- ) printf("%d",C[i]);
}
else // A<B时 A-B=-(B-A)
{
auto C = sub(B,A);
while (C.size() > 1 && C.back() == 0) C.pop_back();
printf("-"); //先输出负号
for (int i = C.size()-1; i >= 0; i -- ) printf("%d",C[i]);
}
return 0;
}
高精度乘法
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> A;
vector<int> multi(vector<int> &A, int b)
{
vector<int> res;
int t = 0; //进位
for (int i = 0; i < A.size(); i ++ )
{
t = A[i]*b+t; //乘上整体b并加上进位
res.push_back(t%10); // 填入对应位结果
t /= 10; // 进位
}
if(t) res.push_back(t); //多余的进位，补上
return res;
}
int main()
{
string a;
int b;
cin >> a >> b;
for (int i = a.size()-1; i >= 0; i -- ) A.push_back(a[i]-'0');
auto C = multi(A,b);
while(C.size() > 1 && C.back()==0) C.pop_back();
for (int i = C.size()-1; i >= 0; i -- ) printf("%d",C[i]);
return 0;
}
高精度除法
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> div(vector<int> &A, int &b,int &r)
{
vector<int> res;
for (int i = A.size()-1; i >= 0; i -- )
{
r = r*10+A[i]; // 每一步除法就是余数r*10加上下一位数，再除以除数得到商的一位
res.push_back(r/b);
r %= b; // 对除数取模后得到新的余数r
}
reverse(res.begin(),res.end());
while(res.size()>1 && res.back() == 0) res.pop_back();
return res;
}
vector<int> A;
int main()
{
string a;
int b;
cin >> a >> b;
for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
int r = 0; // r用于存余数，初始化为0
auto c = div(A,b,r);
for(int i=c.size()-1;i>=0;i--) printf("%d",c[i]);
cout << endl << r << endl;
return 0;
}
前缀和
一维前缀和
具体做法：
首先做一个预处理，定义一个sum[]数组，sum[i]代表a数组中前i个数的和。
求前缀和运算：
const int N=1e5+10;
int sum[N],a[N]; //sum[i]=a[1]+a[2]+a[3].....a[i];
for(int i=1;i<=n;i++)
{
sum[i]=sum[i-1]+a[i];
}
用这个公式我们可以来看一下这道题：
输入一个长度为 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 <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int a[N]; // 表示原数组
int s[N]; // 表示前缀和数组
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++ )
{
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
}
while (m -- )
{
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", s[r] - s[l - 1]);
}
return 0;
}
二维前缀和
定义二维前缀和数组：
s[i][j]表示二维数组中，左上角(1,1)到右下角( i,j )所包围的矩阵元素的和。
紫色区域是指(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][j-1] - s[i-1][j-1] + a[i][j]
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
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 ++ ) scanf("%d",&a[i][j]);
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ ) s[i][j]=s[i][j-1]+s[i-1][j]-s[i-1][j-1]+a[i][j]; // 初始化二维前缀和数组
while(q--)
{
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
printf("%d\n",s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1]); //二维数组前缀和计算公式：[i] [j] = s[i-1][j] + s[i][j-1] + a[i] [j] - s[i-1][ j-1]
}
}
注意：二维数组从行和列都下标1开始存，并且将a[0][0]定义为0，S[0][0]定义为0,目的一样是为了好处理边界。
145
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
