浮点数判断相等与否
在c++中，判断浮点数不能单独的用 a == b去判断。
例如：存了100组斜率和截距，y = kx + b判断有多少对不同的直线。思路是按斜率k第一关键字，截距b第二关键字从小到大（从大到小）排序。然后判断前后k和b至少一项不相同，res就加1；
浮点数判断相等，一般是两个浮点数相减后绝对值小于一个很小的浮点数，一般取1e-8。
同理判断不相等，一般是两个浮点数相减后的绝对值大于1e-8
int res = 1;
for(int i = 2;i <= 100;i ++)
if(fabs(p[i].first - p[i - 1].first) > 1e-8
|| fabs(p[i].second - p[i - 1].second) > 1e-8)
res++;
//斜率和截距有一个不相等就为不同直线
cout <<res<<endl;
筛质数
筛1~n中的质数，线性筛
int get(int n)
{
int cnt = 0;
for(int i = 2;i <= n;i ++)
{
if(!st[i])
{
primes[++cnt] = i;
}
//每次用最小质因数去筛
for(int j = 1;primes[j] <= n/i ; j ++)
{
st[primes[j] * i] = true;
if(i % primes[j] == 0)
break;
}
}
return cnt;
}
分解质因数
void get(int n)
{
for(int i = 2;i <= n/i;i ++) //这样分解，确实都是质因数
{
int cnt = 0;
if(n % i == 0)
{
while(n %i == 0)
{
n /= i;
cnt++;
}
cout <<i <<" "<<cnt<<endl;
}
}
if(n > 1)
cout <<n <<" " <<1<<endl;
}
约数个数
#include <iostream>
#include <unordered_map>
using namespace std;
typedef long long int LL;
const int mod = 1e9 + 7;
int main()
{
LL res = 1;
unordered_map<int,int> mp;
int n;
cin >> n;
while(n--)
{
int x;
cin >> x;
for(int i = 2;i <= x/i ;i ++)
{
if(x % i == 0 )
{
int cnt = 0;
while(x % i == 0 )
{
x /= i;
cnt++;
}
mp[i] += cnt;
}
}
if( x > 1)
mp[x]++;
}
for(auto each:mp)
{
res = res * (each.second + 1) % mod;
}
cout <<res % mod<<endl;
return 0;
}
约数之和
#include <iostream>
#include <unordered_map>
using namespace std;
typedef long long int LL;
const int mod = 1e9 + 7;
int main()
{
unordered_map<int,int> mp;
int n;
cin >> n;
while(n--)
{
int x;
cin >> x;
for(int i = 2;i <= x / i; i ++)
{
if(x % i == 0 )
{
int cnt = 0;
while(x % i == 0 )
{
x /= i;
cnt++;
}
mp[i] += cnt;
}
}
if(x > 1)
mp[x] ++;
}
LL res = 1;
for(auto each:mp)
{
LL sum =1;
int p = each.first;
int t = each.second;
while(t--)
{
sum = (sum * p + 1) % mod;
}
res = res * sum % mod;
}
cout <<res % mod<<endl;
return 0;
}
快速幂，预处理出a的2的k次方，k为0、1、2、3…也就是a的1次方、a的2次方、a的4次方、a的8次方…
用于在 L o g N LogN LogN的时间复杂度内求出：a^k mod p
#include <iostream>
using namespace std;
typedef long long int LL;
LL qmi(int a,int k,int p)
{
int res = 1;
while(k)
{
if(k & 1)
res = (LL)res * a %p;
k = k>>1;
a = (LL)a * a % p;
}
return res ;
}
int main()
{
int n;
cin >> n;
while(n--)
{
int a,k,p;
cin >>a >> k >> p;
cout <<qmi(a,k,p)<<endl;
}
return 0;
}
快速幂求逆元
比如b的逆元，就是一个数除以b mod m，等于那个数乘以x mod m。那么就称x为b的乘法逆元。
快速幂求逆元，如果b%mod==0，则没有逆元，
否则，b的乘法逆元为b^mod-2
传入参数qmi（a,mod-2,mod）
#include <iostream>
using namespace std;
typedef long long int LL;
LL qmi(LL a,int k,int mod)
{
LL res = 1;
while(k)
{
if(k & 1)
res = (res * a) % mod;
k = k >> 1;
a = (a * a) % mod;
}
return res % mod;
}
int main()
{
int n;
cin >> n;
while(n--)
{
LL a;
int p;
cin >> a >> p;
if(a % p == 0)
cout <<"impossible"<<endl;
else
cout <<qmi(a,p-2,p)<<endl;
}
return 0;
}
高精度加法
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string add(string &a,string &b)
{
string c="";
int cnt=0;
for(int i=a.size()-1,j=b.size()-1;i>=0||j>=0||cnt>0;i--,j--)
{
if(i>=0)
cnt+=(a[i]-'0');
if(j>=0)
cnt+=(b[j]-'0');
c+=(cnt%10)+'0';
cnt/=10;
}
reverse(c.begin(),c.end());
return c;
}
int main()
{
string s,ss;
cin >> s>>ss;
cout <<add(s,ss)<<endl;
}
字符串哈希
通过巧妙设置P (131 或 13331) , Q (2^64)的值，c++设置成unsigned long long int，会自动对2^64取余。
题面
给定一个长度为 n 的字符串，再给定 m 个询问，每个询问包含四个整数 l1,r1,l2,r2，请你判断 [l1,r1] 和 [l2,r2] 这两个区间所包含的字符串子串是否完全相同。
字符串中只包含大小写英文字母和数字。
输入格式
第一行包含整数 n 和 m，表示字符串长度和询问次数。
第二行包含一个长度为 n 的字符串，字符串中只包含大小写英文字母和数字。
接下来 m 行，每行包含四个整数 l1,r1,l2,r2，表示一次询问所涉及的两个区间。
注意，字符串的位置从 1 开始编号。
输出格式
对于每个询问输出一个结果，如果两个字符串子串完全相同则输出 Yes，否则输出 No。
每个结果占一行。
数据范围
1≤n,m≤105
输入样例：
8 3
aabbaabb
1 3 5 7
1 3 6 8
1 2 1 2
输出样例：
Yes
No
Yes
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010,p = 131;
typedef unsigned long long int ULL;
ULL pe[N],h[N];
char s[N];
int n,m;
ULL get(int l,int r)
{
return h[r] - h[l - 1] * pe[r - l +1];
}
int main()
{
cin >> n >> m;
getchar();
pe[0] = 1;
cin >> s + 1;
for(int i = 1;i <= n;i ++)
{
pe[i] = pe[i - 1] * p;
h[i] = h[i - 1] * p + s[i];
}
while(m--)
{
int l1,r1,l2,r2;
cin >> l1 >> r1 >> l2 >> r2;
if(get(l1,r1) == get(l2,r2))
{
cout <<"Yes"<<endl;
}
else
cout <<"No"<<endl;
}
return 0;
}
树状数组， L o g N LogN LogN时间复杂度，处理加上一个数，求区间【L,R】的和。
单点修改，区间查询。
题面:动态求连续区间和
给定 n 个数组成的一个数列，规定有两种操作，一是修改某个元素，二是求子数列 [a,b] 的连续和。
输入格式
第一行包含两个整数 n 和 m，分别表示数的个数和操作次数。
第二行包含 n 个整数，表示完整数列。
接下来 m 行，每行包含三个整数 k,a,b （k=0，表示求子数列[a,b]的和；k=1，表示第 a 个数加 b）。
数列从 1 开始计数。
输出格式
输出若干行数字，表示 k=0 时，对应的子数列 [a,b] 的连续和。
数据范围
1≤n≤100000,
1≤m≤100000，
1≤a≤b≤n,
数据保证在任何时候，数列中所有元素之和均在 int 范围内。
输入样例：
10 5
1 2 3 4 5 6 7 8 9 10
1 1 5
0 1 3
0 4 8
1 7 5
0 4 8
输出样例：
11
30
35
#include <iostream>
using namespace std;
const int N = 100010;
int c[N],a[N];
int n,m;
int lowbit(int x)
{
return x & -x;
}
void add(int x,int u)
{
for(int i = x;i <= n;)
{
c[i] += u;
i += lowbit(i);
}
}
int get(int x)
{
int res = 0;
for(int i = x;i>=1;)
{
res += c[i];
i -= lowbit(i);
}
return res;
}
int main()
{
ios::sync_with_stdio(false);
cin >> n >> m;
for(int i = 1;i <= n;i ++)
{
cin >> a[i];
}
for(int i = 1;i <= n;i ++)// 这里别忘了
add(i,a[i]);
while(m--)
{
int op;
cin >> op;
if(op == 0)
{
int l,r;
cin >> l >> r;
cout <<get(r) - get(l - 1)<<endl;
}
else
{
int p,x;
cin >> p >> x;
add(p,x);
}
}
return 0;
}
c++对负数取模，按理说，数学上对负数取模是正的，但是c++却是负的。比如：-5 % 3,数学上是1，但是c++却是-2。
公式了,我这样写的。
若给一个数正数a，想对它的负数求模。
res = ((mod - (a % mod)) % mod);
同理，给一个负数，相对它本身求模。
res = ((mod - (-a % mod)) % mod);
扩展欧几里得
给定 n 对正整数 ai,bi，对于每对数，求出一组 xi,yi，使其满足 ai×xi+bi×yi=gcd(ai,bi)。
输入格式
第一行包含整数 n。
接下来 n 行，每行包含两个整数 ai,bi。
输出格式
输出共 n 行，对于每组 ai,bi，求出一组满足条件的 xi,yi，每组结果占一行。
本题答案不唯一，输出任意满足条件的 xi,yi 均可。
数据范围
1≤n≤105,
1≤ai,bi≤2×109
输入样例：
2
4 6
8 18
输出样例：
-1 1
-2 1
#include <iostream>
using namespace std;
int exgcd(int a,int b,int &x,int &y) // x,y引用传参
{
if(b == 0)
{
x = 1;
y = 0;
return a;
}
int d = exgcd(b,a % b,x,y);
int temp = y;
y = x-a/b * y;
x = temp;
return d; //这个d是最大公因数
}
int main()
{
int n;
cin >> n;
while(n--)
{
int a,b;
cin >> a>> b;
int x,y;
exgcd(a,b,x,y); //x,y为所求的一组解
cout << x << " "<< y <<endl;
}
return 0;
}
扩展欧几里得求线性同余方程(逆元)
给定 n 组数据 ai,bi,mi，对于每组数求出一个 xi，使其满足 ai×xi≡bi(modmi)，如果无解则输出 impossible。
输入格式
第一行包含整数 n。
接下来 n 行，每行包含一组数据 ai,bi,mi。
输出格式
输出共 n 行，每组数据输出一个整数表示一个满足条件的 xi，如果无解则输出 impossible。
每组数据结果占一行，结果可能不唯一，输出任意一个满足条件的结果均可。
输出答案必须在 int 范围之内。
数据范围
1≤n≤105,
1≤ai,bi,mi≤2×109
输入样例：
2
2 3 6
4 3 5
输出样例：
impossible
-3
#include <iostream>
using namespace std;
typedef long long int LL;
int exgcd(int a,int b,int &x,int &y)
{
if(b == 0 )
{
x = 1;
y = 0;
return a;
}
int d = exgcd(b,a % b,x,y);
int temp = y;
y = x - a / b * y;
x = temp;
return d;
}
int main()
{
cin.tie(0);
int n;
cin >> n;
while(n--)
{
int a,b,m;
cin >> a >> b >> m; //给定 a，b，m 求 a*答案 = b mod (m)
int x,y;
int d = exgcd(a,m,x,y);//返回d = a和m的最大公因数
if(b % d == 0 ) // b是d的整数倍有解
cout <<(LL)x * b / d % m<<endl;
else
cout <<"impossible"<<endl;
}
}
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
