[kuangbin带你飞]专题十四 数论基础

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


111 / 423 Problem A LightOJ 1370 Bi-shoe and Phi-shoe

d.给出n个数a1,a2,...,an,对每个数ai分别找到一个相应的数pi,使其欧拉函数值Φ(pi)>=ai,求p1+p2+...+pn的最小值。

s.不知道为什么pi要选大于ai的第一个素数。

#include
#include
#include<string.h>
#include
using namespace std;

const int MAXN=1000100;

bool isPrime[MAXN];

void sieve(int n){
    memset(isPrime,true,sizeof(isPrime));
    isPrime[0]=isPrime[1]=false;
    int i,j,k;
    k=sqrt(n);
    for(i=2;i<=k;++i){
        if(isPrime[i]==true){
            for(j=i+i;j<=n;j=j+i){
                isPrime[j]=false;
            }
        }
    }
}

int main(){

    sieve(MAXN-1);

    int T;
    int n;
    int t;
    int i;
    int j;
    long long sum;
    int ca=0;

    scanf("%d",&T);

    while(T--){
        scanf("%d",&n);
        sum=0;
        for(i=0;ii){
            scanf("%d",&t);
            for(j=t+1;jj){
                if(isPrime[j]==true){
                    break;
                }
            }
            sum+=j;
        }
        printf("Case %d: %lld Xukha\n",++ca,sum);
    }

    return 0;
}
View Code

 

21 / 74 Problem B LightOJ 1356 Prime Independence

题意:
找出一些数字的最大质独立集,就是集合能的所有数互相之间不会出现 a[i]==t*a[j] (t是质数) 的情况。
思路:
首先想最大独立集对于一般图是NP问题,通常只有求二分图最大独立集,然后就是如何把这些数字分为二分图。
能够想到如果一个数字等于另一个数字乘以一个质数,那么这两个数字的质因子分解应该只有这一个质数的差别。也就是只会多一个质数,数字上限只有500000,完全可以看一个数组储存某个数字是否存在,然后对每个数字分解质因子,找到他对于每个质因子能够找到的那个数,存在则加边,然后就把质因子总个数(可重复的)是奇数与偶数的分成两边并且把只有一个质因子差别的连通,然后二分图匹配求最大独立集即可。

即二分图左边为质因子总数为奇数的,右边为质因子总数偶数的。
关于二分图匹配因为数量较大所以用匈牙利会tle,要用Hopcroft-Carp:

c.根据这个思路写了下,用的匈牙利O(VE),没超时。不过Hopcroft-Carp这个会快1s左右。

/*
//顶点编号从1开始的
用STL中的vector建立邻接表实现匈牙利算法
效率比较高
处理点比较多的效率很高。1500的点都没有问题
*/
#include
#include
#include
#include<string.h>
#include
#include
using namespace std;

const int MAXN=40000+10;//这个值要超过两边个数的较大者,因为有linker
int linker[MAXN];
bool used[MAXN];
vector<int>G[MAXN];
int uN;
bool dfs(int u)
{
    int sz=G[u].size();
    for(int i=0; i)
    {
        if(!used[G[u][i]])
        {
            used[G[u][i]]=true;
            if(linker[G[u][i]]==-1||dfs(linker[G[u][i]]))
            {
                linker[G[u][i]]=u;
                return true;
            }
        }
    }
    return false;
}

int hungary()
{
    int u;
    int res=0;
    memset(linker,-1,sizeof(linker));
    for(u=0; u)
    {
        memset(used,false,sizeof(used));
        if(dfs(u)) res++;
    }
    return res;
}

const int MAXN2=500000+10;

bool exist[MAXN2];//标记数是否存在
int a[MAXN];//原来的数
int myHash[MAXN2];//离散化

int factors[MAXN2][2];//[0]存质因子,[1]存个数
int factCnt;//不同的质因子总个数
int factCnt2;//包含相同的质因子的总个数

void getFactors(int n){
    int i,k;
    factCnt=0;
    factCnt2=0;
    for(i=2,k=sqrt(n);i<=k;++i){
        if(n%i==0){
            factors[factCnt][0]=i;
            factors[factCnt][1]=1;
            ++factCnt2;
            n=n/i;
            while(n%i==0){
                ++factors[factCnt][1];
                ++factCnt2;
                n=n/i;
            }
            ++factCnt;
            k=sqrt(n);//循环条件不直接写i<=sqrt(n);是因为这样可以避免重复开跟方
        }
    }
    if(n>1){
        factors[factCnt][0]=n;
        factors[factCnt][1]=1;
        ++factCnt;
        ++factCnt2;
    }
}

int main(){
    int T;
    int N;
    int i;
    int j;
    int tmp;
    int ans;
    int ca=0;

    scanf("%d",&T);

    while(T--){
        scanf("%d",&N);
        uN=N;//左边集合个数
        for(i=0;i//记得要清空
            G[i].clear();
        }

        memset(exist,false,sizeof(exist));
        for(i=0;ii){
            scanf("%d",&a[i]);
            exist[a[i]]=true;
            myHash[a[i]]=i;//离散化,二分图N个点就可以了
        }

        for(i=0;ii){
            getFactors(a[i]);//获取质因子
            for(j=0;j//枚举质因子
                tmp=a[i]/factors[j][0];
                if(exist[tmp]==true){
         //tmp存在
                    if(factCnt2&1){
         //第i个数质因数个数为奇数,第i个数作为左边的点插入一条由左指向右的有向边
                        G[i].push_back(myHash[tmp]);
                    }
                    else{
                        G[myHash[tmp]].push_back(i);
                    }
                }
            }
        }
        ans=hungary();
        printf("Case %d: %d\n",++ca,N-ans);
    }

    return 0;
}
View Code

c2.Hopcroft-Carp,这个比较快,O(squt(n)*E)

/*
//顶点编号从0开始的
二分图匹配(Hopcroft-Karp算法)
复杂度O(squt(n)*E)
邻接表存图,vector实现
vector先初始化,然后加入边
uN为左端的顶点数,使用前赋值(点编号0开始)
*/
#include
#include
#include
#include
#include<string.h>
#include
using namespace std;

