[kuangbin专题十四] 数论基础 —— [ 部分题解 1 ]

最新推荐文章于 2022-02-07 15:31:04 发布
最新推荐文章于 2022-02-07 15:31:04 发布
阅读量426 收藏
点赞数
分类专栏： 数论黑洞&思维暴力
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43237242/article/details/98749738
版权

问题虫洞——C： C - Aladdin and the Flying Carpet

 

黑洞内窥：

给你两个数n、k， 求大于k的n的约数的个数

 

思维光年：

一个基础知识：合数的正因素个数公式

（1）一个大于1的正整数N，如果它的标准分解式为：，那么它的正因数个数为。

然后减去小于k的约数，，搞定。

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 1000005
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;

bool is[MAXN];
int prime[MAXN];
ll tot;
void getprime()         //欧拉筛
{
    memset(is, false, sizeof(is));
    tot = 0;
    for(int i=2; i<=MAXN; ++i)
    {
        if(is[i] == false)
            prime[tot++] = i;
        for(int j=0; j<tot && i*prime[j] <= MAXN; ++j)
        {
            is[i*prime[j]] = true;
            if(i%prime[j] == 0)
                break;
        }
    }
}

ll solution(ll n)
{
    ll ans = 1;
    for(int i=0; i<tot && prime[i] < n; ++i)
    {
        int k = 0;
        while(n%prime[i] == 0)
        {
            n/=prime[i];
            ++k;
        }
        ans*=(1+k);
    }
    if(n > 1)
        ans*=2;
    return ans;
}

int main()
{
    getprime();
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, m, sum=0, ans;
        scanf("%lld %lld", &n, &m);
        if(m*m > n)
           ans = 0;
        else
        {
            for(int i=1; i<m; ++i)
                if(n%i == 0)
                    sum++;
            ans = solution(n)/2 - sum;
        }
        printf("Case %d: %lld\n", ccc++, ans);
    }
    return 0;
}

 

 

问题黑洞——D： D - Sigma Function

 

黑洞内窥：

设一个函数f(n) = n 的所有约数的和，如 f（6） = 1+2+3+6 = 12

给出一个数n，求1~n中f(x) 为偶数的个数。

 

思维光年：

一个基础知识：约数和公式：

对于已经分解的整数A=(p1^k1)*(p2^k2)*(p3^k3)*....*(pn^kn)

有A的所有因子之和为

S = (1+p1+p1^2+p1^3+...p1^k1) * (1+p2+p2^2+p2^3+….p2^k2) * (1+p3+ p3^3+…+ p3^k3) * .... * (1+pn+pn^2+pn^3+...pn^kn)

（2） 它的全体正因数之和为

我能想到的就只有暴力和唯一分解式的约数和公式了。。。

理性的思考：

 

 ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 5000
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;
const double eps = 0.0000001;

int main()
{
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n;
        scanf("%lld", &n);
        ll a = sqrt(n);
        ll b = sqrt(n/2);
        printf("Case %d: %lld\n", ccc++, n-a-b);
    }
    return 0;
}

 

 

问题虫洞——E： E - Leading and Trailing

 

黑洞内窥：

求n^k 的前三位数，和后三位数。

（注意，如果答案不够三位数，则在前面补0）

 

思维光年：

后三位：快速幂取模1000

前三位：log(10为底)取模，，，，设f(n) = n^k,

则x = log f(n) = k * log( n ) , 设x = a（整数部分） + b（小数部分）

则10^(a+b) = n ^ k, 我们知道10^a 为10 的整数幂次，是无法提取出有效数字的，

所以我们要的是10^b,,,,,然后再扩大到所需的三位数即可；

 

（好像在哪里做过。。。。有点熟悉）

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 5000
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000;
const double eps = 0.0000001;

int ksm(ll a, ll b)
{
    a%=mod;
    ll ans = 1;
    while(b)
    {
        if(b&1)
            ans = ans*a%mod;
        a = a*a%mod;
        b >>= 1;
    }
    return (int)ans;
}

int fir(ll n, ll k)
{
    double ans = k*log10(1.0*n);
    ans -= floor(ans);    //去小数部分b
    ans = pow(10, ans);
    while(ans < 100)
        ans*=10;
    return (int)ans;
}

