# NOIP前 基础数学模板

/*
created by scarlyw
基础数学模板
*/
#include <bits/stdc++.h>

//最大公约数 & 最小公倍数
namespace gcd_lcm() {
//最大公约数 O(logn)
inline int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}

//最小公倍数 (logn)
inline int lcm(int a, int b) {
return a * b / gcd(a, b);
}
}

//线筛
namespace s_seive {

//线筛质数 和 莫比乌斯函数(容斥函数) O(n)
int prime[MAXN], miu[MAXN];
int prime_cnt, n;
bool not_prime[MAXN];
inline void seive(int n) {
not_prime[1] = true, miu[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!not_prime[i]) prime[++prime_cnt] = i, miu[i] = -1;
for (int j = 1; j <= prime_cnt && prime[j] * i <= n; ++j) {
not_prime[i * prime[j]] = true;
if (i % prime[j] == 0) {
miu[i * prime[j]] = 0;
break;
}
miu[i * prime[j]] = -miu[i];
}
}
}
}

//质因子分解
namespace compose {

//暴力分解 O(sqrt(n))
inline void get_pactor() {
std::cin >> n, std::cout << n << "=";
for (int i = 2; i <= sqrt(n); ++i) {
while (n % i == 0) {
if (n == i) std::cout << i, exit(0);
else std::cout << i << "*", n /= i;
}
}
if (n != 1) std::cout << n;
}
}

//扩展欧几里得
namespace extand_gcd() {

//扩欧 O(logn)最后的(x % b + b) % b是满足ax = 1(mod b)的最小x
long long a, b, x, y, temp;
inline void ext_gcd(long long a, long long b) {
if (b == 0) x = 1, y = 0;
else ext_gcd(b, a % b), temp = x, x = y, y = temp - a / b * y;
}
}

//快速幂 & 快速乘
namespace mul_pow {

//O(log n)快速乘
long long n, m, mod;
inline long long mod_mul(long long a, long long b) {
long long ans = 0;
for (; b; b >>= 1, a = (a + a) % mod)
if (b & 1) ans = (ans + a) % mod;
return ans;
}

//O(1)快速乘
inline long long mod_mul(long long a, long long b) {
return (a * b - (long long)((long double)a / mod * b) * mod + mod) % mod;
}

//O(logn)快速幂
inline long long mod_pow(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = mod_mul(a, a))
if (b & 1) ans = mod_mul(ans, a);
return ans;
}
}

//组合数
namespace combination {

//O(n ^ 2)组合数递推，方便取模
const int MAXN = 1000 + 10;
const int mod = 1000000000 + 7;
int c[MAXN][MAXN];
inline void get_c(int n) {
for (int i = 0; i <= n; ++i) c[i][0] = 1, c[i][i] = 1;
for (int i = 2; i <= n; ++i)
for (int j = 1; j < i; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}

//O(n)预处理阶乘和阶乘逆元，然后O(1)询问组合数
int fac[MAXN], inv[MAXN];
inline void get_c(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = (long long)fac[i - 1] * i % mod;
inv[n] = mod_pow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i)
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}

inline int c(int n, int m) {
return (long long)fac[n] * inv[m] % mod * inv[n - m] % mod;
}
}

//进制转换

//十进制转任意进制
static int sum[100], cnt;
for (int i = cnt; i >= 1; --i)
if (sum[i] >= 10) std::cout << (char)(sum[i] + 'A' - 10);
else std::cout << sum[i];
return 0;
}

//任意进制转十进制
static int cnt, y;
cnt = strlen(s + 1);
for (int i = 1, y = 0; i <= cnt; ++i) {
if (isdigit(s[i])) y = y * radix + s[i] - '0';
else y = y * radix + s[i] - 'A' + 10;
}
std::cout << y;
}
}

