基础数论模板与公式

最新推荐文章于 2022-02-06 17:25:06 发布
最新推荐文章于 2022-02-06 17:25:06 发布
阅读量489 收藏 4
点赞数 2
分类专栏： 数论 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangsheng_meng/article/details/120063900
版权

1.素数判定
1.1试除法判素数

bool is_prime(int x)
{
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
            return false;
    return true;
}

1.2 Miller−Rabin 判定法

ll Rand() {//决定了程序的性能
    static ll x = (srand((int)time(0)), rand());
    x += 1000003;
    if (x > 1000000007)
        x -= 1000000007;
    
    return x;
}
bool Witness(ll a, ll n) {
    ll t = 0, u = n - 1;
    while (!(u & 1))
        u >>= 1, t++;
    ll x = qpow(a, u, n), y;//qpow为快速幂

    while (t--) {
        y = x * x % n;
        if (y == 1 && x != 1 && x != n - 1)
            return true;
        x = y;
    }
    return x != 1;
}
bool MillerRabin(ll n, ll s) {
    if (n == 2 || n == 3 || n == 5)
        return 1;

    if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n == 1)
        return 0;

    while (s--) {
        if (Witness(Rand() % (n - 1) + 1, n))
            return false;
    }
    return true;
}

1.3埃氏筛

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (st[i]) continue;
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}

1.4线性筛

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

2.质因数分解
2.1试除法分解

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
}

2.2 Pollard Rho 算法
见到的几种实现：
1-----------------------

#include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
using namespace std;
const int N = 1e5 + 7;
ll x, y, a[N];
ll max_factor;
struct BigIntegerFactor {
    const static int N = 1e6 + 7;
    const static ll inf=0x3f3f3f3f3f3f3f3f;
    ll prime[N], p[N], fac[N], sz, cnt; //多组输入注意初始化cnt = 0
    inline ll mul(ll a, ll b, ll mod) {          //WA了尝试改为__int128或慢速乘
        if (mod <= 1000000000)
            return a * b % mod;
        return (a * b - (ll)((long double)a / mod * b + 1e-8) * mod + mod) % mod;
    }
    void init(int maxn) //线性筛 
	{
        int tot = 0;
        sz = maxn - 1;
        for (int i = 1; i <= sz; ++i)
            p[i] = i;
        for (int i = 2; i <= sz; ++i) {
            if (p[i] == i)
                prime[tot++] = i;
            for (int j = 0; j < tot && 1ll * i * prime[j] <= sz; ++j) {
                p[i * prime[j]] = prime[j];
                if (i % prime[j] == 0)
                    break;
            }
        }
    }
    ll qpow(ll a, ll x, ll mod)
	{
        ll res = 1ll;
        while (x) {
            if (x & 1)
                res = mul(res, a, mod);
            a = mul(a, a, mod);
            x >>= 1;
        }
        return res;
    }
    bool check(ll a, ll n) {                     //二次探测原理检验n
        ll t = 0, u = n - 1;
        while (!(u & 1))
            t++, u >>= 1;
        ll x = qpow(a, u, n), xx = 0;
        while (t--) {
            xx = mul(x, x, n);
            if (xx == 1 && x != 1 && x != n - 1)
                return false;
            x = xx;
        }
        return xx == 1;
    }
    bool miller(ll n, int k) {
        if (n == 2)
            return true;
        if (n < 2 || !(n & 1))
            return false;
        if (n <= sz)
            return p[n] == n;
        for (int i = 0; i <= k; ++i) {            //测试k次
            if (!check(rand() % (n - 1) + 1, n))
                return false;
        }
        return true;
    }
    inline ll gcd(ll a, ll b) {
        return b == 0 ? a : gcd(b, a % b);
    }
    inline ll Abs(ll x) {
        return x < 0 ? -x : x;
    }
    ll Pollard_rho(ll n) {                 //基于路径倍增的Pollard_Rho算法
        ll s = 0, t = 0, c = rand() % (n - 1) + 1, v = 1, ed = 1;
        while (1) {
            for (int i = 1; i <= ed; ++i) {
                t = (mul(t, t, n) + c) % n;
                v = mul(v, Abs(t - s), n);
                if (i % 127 == 0) {
                    ll d = gcd(v, n);
                    if (d > 1)
                        return d;
                }
            }
            ll d = gcd(v, n);

            if (d > 1)
                return d;
            s = t;
            v = 1;
            ed <<= 1;
        }
    }
    void getfactor(ll n) {                         //得到所有的质因子(可能有重复的)
        if (n <= sz) {
            while (n != 1)
                fac[cnt ++ ] = p[n], n /= p[n];
            max_factor = max_factor > p[n] ? max_factor : p[n];
            return;
        }
        if (miller(n, 6)) {
            fac[cnt ++ ] = n;
            max_factor = max_factor > n ? max_factor : n;
        }
        else {
            ll d = n;
            while (d >= n)
                d = Pollard_rho(n);
            getfactor(d);
            getfactor(n / d);
        }
        return ;
    }
    ll cal(ll n,ll p){
		ll ans=0;
		while(n)
		{
		    ans+=n/p;
		    n/=p;
		}
		return ans;
	}
	ll slove(ll n,ll x,ll y){
		cnt=0;
		map<ll,ll> mm;
		getfactor(x);
		ll ans=inf;
		for(int i;i<cnt;i++)
		{
			mm[fac[i]]++;
		}
		for(auto it:mm)
		{
			ll num=0;
			for(int i=0;i<n;i++)
			{
				num+=cal(a[i],it.fi);
			}
			ans=min(ans,(cal(y,it.fi)-num)/it.se);
		}
		return ans;
	}
}Q;

