1289

http://blog.csdn.net/acdreamers/article/details/18507767

这个是位图的链接，这篇写的挺好。

模板：

#include<math.h>
#include<stdlib.h>
#include<stdio.h>
#include <algorithm>
#include<iostream>
#include<string.h>
#include<vector>
#include<map>
#include<math.h>
using namespace std;
typedef  long long LL;
typedef unsigned long long ll;
int cmp(const void*p,const void*q);
const int N=1e8;
const int M=5;
const int V=(1<<M)-1;
int prime[(N>>M)+4]= {0};
void setbit(LL x)
{
        prime[x>>M]|=1<<(x&(V));
}
bool getbit(LL x)
{
        return prime[x>>M]&(1<<(x&V));
}
int kp[7000000];
int main(void)
{
   int i,j,k;LL p;
        for(i=2; i<=20000; i++)
        {
                if(!getbit(i))
                {
                        for(j=i; i*j<=100000000; j++)
                        {
                                setbit(i*j);
                        }
                }
        }int ans=0;
        for(i=2;i<=100000000;i++)
        {
            if(!getbit(i))
            {
                kp[ans++]=i;
            }
        }
        return 0;
}

1289 - LCM from 1 to n

PDF (English)

Statistics

Forum

Time Limit: 4 second(s)

Memory Limit: 64 MB

Given an integer n, you have to find

lcm(1, 2, 3, ..., n)

lcm means least common multiple. For example lcm(2, 5, 4) = 20, lcm(3, 9) = 9, lcm(6, 8, 12) = 24.

Input

Input starts with an integer T (≤ 10000), denoting the number of test cases.

Each case starts with a line containing an integer n (2 ≤ n ≤ 10⁸).

Output

For each case, print the case number and lcm(1, 2, 3, ..., n). As the result can be very big, print the result modulo 2³².

Sample Input	Output for Sample Input
5 10 5 200 15 20	Case 1: 2520 Case 2: 60 Case 3: 2300527488 Case 4: 360360 Case 5: 232792560

---

Problem Setter: Jane Alam Jan

思路：

有个定理

这个是如果n+1是素数的次方，那么当前的L（1+n）=L（n）*p，p为素数，否则就是L（n）；

这个很好理解，如过n+1=（p）^k，我们从最小公倍数的定义：Lcm=max(a1,a2,a3....)*max(b1,b2,b3...)*max(c1,c2,c3...)*....

其中a1是A1的某个素因数的个数，a2是A2的某个素因数的个数（这两个素因数相同）.....

这样我们知道p这个素因数，在n时最大为k-1，所以当到n+1时就有L（n+1）=L(n)*p;否则的话如果n+1不是某个素数的次方那么代表着已经出现的所有素数的最大个数未被更新

那么就有L（n+1）=L（n）；所以我们将【2，1e8】的素数全部筛选出来，由于内存限制所以只能用位图来筛选。

这样筛好后，然后我们把<=(1e8)的素数的次方打表出来，然后排序，这样再打表下到每个素数次方时（1，p^k）的LCM；然后每次查找二分就行。

#include<math.h>
#include<stdlib.h>
#include<stdio.h>
#include <algorithm>
#include<iostream>
#include<string.h>
#include<vector>
#include<map>
#include<math.h>
#include<queue>
using namespace std;
typedef  long long LL;
typedef unsigned long long ll;
const int N=1e8+2;
const int M=5;
const int V=(1<<M)-1;
const LL  mod=4294967296;
typedef struct node
{
        unsigned int id;
        unsigned int NN;

} ss; bool  cmp( struct node p,struct  node q)
{
        return  p.NN<q.NN?true:false;
}
ss io[6000000];
int prime[(N>>M)+4]= {0};
void setbit(LL x)
{
        prime[x>>M]|=1<<(x&(V));
}
bool getbit(LL x)
{
        return prime[x>>M]&(1<<(x&V));
}
int er(int n,int m,int ans,int t);
int main(void)
{
        int i,j,k;LL p;
        for(i=2; i<=20000; i++)
        {
                if(!getbit(i))
                {
                        for(j=i; i*j<=100000000; j++)
                        {
                                setbit(i*j);
                        }
                }
        }
        int ans=0;
        int cns=0;
        for(i=2; i<100000000; i++)
        {
                if(!getbit(i))
                {
                         LL sum=i;ans++;
                        while(sum<=N)
                        {
                                io[cns].id=i;
                                io[cns++].NN=sum;
                                sum*=i;
                        }
                }
        }sort(io,io+cns,cmp);
        for(i=1;i<cns;i++)
        {
         io[i].id=(io[i-1].id*io[i].id)%mod;
        }//freopen("data.in","r",stdin);
         //freopen("wrong.out","w",stdout);
        scanf("%d",&k);
        int s;
        for(s=1; s<=k; s++)
        {
                scanf("%lld",&p);printf("Case %d: ",s);
                {int l,r;
                l=0;
                r=cns-1;
                int ak=0;
                int uu;
                while(l<=r)
                {
                    int c=(l+r)>>1;
                    if(io[c].NN<=p)
                    {
                        ak=c;
                        l=c+1;
                    }
                    else
                        r=c-1;
                }
                unsigned int sum1=io[ak].id;
                printf("%u
",sum1);}
        }
        return 0;
}
int  er(int n,int m,int ans,int t)
{  int l=(n+m)/2;if(l<0)return -1;
    if(io[l].NN==ans)
    {
        return l;
    }

     if(io[l-1].NN<ans&&io[l].NN>ans)
    {
        return l-1;
    } else if(n==m&&m==t)
        return m;
    else if(n==m)
        return n-1;
    else if(io[l-1].NN>=ans&&io[l].NN>ans)
    {
        return er(n,l-1,ans,t);
    }
    else if(io[l-1].NN<ans&&io[l].NN<ans)
    {
        return er(l+1,m,ans,t);
    }
}

我这里两种二分，下面函数式的比较难把喔，写起来很恶心。