int main()
{
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, k;
        scanf("%lld %lld", &n, &k);
        printf("Case %d: %.3d %.3d\n",ccc++, fir(n, k), ksm(n, k));
    }
    return 0;
}

 

 

问题虫洞——F： F - Goldbach`s Conjecture

 

黑洞内窥：

给出数n， 求有多少对质数和等于n。

 

思维光年：

打表+暴力

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 10000010
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const int mod = 1000;
const double eps = 1e-6;

bool is[MAXN];
int prime[1000000];
ll tot, n;
void getprime()         //欧拉筛
{
    memset(is, false, sizeof(is));
    tot = 0;
    for(int i=2; i<=MAXN; ++i)
    {
        if(is[i] == false)
            prime[tot++] = i;
        for(int j=0; j<tot && i*prime[j] <= MAXN; ++j)
        {
            is[i*prime[j]] = true;
            if(i%prime[j] == 0)
                break;
        }
    }
}


int main()
{
    getprime();
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, sum=0;
        scanf("%lld", &n);
        for(int i=0; i<tot && prime[i] <= n/2; ++i)
        {
            if(is[n - prime[i]] == false)
                sum++;
        }
        printf("Case %d: %d\n",ccc++, sum);
    }
    return 0;
}

 

 

问题虫洞——G： G - Harmonic Number (II)

 

黑洞内窥：

定义一个函数：f(n)  = n/1 + n/2 + n/3 +.........+ n/n-1 + n/n;

给出n， 求f(n),

 

思维光年：

直接做会t：

参考一下这篇博客：居然。。。。B - Number of Containers

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 10000010
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const int mod = 1000;
const double eps = 1e-6;


int main()
{
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, sum=0;
        scanf("%lld", &n);
        int c = sqrt(n);
        for(int i=1; i<=c; ++i)//梯形面积
            sum+=n/i;
        sum*=2;
        sum = sum-c*c;
        printf("Case %d: %lld\n",ccc++, sum);
    }
    return 0;
}

 

 

问题虫洞——H： H - Pairs Forming LCM

 

黑洞内窥：

给你一个数n， 求有多少对(i, j) 的最小公倍数（lcm(i, j) == n） 为n

 

思维光年：

一个基础知识：

对a，b求唯一分解式：

a=p1 ^ a1 * p2 ^ a2 *..........*pn ^ an

b=p1 ^ b1 * p2 ^ b2 *..........*pn ^ bn

gcd(a,b)=p1 ^ min(a1,b1) * p2 ^ min(a2,b2) *..........*pn ^ min(an,bn)

lcm(a,b)=p1 ^ max(a1,b1) * p2 ^ max(a2,b2) *..........*pn ^ max(an,bn)

get到一项求gcd、lcm的技能没u有？！

 

理性的求解：

 

 ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 10000010
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const int mod = 1000;
const double eps = 1e-6;

bool is[MAXN];
int prime[1000000];
ll tot, n;
void getprime()         //欧拉筛
{
    memset(is, false, sizeof(is));
    tot = 0;
    for(int i=2; i<=MAXN; ++i)
    {
        if(is[i] == false)
            prime[tot++] = i;
        for(int j=0; j<tot && i*prime[j] <= MAXN; ++j)
        {
            is[i*prime[j]] = true;
            if(i%prime[j] == 0)
                break;
        }
    }
}

ll fenjie(ll s)
{
    ll n = s;
    ll sum = 1;
    for (int i = 0; i < tot && prime[i]*prime[i] <= n; ++i)
    {
        if(n%prime[i] == 0)
        {
            int k=0;
            while (n % prime[i] == 0)
            {
                n /= prime[i];
                k++;
            }
           sum*=(2*k+1);
        }
    }
    if (n > 1)
        sum*=3;
    return sum;
}


int main()
{
    getprime();
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, sum=0;
        scanf("%lld", &n);
        sum = fenjie(n);
        printf("Case %d: %lld\n",ccc++, (sum+1)/2);
    }
    return 0;
}

 

 

 问题虫洞——I： I - Harmonic Number

参考博客：Harmonic Number（调和级数）

 

 

问题虫洞——J： J - Mysterious Bacteria

 

黑洞内窥：

给出一个数x， 设x可以表示为 x = b^p， 求p的最大值。（x <= 2^32， x可正可负）

 

思维光年：

我的思路：

既然x是小于2的32次方的，直接暴力开方跑呗，反正最差也就32次。。。。

但可能因为是pow的精度还是double的精度问题，导致我一直wa。。。。

后来就去搜题解了。。。

 

理性的求解：

求x，和b的唯一分解式，则有：

x=p1^x1 p2 ^x2 …. pk^xk
b=p1^b1 p2^b2…..pk^bk

题意给出关系，x = b^p，所以：

b1*p=x1
 b2*p=x2
 . ..  .  . .
 bk*p=xk

想要让式子同时成立，则有 p | gcd(x1,x2,x3...xk)   。
 所以 ，现在让求最大，如果x为正数，p=gcd(x1,x2,x3...xk)
否则 p 就是gcd(x1,x2,x3,,,xk) 的最大奇数因子。
 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 100010
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const int mod = 1000;
const double eps = 1e-6;

ll prime[MAXN], tot, ans;
bool is[MAXN];

void getprime()
{
    memset(is, false, sizeof(is));
    tot = 0;
    for(int i=2; i<=MAXN; ++i)
    {
        if(is[i] == false)
            prime[tot++] = i;
        for(int j=0; j<tot && i*prime[j] <= MAXN; ++j)
        {
            is[i*prime[j]] = true;
            if(i%prime[j] == 0)
                break;
        }
    }
}

ll gcd(ll a, ll b)
{
    return b == 0? a: gcd(b, a%b);
}

int main()
{
    getprime();
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, sum=0, flag = 0;
        scanf("%lld", &n);
        if(n < 0)
        {
            n = -n;
            flag = 1;
        }
        for(int i=0; i<tot && prime[i] <= n; ++i)
        {
            if(n%prime[i] == 0)
            {
                int ans = 0;
                while(n%prime[i] == 0)
                {
                    n/=prime[i];
                    ans++;
                }
                if(sum) sum = gcd(sum, ans);//求最大公约数
                else sum = ans;
                if(sum == 1) break;
            }
        }
        if(n>1) sum = 1;
        if(flag && sum%2 == 0)
        {
            while(sum%2 == 0)
                sum/=2;
        }
        printf("Case %d: %lld\n",ccc++, sum);
    }
    return 0;
}

 

一开始wa的代码：（给大家批斗批斗。。。[如果有人指教一下就更好啦，，啦啦啦啦啦，，，，]）

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 10000010
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const int mod = 1000;
const double eps = 1e-6;

int main()
{
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, sum=1, flag = 0;
        scanf("%lld", &n);
        if(n < 0)
        {
            flag = 1;
            n = -n;
        }

        for(ll i=2; i<=32; ++i)
        {
            if(flag && i%2 == 0) continue;

            double s = pow(n, double(1.0/i));
            int ans = ceil(pow(floor(s), i));
            if(s <= 1)
                break;
            if(ans == n)
               sum = max(sum, i);
        }

        printf("Case %d: %lld\n",ccc++, sum);
    }
    return 0;
}

 

 

问题虫洞——K： K - Large Division

 

黑洞内窥：

给你两个大数a， b， 问 a|b？，，

 

思维光年：

问题可转换成  a%b == 0？

然后就是一个大数取模。。

两分钟代码，十分钟bug，，，，

我现在是知道了string中的earse不能直接用成s.earse(0) ,   括号里面的东西是string的迭代器

所以你要改成，，，s.earse(s.begin() + i) ,删除第i个元素。。。

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 5000
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;
const double eps = 0.0000001;

string s;
int main()
{
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll b;
        cin >> s >> b;
        if(s[0] == '-') s.erase(s.begin());//这里是坑。。。
        if(b<0) b = -b;
        int len = s.size();
        ll sum = 0;
        for(int i=0; i<len; ++i)
        {
            sum*=10;
            sum+=(s[i] - '0');
            if(sum >= b) sum%=b;
        }
        printf("Case %d: ", ccc++);
        if(sum) puts("not divisible");
        else puts("divisible");
    }
    return 0;
}

 

 

问题虫洞——L： L - Fantasy of a Summation

 

黑洞内窥：

输入n，k，mod，再输入n个数ai，

求在k重循环下的（0~n-1的ai）求和取模

 

思维光年：

多列几项就可以发现规律了；

答案 = n^(k-1)*k*sum%mod；

（其中sum为ai的求和）

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
#define MAXN 5000
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;
const double eps = 0.0000001;

ll ksm(ll a, ll b, ll md)
{
    ll ans = 1;
    while(b)
    {
        if(b&1)
            ans = ans*a%md;
        a = a*a%md;
        b >>= 1;
    }
    return ans;
}

int main()
{
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll n, k, m, x, sum=0;
        cin >> n >> k >> m;
        for(int i=0; i<n; ++i)
        {
            scanf("%lld", &x);
            sum+=x;
        }
        sum = ksm(n, k-1, m)*k%m*sum%m;
        printf("Case %d: %lld\n", ccc++, sum);
    }
    return 0;
}

 

问题虫洞——M： M - Help Hanzo

 

黑洞内窥：

求区间[a, b]中的素数个数，，，，（b-a <= 100000）

 

思维光年：

区间素数筛。。。。。

wa到我想si~~~~~~

由于区间比较小，所以我们可以直接求一个区间的素数

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
const ll MAXN = 100005;
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;
const double eps = 0.0000001;

int prime[MAXN], tot, ans;
bool is[MAXN], vis[MAXN];

void getprime()
{
    memset(is, false, sizeof(is));
    tot = 0;
    is[0] = is[1] = true;
    for(int i=2; i<=MAXN; ++i)
    {
        if(is[i] == false)
            prime[tot++] = i;
        for(int j=0; j<tot && i*prime[j] <= MAXN; ++j)
        {
            is[i*prime[j]] = true;
            if(i%prime[j] == 0)
                break;
        }
    }
}

int main()
{
    getprime();
    int t, ccc=1;
    cin >> t;
    while(t--)
    {
        ll a, b, sum=0;
        cin >> a >> b;
        if(b <= MAXN)
        {
            for(ll i=a; i<=b; ++i)
                if(!is[i])
                    sum++;
        }
        else
        {
            memset(vis, 0, sizeof(vis));                //维护区间
            for(int i=0; i<tot && prime[i]*prime[i] <= b; ++i)
            {
               ll k = ceil(a*1.0/prime[i]);
                for(ll j = k*prime[i]; j<=b; j+=prime[i])
                    vis[j-a] = true;
            }
            for(ll i=a; i<=b; ++i)
                if(!vis[i-a])
                    sum++;
        }
        printf("Case %d: %lld\n", ccc++, sum);
    }
    return 0;
}

 

问题虫洞——N： N - Trailing Zeroes (III)

 

黑洞内窥：

给出数字q，求一个数n，

该数满足条件：n！尾数有q个0；

 

思维光年：

思维+二分。。

尾数如果要出现0， 就必须是2*5， 而在n！中2的因子个数必然多于5

所以，题目等同于，求有q个因子是5的数n！。

我一开始是做对了的啊，，，wawawawawawa，，，

明明就是PE，你一wa我还以为思路有问题。。。

枯了~~~~~~~~；

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
const ll MAXN = 500000000;
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;
const double eps = 0.0000001;

ll SUM(ll n)
{
    return n == 0? 0: n/5+SUM(n/5);
}
int main()
{
    int t, ccc=1;
    //cout << SUM(500000000) << '\n';
    cin >> t;
    while(t--)
    {
        ll n, sum = -1;
        scanf("%lld", &n);
        ll l=0,r = MAXN;
        while(l <= r)    //这里不能特判相等，虽然结果是对的，但不能AC
        {
            ll m = (l+r)/2;
           if(SUM(m) >= n)
                r = m-1;
            else
                l = m+1;
        }
        if(SUM(l) == n)
            printf("Case %d: %lld\n", ccc++, l);
        else
            printf("Case %d: impossible\n", ccc++);
    }
    return 0;
}

 

 

 问题虫洞——O： O - GCD - Extreme (II)

 

黑洞内窥：

给出数n，求

 

思维光年：

理所当然的想到了欧拉函数，，，，

 

理性的求解：

 欧拉函数：满足 0<x<n 且 gcd(x,n) = 1 的x有phi[n]个。

可以推论出：满足 0<2*x<2*n 且 gcd(2*x,2*n) = 2 的2*x同样有phi[n]个，

推向一般：满足 0<k*x<k*n 且 gcd(k*x,k*n) = k 的k*x有euler[n]个。

其实就是对于n来说，在1~n-1内与它互质的数都乘上相应的倍数，同时n也乘上相应的倍数，因而他们的最大公约数也为乘上的倍数，但不管如何，个数没有改变，仍为euler[n]个，只不过是他们的值“放大”了而已。

最后，就可以枚举每个欧拉函数phi[n]和系数k，然后进行统计。

 

ACcode：

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
#include  <sstream>
using namespace std;
typedef long long ll;
const ll MAXN = 4000009;
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll
const ll mod = 1000000007;
const double eps = 0.0000001;

int phi[MAXN];                        //欧拉函数
void getphi()
{
    phi[1] = 1;
    for(int i=2; i<MAXN; ++i)
    {
        if(!phi[i])
        {
            for(int j=i; j<MAXN; j+=i)
            {
                if(!phi[j]) phi[j] = j;
                phi[j] = phi[j]/i*(i-1);
            }
        }
    }
}

ll a[MAXN];
void init()
{
    for(int i=2; i<MAXN; ++i)           //枚举单位欧拉数
        for(int k=1; k*i < MAXN; ++k)   //枚举倍数
            a[i*k]+=k*phi[i];           //累加倍数gcd
    for(int i=2; i<MAXN; ++i)    
        a[i]+=a[i-1];
}
int main()
{
   getphi();
   init();
   int n;
   while(cin >> n && n)
    cout << a[n] << '\n';
    return 0;
}

 

 

 

 

 

 

浦柳人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《初等数论》习题集及答案
07-04
自学考的同志啊！看了不后悔啊！这可是我辛辛苦苦找到的哦！分享分享啊
基础数论（入门）
wayne_got的博客
02-03 1841
基础数论（入门，貌似还没） 嫖了学长的pdf 常用运算符 基本常识（就很…） 基本定理（最好有些简单题来把基本定理练熟） 常用算法 埃氏筛 从整数中筛去合数，留下素数 考虑给定一个素数x那么很明显所有x的倍数都不是素数，我们只需要枚举一个系数i,将所有的xi标记为合数即可 复杂度参考前面的常识~O(n log log n) for(int i=2;i<maxn;++i) { for(int j=i;j<maxn;j+=i) { notPrime[j]=1; } } 一点点
函数
bingXxx的博客
10-22 312
几个库函数 strcpy 使用库函数时,注意一定要包含include头文件 //通过函数的方法找出两个数中较大的一个 //创建一个名为GetMax的数,找出其中较大的数 #include&lt;stdio.h&gt; #include&lt;windows.h&gt; int GetMax(int x, int y) { //进行判断,将较大的数返回 //需要注意这种写法,当return 后面的...
求公因式-辗转相除法
wanglongjiayou的博客
11-11 216
#include <iostream> using namespace std; int division(int a, int b) { int temp; if (a > b) { while (b != 0) { temp= a; a = b; b = temp % b; } cout << a; } else { while (a != 0) { temp = b; b = a; a= b % a;
A Maximum sum&&北邮月赛题
lianxiangbus
03-06 121
Time Limit:1000MS Memory Limit:65536KB Description Given a set of n integers: A={a1, a2,..., an}, we define a function d(A) as below: d(A)=sum{a[s1]~a[t1]}+sum{a[s2]~a[t2]} The rule is 1&...
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有...本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎关注~~~~~~kuangbin的ACM模板（2018.7更新）
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
最新发布
09-19
1. **基础数据结构**：线性结构（如数组、链表）、树结构（如二叉树、平衡树）、图结构（如邻接矩阵、邻接表）等。这些数据结构在ACM比赛中常常被用来处理问题，例如搜索、排序、最短路径等。 2. **排序与查找算法*...
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
《kuangbin的ACM模板（新）》是面向ACM（国际大学生程序设计竞赛）参赛者的一份宝贵的参考资料，由kuangbin分享并命名为"kuangbinacm"。这份模板聚焦于算法和数据结构的实践应用，尤其是动态规划和计算几何两大核心...
翻译题12动态规划
Abby_yyyyyyy的博客
02-07 199
1481:Maximum sum ​​​​​​​【最大的和】 总时间限制: 1000ms 内存限制: 65536kB 描述 Given a set of n integers: A={a1, a2,..., an}, we define a function d(A) as below: 【给出n个数：A={a1，....an}，我们定义一个函数d（A）】 t1 t2 d(A) = max{ ∑ai + ∑aj |..
折磨我一上午的题
weixin_45901806的博客
03-26 250
Given a set of n integers: A={a1, a2,..., an}, we define a function d(A) as below: Your task is to calculate d(A). Input The input consists of T(<=30) test cases. The number of test cases (T) ...
OpenJudge 2.5-1481 Maximum sum(最大和)
岂曰无衣，与子同袍
07-11 393
Description Given a set of n integers: A={a1, a2,..., an}, we define a function d(A) as below: t1 t2 d(A) = max{ ∑ai + ∑aj | 1 <= s1 <= t1 < s2 <= t2
POJ Maximum sum
Alex
08-05 469
DescriptionGiven a set of n integers: A={a1, a2,..., an}, we define a function d(A) as below:Your task is to calculate d(A).InputThe input consists of T(Each test case contains two lines. The first li
Division（暴力枚举入门题）
bunny_1024的博客
11-08 178
题目链接： Online Judgehttps://onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=666 暴力枚举的入门题，难度主要在细节处理上（比如前导0在记录时的处理，还有输出时的处理），就当是输入输出练习了。代码如下： #include <iostream> #include <cstring> #include <..
python的division函数_Python/Numpy:Division给了我一个意外的弃用警告
weixin_42367233的博客
01-14 493
我从一个csv读取数据，然后循环，然后我想除以平均值来规范化它，但得到一个警告。代码是：A = genfromtxt("train.txt", delimiter=';', skip_header=1)lowid = A[:,1].min(axis=0)highid = A[:,1].max(axis=0)X = []Y = []for i in np.arange(lowid, highid):...
C语言初阶：函数，函数指针解决实际问题
凯凯在此
03-25 380
文章目录1. 函数指针 1. 函数指针 函数名就是一个地址，所以函数名就能放在指针中 定义指针的方法： void (*p)() = Func; 调用函数指针的方法： (*p)(); 或者 p(); 和数组的道理一样 有参数和有返回值的调用函数指针： int (*padd)(int a,int b) = add; printf("%d\n",padd(100,200)); 或者 printf("%d\n",（*padd)(100,200)); 体会函数指针的用法： #include <stdio.h&
数论基础及例题
weixin_50522312的博客
03-18 1112
文章目录常识一、整除二、素数三、最大公约数（gcd）四、最小公倍数（lcm）五、同余六、快速幂七、扩展欧几里得八、逆元九、模运算例题一、J - Sum二、C - A/B 常识 一、整除 定义 若整数a除以非零整数b，商为整数，且余数为零， 我们就说a能被b整除（或说b能整除a）b|a，否则b∤a。 基本性质 1.若b|a，c|a，且b和c互质，则bc|a 2.若a|b，且b|c，则a|c 3.若b|a，且b|c，则b|(a±c) 4.若c|a，且c|b，则对于任意整数m、n，有c|(ma+nb) .
POJ-2479-Maximum Sum (动态规划）
wjl_zyl_1314的博客
11-11 361
原题： Given a set of n integers: A={a1, a2,…, an}, we define a function d(A) as below: —————t1——t2 d(A) = max{ ∑ai + ∑aj | 1 &lt;= s1 &lt;= t1 &lt; s2 &lt;= t2 &lt;= n } ————— i=s1 —j=s2 Your...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值