int main()
{
	//Q.init(N - 1);//如果代码超时且仅需要分解大数的质因数可以用这句话，否则不要用
    ll t;
    scanf("%lld",&t);
    while(t--)
    {
    	
	}
}

2-----------------------------------------

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 1e5 + 7;
const ll mod = 998244353;

unordered_map <ll, ll> mp;
  
namespace rho{
    const int MAXP = 1000010;
    const int BASE[] = {2, 450775, 1795265022, 9780504, 28178, 9375, 325};

    long long seq[MAXP];
    int primes[MAXP], spf[MAXP];


    long long gcd(long long a, long long b) {
        int ret = 0;
        while(a) {
            for( ; !(a & 1) && !(b & 1); ++ret, a >>= 1, b >>= 1);
            for( ; !(a & 1); a >>= 1);
            for( ; !(b & 1); b >>= 1);
            if(a < b) swap(a, b);
            a -= b;
        }
        return b << ret;
    }

    inline long long mod_add(long long x, long long y, long long m){
        return (x += y) < m ? x : x - m;
    }

    inline long long mod_mul(long long x, long long y, long long m){
        long long res = x * y - (long long)((long double)x * y / m + 0.5) * m;
        return res < 0 ? res + m : res;
    }

    inline long long mod_pow(long long x, long long n, long long m){
        long long res = 1 % m;
        for (; n; n >>= 1){
            if (n & 1) res = mod_mul(res, x, m);
            x = mod_mul(x, x, m);
        }

        return res;
    }

    inline bool miller_rabin(long long n){
        if (n <= 2 || (n & 1 ^ 1)) return (n == 2);
        if (n < MAXP) return spf[n] == n;

        long long c, d, s = 0, r = n - 1;
        for (; !(r & 1); r >>= 1, s++) {}

        for (int i = 0; primes[i] < n && primes[i] < 32; i++){
            c = mod_pow(primes[i], r, n);
            for (int j = 0; j < s; j++){
                d = mod_mul(c, c, n);
                if (d == 1 && c != 1 && c != (n - 1)) return false;
                c = d;
            }

            if (c != 1) return false;
        }
        return true;
    }

    inline void init(){
        int i, j, k, cnt = 0;

        for (i = 2; i < MAXP; i++){
            if (!spf[i]) primes[cnt++] = spf[i] = i;
            for (j = 0, k; (k = i * primes[j]) < MAXP; j++){
                spf[k] = primes[j];
                if(spf[i] == spf[k]) break;
            }
        }
    }

    long long pollard_rho(long long n){
        while (1){
            long long x = rand() % n, y = x, c = rand() % n, u = 1, v, t = 0;
            long long *px = seq, *py = seq;

            while (1){
                *py++ = y = mod_add(mod_mul(y, y, n), c, n);
                *py++ = y = mod_add(mod_mul(y, y, n), c, n);
                if((x = *px++) == y) break;

                v = u;
                u = mod_mul(u, abs(y - x), n);

                if (!u) return gcd(v, n);
                if (++t == 32){
                    t = 0;
                    if ((u = gcd(u, n)) > 1 && u < n) return u;
                }
            }

            if (t && (u = gcd(u, n)) > 1 && u < n) return u;
        }
    }