//高精度
namespace big_integer {

const int MAXN = 200 + 10;
const int DIGIT = 1000000000;
//压9位的简单高精度类
struct big_integer {
long long a[MAXN];
int len;

//将big_integer初始化为long long or string代表的数字
big_integer(long long s = 0) {
len = 0, memset(a, 0, sizeof(a));
do a[++len] = s % DIGIT, s /= DIGIT;
while (s);
}

big_integer(char *s) {
len = 0, memset(a, 0, sizeof(a));
int s_len = strlen(s + 1);
long long t = 0, k = 1;
for (int i = s_len; i >= 1; --i) {
t = t + (s[i] ^ '0') * k, k = ((k << 2) + k << 1);
if (k == DIGIT) a[++len] = t, k = 1, t = 0;
}
if (t != 0) a[++len] = t;
}

//重载方括号b[i] = b.a[i];
inline long long & operator [] (const int &c) {
return a[c];
}

//重载方括号b[i] = b.a[i];
inline const long long & operator [] (const int &c) const {
return a[c];
}

//重载 <
inline bool operator < (const big_integer &b) const {
if (len != b.len) return len < b.len;
for (int i = len; i >= 1; --i)
if (a[i] != b[i]) return a[i] < b[i];
return false;
}

//高精 + 高精，重载 +，返回高精和
inline big_integer operator + (const big_integer &b) const {
big_integer c;
for (int i = 1; i <= len || i <= b.len; ++i)
c[i] += a[i] + b[i], c[i + 1] += c[i] / DIGIT, c[i] %= DIGIT;
c.len = std::max(len, b.len) + 2;
while (c[c.len] == 0) c.len--;
return (c.len) ? (0) : (c.len = 0), c;
}

//高精 * 高精，重载 *，返回高精积
inline big_integer operator * (const big_integer &b) const {
big_integer c;
for (int i = 1; i <= len; ++i)
for (int j = 1; j <= b.len; ++j) {
int pos = i + j - 1;
c[pos] += a[i] * b[j], c[pos + 1] += c[pos] / DIGIT;
c[pos] %= DIGIT;
}
c.len = len + b.len + 3;
while (c[c.len] == 0) c.len--;
return (c.len) ? (0) : (c.len = 1), c;
}

//高精 - 高精，重载 -，返回高精差，默认减数 > 被减数
inline big_integer operator - (const big_integer &b) const {
big_integer c;
for (int i = 1; i <= len; ++i)
c[i] += a[i] - b[i], (c[i] < 0) ? (c[i] += DIGIT, c[i + 1]--) : 0;
c.len = len;
while (c[c.len] == 0) c.len--;
return (c.len) ? (0) : (c.len = 1), c;
}

//高精 / 单精，重载 /，返回高精商
inline big_integer operator / (const long long b) const {
big_integer c;
long long t = 0;
for (int i = len; i >= 1; --i)
c[i] = (a[i] + t * DIGIT) / b, t = (a[i] + t * DIGIT) % b;
c.len = len;
while (c[c.len] == 0) c.len--;
return (c.len) ? (0) : (c.len = 1), c;
}

//高精 % 单精， 重载%，返回单精
inline big_integer operator % (const long long b) const {
return *this - *this / b * b;
}

//输出
inline void write() const {
printf("%lld", a[len]);
for (int i = len - 1; i >= 1; --i) printf("%09lld", a[i]);
}
} ;

//重载cin, cin >> (big_integer)a, 直接读入一个字符串，然后将a赋值为字符串
inline std::istream & operator >> (std::istream &a, big_integer &b) {
static char s[MAXN << 4];
scanf("%s", s + 1), b = s;
return a;
}

//重载cout, cout << (big_integer)b, 输出b，利用write()
inline std::ostream & operator << (std::ostream &a, const big_integer &b) {
b.write();
return a;
}
}

//高斯消元
namespace gauss {

const int MAXN = 100 + 10;
int n;
double f[MAXN][MAXN], ans[MAXN];
//f[i][j]表示第i个等式中第j个变量的系数，f[i][n + 1]表示第i个等式的值
inline void solve() {
for (int i = 1; i <= n; ++i) {
int pos = -1;
for (int j = i; j <= n; ++j)
if (f[j][i] != 0) {
pos = j;
break ;
}
std::swap(f[pos], f[i]);
for (int j = i + 1; j <= n; ++j) {
double t = f[j][i] / f[i][i];
for (int k = i; k <= n + 1; ++k)
f[j][k] -= t * f[i][k];
}
}
for (int i = n; i >= 1; --i) {
ans[i] = f[i][n + 1] / f[i][i];
for (int j = 1; j < i; ++j)
f[j][n + 1] -= f[j][i] * ans[i];
}
for (int i = 1; i <= n; ++i) std::cout << int(ans[i] + 0.5) << " ";
}
}

//矩阵乘法 & 矩阵快速幂
namespace matrix {

const int MAXN = 200 + 10;
const int mod = 1000000000 + 7;
//矩阵类
struct matrix {
int a[MAXN][MAXN];
int n;
matrix() {}
matrix(int n) : n(n) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
a[i][j] = 0;
}

//重载 * ， 矩阵乘法
inline matrix operator * (const matrix &b) const {
matrix ans(n);
for (int i = 1; i <= n; ++i)
for (int k = 1; k <= n; ++k)
for (int j = 1; j <= n; ++j)
ans.a[i][j] = (ans.a[i][j] + a[i][k] * b.a[k][j]) % mod;
return ans;
}

//重载 ^ ，矩阵快速幂
inline matrix operator ^ (int b) const {
matrix ans(n), a = *this;
for (int i = 1; i <= n; ++i) ans.a[i][i] = 1;
for (; b; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
};
}

• 广告
• 抄袭
• 版权
• 政治
• 色情
• 无意义
• 其他

120