const int MAXN=40000+10;
const int INF=0x3f3f3f3f;
vector<int>G[MAXN];
int uN;
int Mx[MAXN],My[MAXN];
int dx[MAXN],dy[MAXN];
int dis;
bool used[MAXN];
bool SearchP(){
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i)
        if(Mx[i]==-1){
            Q.push(i);
            dx[i]=0;
        }
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)break;
        int sz=G[u].size();
        for(int i=0;i){
            int v=G[u][i];
            if(dy[v]==-1){
                dy[v]=dx[u]+1;
                if(My[v]==-1)dis=dy[v];
                else{
                    dx[My[v]]=dy[v]+1;
                    Q.push(My[v]);
                }
            }
        }
    }
    return dis!=INF;
}
bool DFS(int u){
    int sz=G[u].size();
    for(int i=0;i){
        int v=G[u][i];
        if(!used[v]&&dy[v]==dx[u]+1){
            used[v]=true;
            if(My[v]!=-1&&dy[v]==dis)continue;
            if(My[v]==-1||DFS(My[v])){
                My[v]=u;
                Mx[u]=v;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch(){
    int res=0;
    memset(Mx,-1,sizeof(Mx));
    memset(My,-1,sizeof(My));
    while(SearchP()){
        memset(used,false,sizeof(used));
        for(int i=0;i)
            if(Mx[i]==-1&&DFS(i))
                res++;
    }
    return res;
}

const int MAXN2=500000+10;

bool exist[MAXN2];//标记数是否存在
int a[MAXN];//原来的数
int myHash[MAXN2];//离散化

int factors[MAXN2][2];//[0]存质因子,[1]存个数
int factCnt;//不同的质因子总个数
int factCnt2;//包含相同的质因子的总个数

void getFactors(int n){
    int i,k;
    factCnt=0;
    factCnt2=0;
    for(i=2,k=sqrt(n);i<=k;++i){
        if(n%i==0){
            factors[factCnt][0]=i;
            factors[factCnt][1]=1;
            ++factCnt2;
            n=n/i;
            while(n%i==0){
                ++factors[factCnt][1];
                ++factCnt2;
                n=n/i;
            }
            ++factCnt;
            k=sqrt(n);//循环条件不直接写i<=sqrt(n);是因为这样可以避免重复开跟方
        }
    }
    if(n>1){
        factors[factCnt][0]=n;
        factors[factCnt][1]=1;
        ++factCnt;
        ++factCnt2;
    }
}

int main(){
    int T;
    int N;
    int i;
    int j;
    int tmp;
    int ans;
    int ca=0;

    scanf("%d",&T);

    while(T--){
        scanf("%d",&N);
        uN=N;//左边集合个数
        for(i=0;i//记得要清空
            G[i].clear();
        }

        memset(exist,false,sizeof(exist));
        for(i=0;ii){
            scanf("%d",&a[i]);
            exist[a[i]]=true;
            myHash[a[i]]=i;//离散化,二分图N个点就可以了
        }

        for(i=0;ii){
            getFactors(a[i]);//获取质因子
            for(j=0;j//枚举质因子
                tmp=a[i]/factors[j][0];
                if(exist[tmp]==true){
         //tmp存在
                    if(factCnt2&1){
         //第i个数质因数个数为奇数,第i个数作为左边的点插入一条由左指向右的有向边
                        G[i].push_back(myHash[tmp]);
                    }
                    else{
                        G[myHash[tmp]].push_back(i);
                    }
                }
            }
        }
        ans=MaxMatch();
        printf("Case %d: %d\n",++ca,N-ans);
    }

    return 0;
}
View Code

 

61 / 332 Problem C LightOJ 1341 Aladdin and the Flying Carpet

题意:给个矩形的面积a,和矩形的最小边长b,问有多少种矩形的方案(不能是正方形)

分析:a可以写成x,y,因为不能是正方形,所以设xsqrt(a)

        所以找到所有小于sqrt(a)的因子,看有几个大于等于b的就是方案数

        因子可以由数的唯一分解定理,求得

具体 : 先筛一遍1e6以内的素数,有线性筛,然后分解a,然后dfs找所有的小于sqrt(a)的因子,

          由于前12个素数的乘积大于1e12了,所以这部分复杂度,大概是O(2^12)(一般还要略大,不过大不了多少,数组要开大)左右

         可以用这个估计(因为是求小于sqrt(a)的,可以除以2,当然这是空间常数)

          所以这部分复杂度是O(T*2^12)满的话(4000*4000)大概也就是几百万,这部分可以忽略不计

          主要的复杂度在分解素数里,因为1e6里面大概有7w多素数,这部分复杂度(最坏的情况a是大素数),大概是4000*70000,可以卡过,由于不可能都是这种数据

          所以还是可以过的

吐槽:然后我看了看网上的代码,都是先求出总的,然后暴力扫b减,结果居然过了,b是sqrt(a)的级别,是百万,4000*1e6,是4e9,TLE

        出题人太良心,没有卡这种的QAQ,感觉略坑啊

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long LL;
const int N=1e6+5;
const int INF=0x3f3f3f3f;
int cnt;
bool v[N];
LL prime[80000];
void getprime(){
  for(int i=2;i*i<=N-5;++i)
    if(!v[i])
      for(int j=i*i;j<=N-5;j+=i)
        v[j]=1;
  for(int i=2;i<=N-5;++i)
  if(!v[i])prime[++cnt]=i;  
}
vectorfac[2];
int divisors[5000],tot;
LL k;
void dfs(int pos,LL res){
   if(pos==fac[0].size()){
      divisors[++tot]=res;
      return;
   }
   for(LL i=0,now=1;i<=fac[1][pos];now*=fac[0][pos],++i){
     if(now*res>=k)break;
     dfs(pos+1,res*now);
   }
}
int main()
{
    getprime();
    int cas=0,T;
    scanf("%d",&T);
    while(T--){
       printf("Case %d: ",++cas);
       LL a,b;
       scanf("%lld%lld",&a,&b);
       k=sqrt(a);
       if(k*k!=a)++k;
       if(b>=k){
        printf("0\n");
        continue;
       }
       LL t=a;
       fac[0].clear(),fac[1].clear();
       for(int i=1;i<=cnt&&prime[i]*prime[i]<=t;++i){
         if(t%prime[i])continue;
         int tmp=0;
         fac[0].push_back(prime[i]);
         while(t%prime[i]==0)++tmp,t/=prime[i];
         fac[1].push_back(tmp);
       }
       if(t>1){
        fac[0].push_back(t);
        fac[1].push_back(1);
       }
       tot=0;
       dfs(0,1);
       int ans=0;
       for(int i=1;i<=tot;++i)
          if(divisors[i]>=b)++ans;
      printf("%d\n",ans);
    }
    return 0;
}
View Code

法2:根据唯一分解定理,先将a唯一分解,则a的所有正约数的个数为num = (1 + a1) * (1 + a2) *...(1 + ai),这里的ai是素因子的指数,见唯一分解定理,因为题目说了不会存在c==d的情况,因此num要除2,去掉重复情况,然后枚举小于b的a的约数,拿num减掉就可以了

ps:这个除2很刁。如果存在c==d的情况,会给舍掉。正好符合题意不能是正方形。

#include 
#include 
#include 
#include 
#define ll long long
using namespace std;
int const MAX = 1e6 + 10;
int p[MAX];
bool u[MAX];
int num, cnt;
ll a, b, tmp;

void get_prime()  
{  
    memset(u, false, sizeof(u));
    for(int i = 2; i <= sqrt(MAX); i++)
        if(!u[i])
            for(int j = i * i; j <= MAX; j += i)
                u[j] = true;
    for(int i = 2; i <= MAX; i++)
        if(!u[i])
            p[cnt ++] = i;
}

void cal()
{
    for(int i = 0; i < cnt && p[i] <= sqrt(tmp); i++)
    {
        int cc = 0;
        while(tmp % p[i] == 0)
        {
            cc ++;
            tmp /= p[i];
        }
        num *= (cc + 1);

    }
    if(tmp > 1) //如果tmp不能被整分,说明还有一个素数是它的约数,此时cc=1
        num *= 2;
}

int main()
{
    int T;
    scanf("%d", &T);
    cnt = 0;
    get_prime();
    for(int ca = 1; ca <= T; ca++)
    {
        scanf("%lld %lld", &a, &b);
        if(a < b * b)
            printf("Case %d: 0\n", ca);
        else
        {
            num = 1;
            tmp = a;
            cal();
            num /= 2;
            for(int i = 1; i < b; i++)
                if(a % i == 0)
                    num --;
            printf("Case %d: %d\n", ca, num);
        }
    }
}
View Code

 

54 / 82 Problem D LightOJ 1336 Sigma Function

题意:定义f(n)为n的约数之和。比如f(6)=1+2+3+6=12。给出n,求[1,n]中f值为偶数的数的个数。

c.这个代码,,很尴尬,看代码吧。

#include
#include
#include
using namespace std;

int main(){

    int T;
    long long n;
    int a,b;
    int ca=0;

    scanf("%d",&T);

    while(T--){
        scanf("%lld",&n);
        a=sqrt(n);
        b=sqrt(n/2);
        printf("Case %d: %lld\n",++ca,n-a-b);
    }

    return 0;
}
View Code

正规点的做法:看了这个好像明白上面那个了。。。from:http://www.hardbird.net/lightoj-1336-sigma-function/

大意:定义函数σ(x)为x的所有因子的和。问题是,给一个n,问有多少个σ(x)为偶数,x<=n。

思路:可以计算有多少个σ(x)为奇数,用n减去就好了。题目中给出了提示σ(n)可以写成

其中单独的一项,是等比数列求和的公式。如果要求σ(n)为奇数,那公式中的每一项乘数都得是奇数。

对于其中的第i项乘数f(i)=pi^0+pi^1+…+pi^ei.
当pi=2时,f(i)一定是奇数。
当pi!=2时,由于pi是奇数,只有当ei为偶数时,才能保证f(i)为奇数。

所以,当所有的σ(x)为奇数时,x只有两种情况:
1、所有的ei都为偶数,x就一定是平方数。
2、除了素因子2的指数为奇数外,所有的ei都为偶数,x就一定是平方数的2倍。

#include 
using namespace std;
typedef long long LL;
 
int main()
{
    int T, kase=0;
    LL n;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%lld", &n);
        LL ans=0;
        for(LL i=1; i*i<=n; i++)
        {
            ans++;
            if(2*i*i<=n)
                ans++;
        }
        printf("Case %d: %lld\n", ++kase, n-ans);
    }
    return 0;
}
View Code

解3:

题意:求[1,n]中约数和为偶数的数的个数

思路:根据算术基本定理的约数和公式f(n)=(1+p1+p1^2+...+p1^k1)(1+p2+p2^2+...+p2^k2)...(1+pn+pn^3+...+pn^kn);

其中n=(p1^k1)*(p2^k2)*...*(pn^kn);(分解素因数)

由于奇数*奇数还是奇数,奇数*偶数或者偶数相乘是偶数。而素数除了2都是奇数。

f(n)的奇偶性取决于每个因子的奇偶性,只要出现一个因子是偶数时f(n)为偶数。

对每个因子,1+p+p^2+...+p^k的奇偶性,

    p为素数,当p是2时,式子为奇数;

                当p不是2时,p是奇数,p^i为奇数,式子总共k+1项,即k+1个奇数的和,k为偶数时式子为奇数。

以此条件反推dfs出所有的f(n)为奇数的n,方法是每次乘以奇素数素数的两倍或者2,得到的n就是f(n)为奇数的n了。

#include
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include<string>
#include
#include

using namespace std;

typedef long long ll;
const int maxn=1000100;
const int INF=(1<<29);
const double EPS=0.0000000001;
const double Pi=acos(-1.0);

ll n;
vector odd;
bool isprime[maxn];
vector<int> prime;
const ll M=1000000000010;

void play_prime()
{
    memset(isprime,1,sizeof(isprime));
    isprime[1]=0;
    for(int i=2;i){
        if(!isprime[i]) continue;
        for(int j=i*2;ji){
            isprime[j]=0;
        }
    }
    for(int i=1;i){
        if(isprime[i]) prime.push_back(i);
    }
}

void dfs(int dep,ll cur)
{
    odd.push_back(cur);

    for(int i=dep;i){
        ll t=prime[i];
        if(t==2){
            if(cur<=M/2) dfs(i,cur*2);
            else return;
        }
        else{
            if(cur<=M/(t*t)) dfs(i,cur*t*t);
            else return;
        }
    }
}

int main()
{
    int T;cin>>T;
    play_prime();
    dfs(0,1);
    sort(odd.begin(),odd.end());
    int tag=1;
    while(T--){
        cin>>n;
        ll ans=upper_bound(odd.begin(),odd.end(),n)-odd.begin();
        printf("Case %d: %lld\n",tag++,n-ans);
    }
    return 0;
}
View Code

 

66 / 181 Problem E LightOJ 1282 Leading and Trailing

后三位直接用快数幂取余可以求出

前三位我们可以将n^k转化成a.bc * 10^m,这样abc就是前三位了,n^k =  a.bc * 10^m

即lg(n^k) = lg(a.bc * 10^m)

<==>k * lg(n) = lg(a.bc) + lg(10^m) = lg(a.bc) + m

m为k * lg(n)的整数部分,lg(a.bc)为k * lg(n)的小数部分

x = lg(a.bc) = k * lg(n) - m = k * lg(n) - (int)(k * lg(n))

a.bc = pow(10, x);

abc = a.bc * 100;

这样前三位数abc便可以求出

#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
long long POW(long long a,long long b,long long c){
    if(b==0)return 1;
    long long t=POW(a,b>>1,c);
    t=t*t%c;
    if(b&1)t=t*a%c;
    return t;
}
int main()
{
    long long n,k,i,j,t,test=1;
    scanf("%lld",&t);
    while(t--){
        scanf("%lld%lld",&n,&k);
        double m=k*log10(n)-(long long)(k*log10(n));
        m=pow(10.0,m);
        printf("Case %lld: %lld %03lld\n",test++,(long long)(m*100),POW(n,k,1000));
    }
    return 0;
} 
View Code

 

65 / 216 Problem F LightOJ 1259 Goldbach`s Conjecture

题意:给你一个偶数n,让你求它有多少种可能是两个素数相加得到的

思路:将10000000以内的素数打表,在开一个标志函数,要注意内存,用bool类型

/*
筛法求素数
*/
#include
#include
#include
#include<string.h>
using namespace std;

const int MAXN=1e7+10;

bool a[MAXN];
int prime[MAXN/10];
int primeCnt;//素数个数
void sieve(int n){
         //
    memset(a,true,sizeof(a));
    int i,j,k;
    k=sqrt(n);
    a[1]=false;
    for(i=2;i<=k;++i)
        if(a[i]==true){
            for(j=i+i;j<=n;j=j+i)
                a[j]=false;
        }
    primeCnt=0;
    for(i=2;i<=n;++i){
        if(a[i]==true){
            prime[primeCnt++]=i;
        }
    }
}

int main(){

    sieve(MAXN);

    int T;
    int n;
    int i;
    int k;
    int sum;
    int ca=0;

    scanf("%d",&T);

    while(T--){
        scanf("%d",&n);
        k=n/2;
        sum=0;
        for(i=0;prime[i]<=k;++i){
            if(a[prime[i]]==true&&a[n-prime[i]]==true){
                ++sum;
            }
        }
        printf("Case %d: %d\n",++ca,sum);
    }

    return 0;
}
View Code

 

65 / 110 Problem G LightOJ 1245 Harmonic Number (II)

先求出前sqrt(n)项和:即n/1+n/2+...+n/sqrt(n)

再求出后面所以项之和.后面每一项的值小于sqrt(n),计算值为1到sqrt(n)的项的个数,乘以其项值即可快速得到答案

例如:10/1+10/2+10/3+...+10/10

sqrt(10) = 3

先求出其前三项的和为10/1+10/2+10/3

在求出值为1的项的个数为(10/1-10/2)个,分别是(10/10,10/9,10/8,10/7,10/6),值为2个项的个数(10/2-10/3)分别是(10/5,10/4),在求出值为3即sqrt(10)的项的个数.

显然,值为sqrt(10)的项计算了2次,减去一次即可得到答案。当n/(int)sqrt(n) == (int)sqrt(n)时,值为sqrt(n)的值会被计算2次。

#include 
#include 
#include 
using namespace std;

int main()
{
    int T,n;
    scanf("%d",&T);
    long long sum;
    for(int i = 1; i<=T; i++)
    {
        scanf("%d",&n);
        sum = 0;
        for(int j = 1; j<=sqrt(n); j++)
        {
            sum += n/j;
        }
        for(int j = 1; j<=sqrt(n); j++)
        {
            sum += (n/j - n/(j+1))*j;
        }
        if(n/(int)sqrt(n)==(int)sqrt(n))
            sum -= n/(int)sqrt(n);
        printf("Case %d: %lld\n",i,sum);
    }
    return 0;
}
View Code

 

48 / 172 Problem H LightOJ 1236 Pairs Forming LCM

思路:把n分解成素因数的形式n=p1^c1+p2^c2+...pm^cm

假设已找到一对(a,b)的lcm=n

有a=p1^d1+p2^d2+...pm^dm

b=p1^e1+p2^e2+...pm^em

易知max(di,ei)=ci

先考虑有序数对(a,b),由唯一分解定理知,a的每一个素因数的幂的大小都决定一个独一无二的数。

所以(a,b)的种数就是(di,ei)的种数,即2*(ci+1)-1(因为有序对(c1,c1)重复了一次所以-1)

所以有序对(a,b)的种数ans=(2*c1+1)*(2*c2+1)*(2*c3+1)*...*(2*cm+1)

但是要求求无序对的种数,已知(a,b)(b,a)重复,除了(n,n)只算了一个之外,所以ans = ans/2 +1

#include
#include
#include
#include
#include
using namespace std;

typedef long long ll;
const int N = 1e7+100;
ll prime[N/10];
bool vis[N];
int tot;
void ini()
{
    for(ll i=2;i)
        if(!vis[i])
        {
            prime[tot++]=i;
            for(ll j=i*i;j1;
        }
}
int main()
{
    ini();
    int T;
    scanf("%d",&T);
    for(int cas=1;cas<=T;cas++)
    {
        ll n;
        cin>>n;
        ll t=n;
        ll ans=1;
        for(int i=0;i)
        {
            ll cnt=0;
            while(t%prime[i]==0) cnt++,t/=prime[i];
            ans*=(2*cnt+1);
        }
        if(t>1) ans*=3;
        ans = ans/2 +1;
        cout<<"Case "<": "<endl;
    }
    return 0;
}
View Code

 

43 / 73 Problem I LightOJ 1234 Harmonic Number

求1 + 1/2 + 1/3 + 1/4 + 1/ 5 +...+ 1/ n(1 ≤ n ≤ 108)

这题是单调级数部分求和,网上有公式,不过不知道公式也是没关系的,毕竟这个知识点也偏门了点。。。

我用的方法是打表记录1/i (1<=i<=n),根据题意,n最大为一亿,将一亿个结果记录下来肯定是不可行的,但是可以记录百万级个结果。下面的代码中,我开了一个250万的数组,0到一亿范围内,每40个数记录一个结果,即是分别记录1/40,1/80,1/120,...,1/一亿,这样对于输入的每个n,最多只需执行39次求倒数运算,大大节省了时间。

注意的是,a[0] = 0,只是为了使得当n==1时不用单独判断。

ps:当n很大时,有个近似公式:1+1/2+1/3+1/4+1/5+...+1/n=γ+ln(n) 
γ是欧拉常数,γ=0.57721566490153286060651209...
ln(n)是n的自然对数(即以e为底的对数,e=2.71828...)

我用这个公式写了下,好像精度不太够。

#include 
#include 
#include 
#include 
#include 

using namespace std;

const int maxn = 2500001;
double a[maxn] = {
         0.0, 1.0};

int main()
{
    int t, n, ca = 1;
    double s = 1.0;
    for(int i = 2; i < 100000001; i++)
    {
        s += (1.0 / i);
        if(i % 40 == 0) a[i/40] = s;
    }
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        int x = n / 40;
       // int y = n % 40;
        s = a[x];
        for(int i = 40 * x + 1; i <= n; i++) s += (1.0 / i);
        printf("Case %d: %.10lf\n", ca++, s);
    }
    return 0;
}
View Code

 

38 / 160 Problem J LightOJ 1220 Mysterious Bacteria

题目大意:给你一个整数n(可能为负数),让你求满足a^p=n的最大的p
思路:当n是正数时,直接对n进行素因子分解,在对它的素因子的个数进行gcd,比如12=2^2*3,gcd(2,1)就是最大的p;
当n是负数时,则p的值一定是奇数,因为一个数的偶数次方一定为整数,因此需要将它的素因子个数全都化为奇数。

#include
#include<string.h>
const int MAXN=1000100;
bool vis[MAXN];
long long prime[MAXN/10];
int tot=0;
void getPrime()//求素数
{
    for(long long i=2;i)
        if(!vis[i])
        {
            prime[tot++]=i;
            for(long long j=i*i;jtrue;
        }
}
int a[1000];//保存素因子
int b[1000];//保存素因子的个数
int cnt;
void sbreak(long long n){
         //进行素因子分解
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    cnt=0;
    for(int i=0;prime[i]*prime[i]<=n;i++){
        if(n%prime[i]==0){
            a[cnt]=prime[i];
            while(n%prime[i]==0){
                b[cnt]++;
                n/=prime[i];
            }
            cnt++;
        }
    }
    if(n!=1){
        a[cnt]=n;
        b[cnt++]=1;
    }
}

int gcd(int a,int b)  //求最大公约数
{
    return b?gcd(b,a%b):a;
}

int main(){
    int T,ans,kase=0,flag;
    long long n;
    getPrime();
    scanf("%d",&T);
    while(T--){
        flag=1;//标志,判断n是正数还是负数
        scanf("%lld",&n);
        if(n<0) n=-n,flag=0;
        sbreak(n);
        int t=b[0];
        if(!flag){
         //如果n是奇数
            if(t%2==0){
                while(t%2==0) t/=2;
            }
            for(int i=0;i//将它的素因子的个数化为奇数
                if(b[i]%2==0){
                    while(b[i]%2==0) b[i]/=2;
                }
                t=gcd(t,b[i]);
            }
        }
        else for(int i=0;igcd(t,b[i]);
        printf("Case %d: %d\n",++kase,t);
    }
    return 0;
}
View Code

 

46 / 98 Problem K LightOJ 1214 Large Division

d.问a能否被b整除

s.大数

c.借机水下java大数

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
         //类名要用Main
    public static void main(String[] args){
        
        int T;
        BigInteger a,b;
        BigInteger ZERO=new BigInteger("0");
        Scanner sc=new Scanner(System.in);
        int ca=0;
        
        T=sc.nextInt();
        while((T--)>0){
            
            a=sc.nextBigInteger();
            b=sc.nextBigInteger();
            System.out.print("Case ");
            System.out.print(++ca);
            if(a.remainder(b).compareTo(ZERO)==0){
         //b可能为负数,不能用mod函数
                
                System.out.println(": divisible");
            }
            else{
         //
                System.out.println(": not divisible");
            }
            
        }
        
    }
}
View Code

c2.大数模板,好臃肿啊!写起来也麻烦!用了下,还wa了好几发,很尴尬。%运算里面的d可能超int,得用long long才行,这种错不好找啊。。

ps:能少用这个就少用,代码太长。

/*
整数大数
int数组实现
*/
#include
#include
#include
#include<string.h>
using namespace std;

#define MAXN 9999//万进制
#define DLEN 4//4位

class BigNum{
private:
    int a[500];//可以控制大数位数(500*4)
    int len;//大数长度
public:
    BigNum(){
          //构造函数
        len=1;
        memset(a,0,sizeof(a));
    }
    BigNum(const int);//将int转化为大数
    BigNum(const char *);//将字符串转化为大数
    BigNum(const BigNum &);//拷贝构造函数
    BigNum &operator=(const BigNum &);//重载赋值运算符,大数之间赋值

    BigNum operator+(const BigNum &)const;//大数+大数
    BigNum operator-(const BigNum &)const;//大数-大数
    BigNum operator*(const BigNum &)const;//大数*大数
    BigNum operator/(const int &)const;//大数/int

    BigNum operator^(const int &)const;//幂运算
    int operator%(const int &)const;//取模
    bool operator>(const BigNum &)const;//大数与大数比较
    bool operator>(const int &)const;//大数与int比较

    void print();//输出大数
};

BigNum::BigNum(const int b){
         //将int转化为大数
    int c,d=b;
    len=0;
    memset(a,0,sizeof(a));
    while(d>MAXN){
        //c=d-(d/(MAXN+1))*(MAXN+1);
        c=d%(MAXN+1);//取出后四位
        d=d/(MAXN+1);//
        a[len++]=c;
    }
    a[len++]=d;
}
BigNum::BigNum(const char *s){
         //将字符串转化为大数
    int t,k,index,l,i,j;
    memset(a,0,sizeof(a));
    l=strlen(s);
    len=l/DLEN;
    if(l%DLEN)++len;
    index=0;
    for(i=l-1;i>=0;i-=DLEN){
        t=0;
        k=i-DLEN+1;
        if(k<0)k=0;
        for(j=k;j<=i;++j)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}
BigNum::BigNum(const BigNum &T):len(T.len){
         //拷贝构造函数
    int i;
    memset(a,0,sizeof(a));
    for(i=0;ii)
        a[i]=T.a[i];
}
BigNum &BigNum::operator=(const BigNum &n){
         //重载复制运算符,大数之间赋值
    int i;
    len=n.len;
    memset(a,0,sizeof(a));
    for(i=0;ii)
        a[i]=n.a[i];
    return *this;
}

BigNum BigNum::operator+(const BigNum &T)const{
         //大数+大数
    BigNum t(*this);
    int i,big;//位数
    big=T.len>len?T.len:len;
    for(i=0;ii){
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN){
            ++t.a[i+1];
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0)t.len=big+1;
    else t.len=big;
    return t;
}
BigNum BigNum::operator-(const BigNum &T)const{
         //大数-大数
    int i,j,big;
    bool flag;
    BigNum t1,t2;//t1大的,t2小的
    if(*this>T){
        t1=*this;
        t2=T;
        flag=0;//前面的大
    }
    else{
        t1=T;
        t2=*this;
        flag=1;//前面的小
    }
    big=t1.len;
    for(i=0;ii){
        if(t1.a[i]<t2.a[i]){
            j=i+1;
            while(t1.a[j]==0)++j;
            --t1.a[j--];
            while(j>i)t1.a[j--]+=MAXN;
            t1.a[i]+=MAXN+1-t2.a[i];
        }
        else t1.a[i]-=t2.a[i];
    }
    while(t1.a[t1.len-1]==0&&t1.len>1){
        --t1.len;
        --big;
    }
    if(flag)t1.a[big-1]=-t1.a[big-1];//前面的小,结果为负
    return t1;
}
BigNum BigNum::operator*(const BigNum &T)const{
         //大数*大数
    BigNum ret;
    int i,j,up;
    int temp,temp1;
    for(i=0;ii){
        up=0;
        for(j=0;jj){
            temp=a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN){
                //temp1=temp-temp/(MAXN+1)*(MAXN+1);
                temp1=temp%(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            }
            else{
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0)ret.a[i+j]=up;
    }
    ret.len=i+j;
    while(ret.a[ret.len-1]==0&&ret.len>1)--ret.len;
    return ret;
}
BigNum BigNum::operator/(const int &b)const{
         //大数/int
    BigNum ret;
    int i,down=0;
    for(i=len-1;i>=0;--i){
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
    }
    ret.len=len;
    while(ret.a[ret.len-1]==0&&ret.len>1)--ret.len;
    return ret;
}

BigNum BigNum::operator^(const int &n)const{
         //幂运算
    BigNum t,ret(1);
    int i;
    if(n<0)exit(-1);
    if(n==0)return 1;
    if(n==1)return *this;
    int m=n;
    while(m>1){
        t=*this;
        for(i=1;i<<1<=m;i<<=1){
            t=t*t;
        }
        m-=i;
        ret=ret*t;
        if(m==1)ret=ret*(*this);
    }
    return ret;
}
int BigNum::operator%(const int &b)const{
         //取模
    int i;
    long long d=0;//这个题这里必须用long long,还得。。可能会超限。
    for(i=len-1;i>=0;--i){
        d=((d*(MAXN+1))%b+a[i])%b;
    }
    return d;
}
bool BigNum::operator>(const BigNum &T)const{
         //大数与大数比较
    int ln;
    if(len>T.len)return true;
    else if(len==T.len){
        ln=len-1;
        while(a[ln]==T.a[ln]&&ln>=0)--ln;
        if(ln>=0&&a[ln]>T.a[ln])return true;
        else return false;
    }
    else return false;
}
bool BigNum::operator>(const int &t)const{
         //大数与int比较
    BigNum b(t);
    return *this>b;
}

void BigNum::print(){
         //输出大数
    int i;
    printf("%d",a[len-1]);
    for(i=len-2;i>=0;--i){
        printf("%.4d",a[i]);//%.4d代表4位,不够前面补0
    }
    printf("\n");
}

int main(){
    /*
    char str1[]="2",str2[]="22222222222222222222222222222222222222222222";
    int c=2;
    //scanf("%s%s",str1,str2);
    BigNum a,b,t;
    a=BigNum(str1);
    b=BigNum(str2);
    printf("a=");a.print();
    printf("b=");b.print();
    printf("c=%d\n",c);
    printf("\n");

    t=a+b;
    printf("a+b=");t.print();
    t=a-b;
    printf("a-b=");t.print();
    t=a*b;
    printf("a*b=");t.print();
    t=a/c;
    printf("a/c=");t.print();
    printf("\n");

    t=a^c;
    printf("a^c=");t.print();
    t=a%c;
    printf("a%%c=");t.print();

    a>b?printf("a>b\n"):printf("a<=b\n");
    a>c?printf("a>c\n"):printf("a<=c\n");
    */
    int T;
    BigNum a;
    int b;
    char str1[300];
    int t;
    int ca=0;

    scanf("%d",&T);

    while(T--){
        scanf("%s%d",str1,&b);
        if(str1[0]=='-'){
            a=BigNum(str1+1);
        }
        else{
            a=BigNum(str1);
        }
        if(b<0){
            b=-b;
        }

        t=a%b;
        if(t==0){
            printf("Case %d: divisible\n",++ca);
        }
        else{
            printf("Case %d: not divisible\n",++ca);
        }
    }

    return 0;
}
View Code

c3.直接写也挺好啊~网上代码。里面的res也得用long long。

#include 
#include 
#include 
#include 
 
using namespace std;
 
char str[205];
long long mod;
 
int main()
{
    int t;
    scanf("%d",&t);
    int cas = 0;
    while( t-- )
    {
        scanf("%s %lld",str,&mod);
        //printf("%s %d\n",str,mod);
        int len = strlen( str );
        int s = 0;
        if( str[0] == '-' )
            s++;
        long long res = 0;
        for( int i = s; i < len; i++ )
            {
                res = res*10 + str[i] - '0';
                res = res % mod;
            }
        if( !res )
            printf("Case %d: divisible\n",++cas);
        else
            printf("Case %d: not divisible\n",++cas);
    }
    return 0;
}
View Code

 

35 / 62 Problem L LightOJ 1213 Fantasy of a Summation

题意:给你一个求和的循环,让你计算最后的结果是多少?

思路:首先,我们得明确在这个循环里面,a[0]……a[n-1]出现的次数是一样多的,
它大的累加的次数为n^k次方。
看第二个样例:
它有2个数字,3层循环
1、a[0]   a[0]   a[0]
2、a[0]   a[0]   a[1]
3、a[0]   a[1]   a[0]
4、a[0]   a[1]   a[1]
5、a[1]   a[0]   a[0]
6、a[1]   a[0]   a[1]
7、a[1]   a[1]   a[0]
8、a[1]   a[1]   a[1]
在这里面它的大的累加次数为2^3=8次,因为每个数的累加次数一样多的
它每个数的累加次数为(n^k)*k/n=(n^(k-1))*k,
则和就等于(sum(a[i])*(n^(k-1))*k)%mod

#include
long long pow(int a,int n,int mod){
    if(n==0) return 1;
    long long t=pow(a,n/2,mod);
    t=t%mod;
    long long ans=t*t%mod;
    if(n%2==1) ans=(ans*(a%mod))%mod;
    return ans;
}
int main(){
    int T,kase=0;
    int a[1005];
    scanf("%d",&T);
    while(T--){
        int n,k,mod;
        long long ans=0;
        scanf("%d%d%d",&n,&k,&mod);
        for(int i=0;i){
            scanf("%d",&a[i]);
            ans=(ans+a[i]%mod)%mod;
        }
        long long t=pow(n,k-1,mod);
        ans=((ans*(k%mod)%mod)*t)%mod;
        printf("Case %d: %lld\n",++kase,ans);
    }
    return 0;
}
View Code

 

41 / 137 Problem M LightOJ 1197 Help Hanzo

给你a和b求a到b之间的素数个数。

先在小区间素数筛,大区间就用类似素数筛的想法,把a到b之间不是素数的标记出来。因为b-a最多1e5的大小,所以每组数据的时间复杂度最多就o(1e5 log1e5)。

ps:我感觉这个复杂度为O(1e5+log1e5)

#include 
#include 
#include 
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long LL;
bool prime[MAXN] , vis[MAXN];
LL p[MAXN / 5];

void init() {
    prime[1] = true;
    int cont = 0;
    for(int i = 2 ; i < MAXN ; i++) {
        if(!prime[i]) {
            p[++cont] = i;
            for(int j = i * 2 ; j < MAXN ; j += i) 
                prime[j] = true;
        }
    }
}

int main()
{
    init();
    int t , a , b;
    scanf("%d" , &t);
    for(int ca = 1 ; ca <= t ; ca++) {
        scanf("%d %d" , &a , &b);
        int res = 0;
        if(b < MAXN) {
            for(int i = a ; i <= b ; i++) {
                if(!prime[i])
                    res++;
            }
        }
        else {
            memset(vis , false , sizeof(vis));
            for(int i = 1 ; p[i]*p[i] <= b ; i++) {
                LL k = a / p[i];
                if(k*p[i] < a)
                    k++;
                if(k == 1) //此时a%p[i]==0 && a/p[i]==1,说明a刚好是一个素数
                    k++;
                while(k * p[i] <= b) { //筛选a~b中不是素数的
                    vis[k*p[i] - a] = true;
                    k++;
                }
            }
            for(int i = a ; i <= b ; i++) {
                if(!vis[i - a])
                    res++;
            }
        }
        printf("Case %d: %d\n" , ca , res);
    }    
}
View Code

 

45 / 100 Problem N LightOJ 1138 Trailing Zeroes (III)

d.给一个Q,代表N!末尾有Q个0。给出Q,找到最小的N。

s.可以用二分法,找到最小的N。

然后看看怎么求N!后面有几个0?

有算数基本定理可知 N!可划分为质因数相乘的形式  n!=2x*3y*5z*...

因为只有2*5才会出现0,又因为2的个数比5多(可见下面证明),所以N!后面的0的个数就是N!的分解中的5的个数。

那么如何求一个数的阶乘的结果5的幂次方是多少。

譬如30!的结果中,5的幂究竟是多少,答案是30/5 = 6, 6/5 = 1;结果为7个。除到最后的数<5为止。可以自己在纸上验证。

证明:2的个数比5多

对n!做质因数分解n!=2x*3y*5z*...

显然0的个数等于min(x,z),并且min(x,z)==z

对于阶乘而言,也就是1*2*3*...*n
[n/k]代表1~n中能被k整除的个数
那么很显然
[n/2] > [n/5] (左边是逢2增1,右边是逢5增1)
[n/2^2] > [n/5^2](左边是逢4增1,右边是逢25增1)
……
[n/2^p] > [n/5^p](左边是逢2^p增1,右边是逢5^p增1)
随着幂次p的上升,出现2^p的概率会远大于出现5^p的概率。
因此左边的加和一定大于右边的加和,也就是n!质因数分解中,2的次幂一定大于5的次幂。

#include 
#include 
#include 
#include 
#include <string>
#include <string.h>
#include 
#include 
#include 

using namespace std;

typedef long long LL;

LL solve(LL n)
{
    LL num=0;
    while(n)
    {
        num+=n/5;
        n/=5;
    }
    return num;
}

LL er(LL n)
{
    LL x=1;
    LL y=0x3f3f3f3f;
    LL mid;
    LL res=-1;
    while(x<=y)
    {
        mid=(x+y)/2;
        LL ans=solve(mid);
        if(ans==n)
        {
            res=mid;
            y=mid-1;
            //return mid;
        }
        else if(ans>n)
        {
            y=mid-1;
        }
        else if(ans<n)
        {
            x=mid+1;
        }
    }
    return res;
}
int main()
{

    int t;
    scanf("%d",&t);
    int xp=1;
    while(t--)
    {
        LL n;
        scanf("%lld",&n);
        LL ans=er(n);
        if(ans==-1)  printf("Case %d: impossible\n",xp++);
        else printf("Case %d: %lld\n",xp++,ans);
    }
    return 0;
}
View Code

 

37 / 48 Problem O UVA 11426 GCD - Extreme (II)

d.

G=0;
for(i=1;ifor(j=i+1;j<=N;j++)
{
G+=gcd(i,j);
}

求G。

s.假设a、b(a

假设和b互质的数有n个,也就是n对(?,b)(?和b互质),那么在i、j循环到?、b时结果会增加n,循环到(2*?,2*b)时结果就会增加2*n...当i、j循环到k*?、k*b时结果就会增加k*n。那么我们不妨用a[i]记录各种k、b在满足k*b=i时会增加多少结果,a[i]代表gcd(x,i)的和,其中x小于i,那么最后我们要输出的就是a[2]+a[3]+...+a[N]。

至于找和b互质的数,就是计算b的欧拉函数的值,然后暴力循环k,并修改对应的a[k*b]即可,整体的复杂度是O(N*logN)的。

欧拉函数扩展: 欧拉公式的延伸:小于n 与n互质的数的和 是euler(n)*n/2

//欧拉函数复杂度O(nlogn)
#include
#include<string.h>
#include 
using namespace std;
#define MAXD 4000010
const int N = 4000000;
typedef long long LL;
int phi[MAXD];
LL a[MAXD];

void prep()
{
    memset(a, 0, sizeof(a));
    for(int i = 1; i <= N; i ++)
        phi[i] = i;
    for(int i = 2; i <= N; i ++)
    {
        if(phi[i] == i){ ///质数
            for(int j = i; j <= N; j += i){
                phi[j] = phi[j] / i * (i - 1);
            }
        }
        for(int j = 1; j * i <= N; j ++)  
            a[j * i] += j * phi[i]; ///通过对i*j的质因子来求
    }
    for(int i = 1; i <= N; i ++)
        a[i] += a[i - 1];
}

int main()
{
    prep();
    int n;
    while(scanf("%d", &n), n)
        printf("%lld\n", a[n]);
    return 0;
}
View Code

 

13 / 65 Problem P UVA 11754 Code Feat
9 / 26 Problem Q UVA 11916 Emoogle Grid
36 / 86 Problem R POJ 1061 青蛙的约会

s.设A在后,B在前,当A与B相遇时,满足:(m-n)*X=(y-x)+L*Y;X是时间,Y是圈数。

移项:(m-n)*X-L*Y=(y-x);

令a=m-n,b=-L,d=gcd(a,b)。则(y-x)%d==0时有解,否则无解。

求出特解,再求最小的X即可。

/*
扩展欧几里德算法(求ax+by=gcd的解以及逆元)
*/
#include
#include
#include
using namespace std;

//返回d=gcd(a,b);和对应于等式ax+by=d中的x,y
long long extend_gcd(long long a,long long b,long long &x,long long &y){
    if(a==0&&b==0)return -1;//无最大公约数
    if(b==0){x=1;y=0;return a;}
    long long d=extend_gcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}

int main(){

    int x,y,m,n,L;
    long long a,b,x0,y0,d;
    long long abs_bd;

    while(~scanf("%d%d%d%d%d",&x,&y,&m,&n,&L)){
        a=m-n;
        b=-L;
        d=extend_gcd(a,b,x0,y0);

        abs_bd=abs(b/d);

        if((y-x)%d==0){
            x0=(x0*((y-x)/d))%b;
            //x0=(x0%(b/d)+(b/d))%(b/d);
            x0=(x0%abs_bd+abs_bd)%abs_bd;
            printf("%lld\n",x0);
        }
        else{
            printf("Impossible\n");
        }
    }

    return 0;
}
View Code

 

24 / 63 Problem S POJ 2115 C Looooops

hint:见之前博客


13 / 35 Problem T POJ 2116 Death to Binary?
61 / 122 Problem U HDU 2161 Primes

输入n,是素数输出yes,不是则输出no。

#include 
#include 
#include 
#include 
using namespace std;

int p[16001];

int main()
{
    int n,k=0;
    memset(p,-1,sizeof(p));
    p[1]=0;
    p[2]=0;
    for(int i=3; i<=16000; i++)
    {
        for(int j=2; j<=sqrt(i); j++)
        {
            if(i%j==0)
            {
                p[i]=0;
                break;
            }
        }
    }

    while(~scanf("%d",&n))
    {
        if(n<=0)
            return 0;
        if(p[n]==-1)
            printf("%d: yes\n",++k);
        else
            printf("%d: no\n",++k);
    }

    return 0;
}
View Code

 

32 / 87 Problem V UVA 11827 Maximum GCD

题意:给你一组数,求出其中两两最大公约数中最大的值。

思路:数据较小,直接枚举。

#include
int gcd(int a,int b){
         //求最大公约数
    return b?gcd(b,a%b):a;
}
int main(){
    int T;
    int a[105];
    char c;
    scanf("%d",&T);
    while (getchar() != '\n');
    while(T--){
        int cnt=0;
        while((c=getchar())!='\n'){
            if(c>='0' && c<='9'){
                ungetc(c,stdin);//将字符c退回到输入流中
                scanf("%d",&a[cnt++]);
            }
        }
        int max=0;
        for(int i=0;i1;i++){
            for(int j=i+1;j){
                int t=gcd(a[i],a[j]);
                if(t>max) max=t;
            }
        }
        printf("%d\n",max);
    }
    return 0;
}
View Code

 

25 / 98 Problem W UVA 10200 Prime Time

题意:通过公式计算出一个数,判断这个数是否为素数。在区间[a,b]上通过公式算出素数占总数的百分比。

ps:里面加上1e-8是什么梗

#include 
#include <string.h>
int prime(int n)
{
    int i;
    for(i=2;i*i<=n;i++)
    {
        if((n%i)==0)
            return 0;
    }
    return 1;
}
int main()
{
    int num[10010];
    int i;
    int a,b;
    int sum;
    memset(num,0,sizeof(num));
    for(i=0;i<=10005;i++)
        num[i]=prime(i*i+i+41);
    while(scanf("%d%d",&a,&b)!=-1)
    {
        sum=0;
        for(i=a;i<=b;i++)
            sum+=num[i];
        printf("%.2f\n",sum*1.0/(b-a+1)*100+1e-8);//精度
    }
    return 0;
}
View Code

 

20 / 154 Problem X SGU 106 The equation
34 / 51 Problem Y POJ 2478 Farey Sequence

题意:给定一个数n,求小于或等于n的数中两两互质组成的真分数的个数。 表达的有点挫,很直接的欧拉函数的应用。

phi(x) 表示与x互质且小于x的正整数的个数。

#include
#include
#include
#include
#include
#define see(x) cout<<#x<<":"<#define MAXN 1000005
using namespace std;

int prime[MAXN],phi[MAXN];
bool notp[MAXN];
void Prime(){
    int i, j, np=0;
    phi[1] = 0;
    memset(notp,false,sizeof(notp));
    for(i=2;i){
        if(notp[i]==false){
            prime[np++] = i;
            phi[i] = i-1; 
        }
        for(j=0;j){
            notp[i*prime[j]] = true;
            if(i%prime[j]==0){
                phi[i*prime[j]] = phi[i]*prime[j];
                break;
            }
            else{
                phi[i*prime[j]] = phi[i]*(prime[j]-1);
            }
        }
    }
}

long long ans[MAXN];
int main(){
    int n, i;
    Prime();
    ans[1] = 0;
    for(i=2;i){
        ans[i] = ans[i-1] + phi[i];
    }
    while(scanf("%d",&n)&&n){
        cout<endl;
    }
    return 0;
}
View Code

这里要说到关于筛素数的方法。以下算法复杂度为O(n)

void Prime(){
    int i, j, np=0;
    memset(notp,false,sizeof(notp));
    for(i=2;i){
        if(notp[i]==false){
            prime[np++] = i;
        }
        for(j=0;j){
            notp[i*prime[j]] = true;
            if(i%prime[j]==0){   //O(n)的关键
                break;
            }
        }
    }
}
View Code

适时跳出,大大降低了算法复杂度。本质就是任意一个合数都有一个最小质因数,最终被赋值为true时,都是由其的最小质因数筛出来的,其被筛出来后也无需再关心其他数了。

原因如下:设 i 的最小质因数为p[j],则 i%p[j]==0,设k=i/p[j],w=i*p[j]=k*p[j]*p[j],w是由k*p[j]和p[j]共同筛出来的,对于比w更大的也有因子p[j]的数ww,则自然可以由后面的m*p[j](m>k)和p[j]共同筛出来了。

对筛素数的代码,略加几行代码,就可以顺带求出欧拉函数phi[x]了。用到了递推式:

对于p|x。若p2|x,则phi(x) = phi(x/p)*p;否则phi(x) = phi(x/p)*(p-1)


23 / 63 Problem Z UVA 11752 The Super Powers

题目大意:没有输入,找出所有的超级数,超级数即可以拆分成至少两个数的幂形式。

解题思路:先用素数筛选法找出64以内的合数,以为只有幂是合数才可以进行拆分。然后枚举底数进行判断,所有小于2^64-1的数都是满足的,这里有一个技巧,就是说2^64-1已经是unsign long long 的最大值了,那么超过它的数就会变成负数。但其实i的最大次幂是可以求的,x = logi(2^64-1) = log(2^64-1) / log(i);

#include 
#include <string.h>
#include 
#include <set>
#include 

using namespace std;
typedef unsigned long long ll;
const int N = 105;
int g, v[N], a[N];

void init () {
    g = 0;
    memset(v, 0, sizeof(v));

    for (int i = 2; i <= 64; i++) {
        if (v[i]) {
            a[g++] = i;
            continue;
        }

        for (int j = i * 2; j <= 64; j += i) v[j] = 1;
    }
}

void solve () {
    set ans;
    ans.insert(1);

    ll MaxT = 1<<16;
    for (ll i = 2; i < MaxT; i++) {
        int ti = ceil(64 * log(2) / log(i)) - 1;
        ll now = i * i * i * i;
        ans.insert(now);
        for (int j = 1; a[j] <= ti; j++) {
            now *= (a[j] - a[j-1] == 1 ? i : i * i);
            ans.insert (now);
        }
    }

    for (set::iterator i = ans.begin(); i != ans.end(); i++)
        printf("%llu\n", *i);
}

int main () {
    init();
    solve ();
    return 0;
}
View Code

 

转载于:https://www.cnblogs.com/bofengyu/p/5360676.html

你可能感兴趣的:(java)