    vector <long long> factorize(long long n){
        if (n == 1) return vector <long long>();
        if (miller_rabin(n)) return vector<long long> {n};

        vector <long long> v, w;
        while (n > 1 && n < MAXP){
            v.push_back(spf[n]);
            n /= spf[n];
        }

        if (n >= MAXP) {
            long long x = pollard_rho(n);
            v = factorize(x);
            w = factorize(n / x);
            v.insert(v.end(), w.begin(), w.end());
        }

        sort(v.begin(), v.end());
        return v;
    }
} 

signed main() {
    // Q.init(N - 1);//如果代码超时且仅需要分解大数的质因数可以用这句话，否则不要用
    ll T, n;
    rho :: init();
    scanf("%lld", &T);
    while (T--) { 
        scanf("%lld", &n);
        vector <ll> res = rho :: factorize(n); 
        for(auto it : res)
        	mp[it] ++ ;
    }
    ll ans = 1;
    for(auto it : mp)
    	ans = (ans * (it.second + 1)) % mod;
    printf("%lld\n", ans);
    return 0;
}

3----这个是最快的（T了可以试试，比2快了有一倍）

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxp = 1e6 + 1, maxv = 25, maxc = (int)1e4 + 1;
int ptot, pr[maxp], d[maxp], cnt;
LL n, p[maxc];
LL mod_add(LL x, LL y, LL p) {
	return (x += y) < p ? x : x - p;
}
LL mod_mul(LL x, LL y, LL p) {
	LL ret = x * y - (LL)((long double)x * y / p + 0.5) * p;
	return ret < 0 ? ret + p : ret;
}
LL mod_pow(LL x, LL k, LL p) {
	LL ret = 1 % p;
	for( ; k > 0; k >>= 1, x = mod_mul(x, x, p))
		(k & 1) && (ret = mod_mul(ret, x, p));
	return ret;
}
bool miller_rabin(LL n) {
	if(n == 2) return 1;
	if(n < 2 || !(n & 1))
		return 0;
	LL s = 0, r = n - 1;
	for( ; !(r & 1); r >>= 1, ++s);
	for(int i = 0; pr[i] < n && pr[i] < maxv; ++i) {
		LL cur = mod_pow(pr[i], r, n), nxt;
		for(int j = 0; j < s; ++j) {
			nxt = mod_mul(cur, cur, n);
			if(nxt == 1 && cur != 1 && cur != n - 1) return 0;
			cur = nxt;
		}
		if(cur != 1) return 0;
	}
	return 1;
}
LL gcd(LL a, LL b) {
	int ret = 0;
	while(a) {
		for( ; !(a & 1) && !(b & 1); ++ret, a >>= 1, b >>= 1);
		for( ; !(a & 1); a >>= 1);
		for( ; !(b & 1); b >>= 1);
		if(a < b)
			swap(a, b);
		a -= b;
	}
	return b << ret;
}
LL pollard_rho(LL n) {
	static LL seq[maxp];
	while(1) {
		LL x = rand() % n, y = x, c = rand() % n;
		LL *px = seq, *py = seq, tim = 0, prd = 1;
		while(1) {
			*py++ = y = mod_add(mod_mul(y, y, n), c, n);
			*py++ = y = mod_add(mod_mul(y, y, n), c, n);
			if((x = *px++) == y) break;
			LL tmp = prd;
			prd = mod_mul(prd, abs(y - x), n);
			if(!prd) return gcd(tmp, n);
			if((++tim) == maxv) {
				if((prd = gcd(prd, n)) > 1 && prd < n) return prd;
				tim = 0;
			}
		}
		if(tim && (prd = gcd(prd, n)) > 1 && prd < n) return prd;
	}
}
void decompose(LL n) {
	for(int i = 0; i < cnt; ++i)
		if(n % p[i] == 0) {
			p[cnt++] = p[i];
			n /= p[i];
		}
	if(n < maxp) {
		for( ; n > 1; p[cnt++] = d[n], n /= d[n]);
	} else if(miller_rabin(n)) {
		p[cnt++] = n;
	} else {
		LL fact = pollard_rho(n);
		decompose(fact), decompose(n / fact);
	}
} // prepare pr(prime) and d(minimal factor)
int main() {
	for(int i = 2; i < maxp; ++i) {
		if(!d[i])
			pr[ptot++] = d[i] = i;
		for(int j = 0, k; (k = i * pr[j]) < maxp; ++j) {
			d[k] = pr[j];
			if(d[i] == pr[j])
				break;
		}
	}
	int m, mod = 998244353;
	scanf("%d", &m);
	while(m--) {
		scanf("%lld", &n);
		decompose(n);
	}
	sort(p, p + cnt);
	int ans = 1;
	for(int i = 0; i < cnt; ) {
		int ctr = 0;
		for(LL pp = p[i]; i < cnt && p[i] == pp; ++i, ++ctr);
		ans = ans * (ctr + 1LL) % mod;
	}
	printf("%d\n", ans);
	return 0;
}

3.因数
3.1 试除法找因数

vector<int> get_divisors(int x)
{
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
}

3.2枚举倍数找因数（常用于一些于因子有关的计算，通过枚举倍数nlogn求解）

    for(int i = 1; i <= n; ++ i){
        for(int j = 1 ;j * i <= n; ++ j){
            factor[i * j].push_back(j);
        }
    }
    for(int i = 1; i <= n; ++ i){
        cout << i << ": ";
        for(int j = 0; j < factor[i].size(); ++ j)
            printf("%d ", factor[i][j]);
        puts("");
    }

3.3 一些性质

如果 N = p1^c1 * p2^c2 * … *pk^ck
约数个数： (c1 + 1) * (c2 + 1) * … * (ck + 1)
约数之和： (p1^0 + p1^1 + … + p1^c1) * … * (pk^0 + pk^1 + …+ pk^ck)

3.4 最大公约数，最小公倍数
4.欧拉函数
4.1按定义求

int phi(int x)
{
    int res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res = res / i * (i - 1);
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);

    return res;
}

4.2 筛法求欧拉函数

int primes[N], cnt;     // primes[]存储所有素数
int euler[N];           // 存储每个数的欧拉函数
bool st[N];         // st[x]存储x是否被筛掉


void get_eulers(int n)
{
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])
        {
            primes[cnt ++ ] = i;
            euler[i] = i - 1;
        }
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0)
            {
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
}

5.同余
5.1快速幂

int qmi(int m, int k, int p)
{
    int res = 1 % p, t = m;
    while (k)
    {
        if (k&1) res = res * t % p;
        t = t * t % p;
        k >>= 1;
    }
    return res;
}

5.2龟速乘

ll Mul(ll a, ll b, ll p)
{ 
	if(b < 0) a = - a, b = - b;
	ll res = 0;//因为是加法模拟乘法，所以res开始为0
	while(b) {
		if(b & 1) res = (res + a) % p;
		a = (a + a) % p;
		b >>= 1;
	}
	return res;
}

5.3 欧拉定理
5.4 费马小定理
5.5 威尔逊定理
6.拓展欧几里得
6.1 拓展欧几里得算法

// 求x, y，使得ax + by = gcd(a, b)
int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a/b) * x;
    return d;
}
  1. 逆元
    7.1费马小定理求逆元
int inv(int x,int p) {return qpow(x, mod - 2, p) % p;}

7.2拓展欧几里得求逆元

int inv(int a,int mod)
{
	int x,y;
	exgcd(a,mod,x,y);
    return (x % mod + mod) % mod;
}

7.3线性递推求逆元

inv[1] = 1;
for (int i = 2; i <= n; ++i) {
	inv[i] = (long long)(p - p / i) * inv[p % i] % p;
}

7.4求阶乘逆元
8.线性同余
9.高次同余方程
9.1 bsgs与exbsgs算法模板

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+7;
const int mod=998244353;
const ll INF=0x3f3f3f3f3f3f3f3f;
ll hs[N], head[N], nexts[N], id[N], top;
void insert(ll x, ll y, ll mod) //mod传 N
{
	ll k = x % mod;
	hs[top] = x;
	id[top] = y;
	nexts[top] = head[k];
	head[k] = top++;
}
ll find(ll x, ll mod)
{
	ll k = x % mod;
	for (int i = head[k]; i != -1; i = nexts[i])
		if (hs[i] == x)
			return id[i];
	return -1;
}
ll gcd(ll a, ll b)
{
	return b == 0 ? a : gcd(b, a % b);
}
ll BSGS(ll a, ll b, ll p, ll a1) //质数传1
{
	memset(head, -1, sizeof(head));
	top = 1;
	a %= p, b %= p;
	if (a1 == 1 && 1 % p == b % p)
		return 0;
	if (a == 0)
	{
		if (b == 0)
			return 1;
		else
			return -1;
	}
	//unordered_map<ll, ll> hash; //map  unordered_map 都试试
	ll k = sqrt(p) + 1;
	ll ak = 1;
	for (ll i = 0; i < k; ++i)
	{
		ll t = ak * b % p;
		insert(t, i, N);
		//hash[t] = i;
		ak = ak * a % p;
	}
	for (ll i = 0; i <= k; ++i)
	{
		/* if (hash.count(a1) && i * k - hash[a1] >= 0)
			return i * k - hash[a1]; */
		ll j = find(a1, N);
		if (j != -1 && i * k - j >= 0)
			return i * k - j;
		a1 = a1 * ak % p;
	}
	return -1;
}
ll exBSGS(ll a, ll b, ll p)
{
	a %= p, b %= p;
	if (b == 1 || p == 1)
		return 0;
	ll cnt = 0, a1 = 1;
	ll d = gcd(a, p);
	while (d > 1)
	{
		if (b % d)
			return -1;
		p /= d;
		b /= d;
		a1 = (a1 * a / d) % p;
		++cnt;
		if (b == a1)
			return cnt;
		d = gcd(a, p);
	}
	ll res = BSGS(a, b, p, a1);
	if (res == -1)
		return -1;
	else
		return res + cnt;
}
lzc__123
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数论模板精心整编
07-10
根据提供的文档信息，我们可以整理出一系列与数论相关的知识点，并对每个部分进行详细的解析和解释。 ### 1. 负数取模 在计算机科学中，取模运算通常用于获取除法运算的余数。当涉及到负数时，取模操作可能会有...
acm山东省赛数论模版
01-11
在ACM竞赛中，数论是一门非常重要的理论基础，特别是在...以上内容涵盖了ACM竞赛中数论模板的关键知识点，包括几何、日期计算以及数论性质。这些知识在解决实际问题时非常有用，特别是对于需要高效算法的编程竞赛而言。
Multiply（2019 ACM- ICPC Asia Xuzhou Regional Contest E）
liangsheng_meng的博客
09-03 140
#include<bits/stdc++.h> #define ll long long #define fi first #define se second using namespace std; const int N = 1e5 + 7; ll x, y, a[N]; ll max_factor; struct BigIntegerFactor { const static int N = 1e6 + 7; const static ll inf=0x3f3f3f3f3f
2019-2020 ACM-ICPC, Asia Xuzhou Regional Contest
spnooyseed的博客
07-10 257
A - Cat #include <iostream> #include <cstdio> #include <algorithm> #include <unordered_map> #include <vector> #include <map> #include <list> #include <queue> #include <cstring> #include <cstdlib>
2019 ICPC Asia Xuzhou Regional
cheng__yu_的博客
10-23 283
2019 ICPC Asia Xuzhou RegionalA. Cat （思维）C. <3<3<3 numbers （素数分布）E. Multiply （大数质因子分解）F. The Answer to the Ultimate Question of Life, The Universe, and Everything. （打表）M. Kill the tree （重心） A. Cat （思维） 题意：有 1e18 只猫在排成一列。第 i 只猫的价格为 i 。假设要买区间 [l,r][
2018-2019 ACM-ICPC, Asia Xuzhou Regional Contest
Code92007的博客
07-06 273
A.Rikka with Minimum Spanning Trees(最小生成树) t(t<=100)组样例，每次n(n<=1e5)个点m(m=1e5)条边， m条边u,v,w是由k1、k2给定的一个随机数异或生成算法生成出来的， 求最小生成树的代价*最小生成树的数量 注意到权值是生成的，重复的概率很小，大胆猜测不会出现重复的权值 所以最小生成树最多只有一棵，套kruskal板子求最小生成树的代价即可， 注意判断不存在生成树的情形 #include <iostream
基础数论
weixin_40191952的博客
03-30 464
发现涉及计数的题目经常涉及逆元之类的 先看数论好了 基础数论还是挺友好的...数学常识，质数筛，欧拉函数筛，gcd，扩展欧几里得，大概就这些内容 数学常识 质数都知道的 相当于是正数的原子 质数有无限个 1不是质数 唯一分解定理：每个大于1的正整数n可以唯一写成pi是质数，ni是整数 根据乘法定理，加上唯一分解定理可以推导：对于整数n，可以整除它的数（n%x==0）数目为：，相当于...
因数与倍数PPT模板：数学之美的探索.pptx
最新发布
10-07
掌握因数与倍数的求法至关重要，列举法、公式法和筛选法是常用技巧，有助于我们更高效地解决问题。此外，了解因数的特殊类型，如素数、合数和完全平方数，对解决数学问题大有裨益。 最后，因数与倍数的应用涵盖了...
数据结构基础与算法集锦
08-22
数据结构基础与算法是计算机科学的核心领域，它们在软件开发中扮演着至关重要的角色。本文主要探讨数论算法、图论算法以及与之相关的编程语言如C++、Java、SQL和Oracle的应用。 首先，让我们来看数论算法。数论算法...
ACM数论模板~。。。
07-20
目录 1 一． 扩展的欧几里德和不定方程的解 2 二． 中国同余定理 3 三． 原根 5 四． 积性函数 6 五． 欧拉函数性质 7 六． 线性求1-max的欧拉函数值 9 七． 求单个欧拉函数，求最小的x(phi（n）%x==0),使得2^x =1(mod n) 10
数论模板.zip
12-05
很实用的数论模板，也很全，希望能给你带来帮助。
数论模板及推理过程
qq_52765554的博客
02-06 934
算法竞赛中的数论模板以及推论
数论模板
weixin_30878361的博客
05-05 144
[toc] 闲的无聊翻了一下快爆了的E盘，发现里面有不少“好东西“”，一堆关于数论的课件，所以就整理一下常见的数论模板。虽然我不会数论，但至少整理一下可以知道以后学什么（顺便水篇博客） 欧几里德: #include<iostream> using namespace std; int hcf(int a,int b) { int r=0; ...
吃苹果（好多陷阱）
RGHLY21的博客
12-16 405
说明： 陷阱超级多！！！ 1.第一个坑：如果ttt是0，那么八尾勇肯定能吃完所有的苹果，输出0，但是0又不能做除数，这种情况要特判； 2.s是t的整数倍，那么八尾勇就吃了s/t个完整的苹果，剩下m−s/t个完整的苹果； 3.s并不是t的整数倍，八尾勇就吃了s/t个完整的苹果和一个残缺的苹果，那么就有（s / t+1）个苹果不完整了，剩下m−（s / t+ 1）个苹果；一个陷阱又又又又又来了，玩意人家在s秒内就完事了呢。 代码： #include<bits/stdc++.h&...
模板之数论大全1
冷月之殇
08-03 1692
1.扩展的欧几里德定理 //拓展欧几里得定理，求ax+by=gcd(a,b)的一组解(x,y),d=gcd(a,b) void gcd(int a,int b,int &d,int &x,int &y) { if(!b){d=a;x=1;y=0;} else{gcd(b,a%b,d,y,x);y-=x*(a/b);} } 2.求模乘法的逆 //求得a在模n条件下的逆 int
7C. Line【拓展欧几里得】 数论模板
希望的专栏
10-24 448
C. Line time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output A line on the plane is described by an equation Ax +
ACM数论中的常见的模板和结论
weixin_30519071的博客
08-11 174
1:最大公约数的求法 欧几里得算法实现。递归实现 1 #include<stdio.h> 2 #include<string.h> 3 #include<algorithm> 4 #include<iostream> 5 using namespace std; 6 __int64 gcd(__int64 y,__int...
数论模板整理！
weixin_43184669的博客
10-10 105
一： 1.欧几里得求最大公约数 int _gcd(int x,int y) { return y?_gcd(y,x%y):x; } 2.最小公倍数 #include <bits/stdc++.h> using namespace std; int gcd(int x,int y) { return y?gcd(y,x%y):x; } int main() { ...
ACM算法模板大全：涵盖数论、图论与几何
2. 重要公式与定理：涉及到数论中的经典概念，如斐波那契数列、卢卡斯数列、卡特兰数、斯特林数（第二类）、贝尔数等，以及数学上的斯特林近似、倒数和的求和、杨表等。数论公式涵盖欧拉函数、费马小定理、费马-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值