hdu 5317 RGCDQ 2015 Multi-University Training Contest 3

最新推荐文章于 2016-09-22 10:02:25 发布
最新推荐文章于 2016-09-22 10:02:25 发布
阅读量458 收藏
点赞数
分类专栏： ACM_数学 ACM_Multi-University Training ACM_脑洞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yskyskyer123/article/details/47121575
版权


RGCDQ

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 853    Accepted Submission(s): 386

Problem Description
Mr. Hdu is interested in Greatest Common Divisor (GCD). He wants to find more and more interesting things about GCD. Today He comes up with Range Greatest Common Divisor Query (RGCDQ). What’s RGCDQ? Please let me explain it to you gradually. For a positive integer x, F(x) indicates the number of kind of prime factor of x. For example F(2)=1. F(10)=2, because 10=2*5. F(12)=2, because 12=2*2*3, there are two kinds of prime factor. For each query, we will get an interval [L, R], Hdu wants to know maxGCD(F(i),F(j)) (L≤i<j≤R)
 

Input
There are multiple queries. In the first line of the input file there is an integer T indicates the number of queries.
In the next T lines, each line contains L, R which is mentioned above.

All input items are integers.
1<= T <= 1000000
2<=L < R<=1000000
 

Output
For each query，output the answer in a single line.
See the sample for more details.
 

Sample Input 
  
  

   
   2
2 3
3 5
 

Sample Output 
  
  

   
   1
1
 

Source
2015 Multi-University Training Contest 3
 

Recommend
wange2014   |   We have carefully selected several similar problems for you:   5326  5325  5324  5323  5322 


题目首先定义了一个函数F[x]: F(x) indicates the number of kind of prime factor of x.
然后T组测试数据（1<= T <= 1000000）每组测试数据求maxGCD(F(i),F(j))maxGCD(F(i),F(j))GCD(F(i),F(j)) (L≤i<j≤R)

首先会发现F[x]   (1<=x<=1000000)  不会是一个很大的数（实际最大为7），对于已经求出F[i]值的一个区间只有几个数
，即使暴力也可行。
若同一个F[i]值出现两次以上，要考虑到他们的gcd（）就是自身。


首先肯定是要求F[i]的，因为T非常大，就要考虑到每次输入区间L，R，能快速得到该区间有没有1到7这7个F[i]值。
解决办法是开一个数组p[8][maxn],对于[L，R]区间 使得f[x]==k的x个数为 p[k][R]-p[k][L-1];
这样就能判断1到7中的每个值到底有没有 。

最终修改代码： 
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<climits>
#include<queue>
#include<vector>
#include<map>
#include<sstream>
#include<set>
#include<stack>
#include<utility>
using namespace std;
const int maxn=1000000;
int F[maxn+10];
int p[8][maxn+10];
  int ans[12];
 int gcd(int a,int b)
{
    int r;
    while(b>0)
    {
         r=a%b;
         a=b;
         b=r;
    }
    return a;
}
inline void  Eratosthenes()   //直接的得出F[j]值，所以这个筛法的本质是每次都用一个不同的素数筛
{
    memset(F,0,sizeof F);
      int m=sqrt(maxn);
      for(int i=2;i<=maxn;i++)
      {
          if(!F[i])
           for(int j=i;j<=maxn;j+=i)
                  F[j]++;             

      }

}

inline void getp()
{
   for(int i=1;i<=7;i++)
       p[i][0]=p[i][1]=0;

    for(int i=2;i<=maxn;i++)
    {
        for(int j=1;j<=7;j++)
        {
            p[j][i]=p[j][i-1];
            if(F[i]==j)  p[j][i]++;

        }
    }


}


int main()
{
    Eratosthenes();
     getp();

     int n,m;
     int T;
    scanf("%d",&T);
    while(T--)
     {
         scanf("%d%d",&n,&m);

         memset(ans,0,sizeof ans);

       for(int i=1;i<=7;i++)
        {

            int tmp=p[i][m]-p[i][n-1];
            ans[i]+=tmp;

        }

        int maxi=1;

     for(int i=7;i>=3;i--)
     {
         if(ans[i]>=2)
          {maxi=i;break;}
     }

 if(maxi >=3 )   {printf("%d\n",maxi);continue;}  //情况无非这几种



     if(ans[2]&&ans[4])  maxi=2;
        if(ans[3]&&ans[6])  maxi=3;

              printf("%d\n",maxi);

     }
    return 0;
}


之前比赛的代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int MAXN=1000000+10;
int prime[78510];
int F[MAXN];
bool noprime[MAXN];
//int dp[10][MAXN]
int p[7][MAXN];
 int gcd(int a,int b)
{
    int r;
    while(b>0)
    {
         r=a%b;
         a=b;
         b=r;
    }
    return a;
}
int cnt;
inline void  Eratosthenes()
{

      memset(noprime,0,sizeof(noprime));
      int m=sqrt(MAXN);
      for(int i=2;i<=m;i++)
      {
          if(!noprime[i])
          for(int j=i*i;j<=MAXN;j+=i)
                  noprime[j]=1;
      }

}

inline void Get_prime()
{
    /*
    memset(prime,0,sizeof prime);
    for (int i=2;i<=MAXN;i++)
    {
        if (!prime[i]) { prime[++prime[0]]=i;
        for (int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++){
            prime[prime[j]*i]=1;
        if (i%prime[j]==0)  break;
        }
    }
}*/
     memset(prime,0,sizeof prime);
//     cout<<prime[0]+cnt<<endl;
   for(int i=2;i<=MAXN;i++)
   {
       if(!noprime[i])
          prime[++prime[0]]=i;
        else
            cnt++;
   }
//   for(int i=2;i<=MAXN;i++)
//   {
//       if(noprime[i])
//        cnt++;
//   }


}


inline void numprime()
{
    memset(F,0,sizeof F);

    for(int i=1;i<=prime[0];i++)
    {
        for(int j=prime[i];j<=MAXN;j+=prime[i])
        {
            F[j]++;
        }
    }
    int ret=0;
    for(int i=0;i<7;i++)
        p[i][1]=0;
    for(int i=2;i<=MAXN;i++)
    {
        for(int j=0;j<7;j++)
        {
            p[j][i]=p[j][i-1];
            if(   j+1==F[i] )
                p[j][i]++;

        }

   }
   /*
   for(int i=1;i<=100;i++)
   {
      cout<<F[i]<<" "<<p[0][i]<<endl;
   }*/
//     cout<<p[0][3]<<" "<<" "<<p[0][1]<<endl;
}


int main()
{
  cnt=0;
    Eratosthenes();
    Get_prime();
      numprime();

     int n,m;
     int T;

    cin>>T;
    while(T--)
     {
         scanf("%d%d",&n,&m);
         int ans[12];
         memset(ans,0,sizeof ans);

       for(int i=0;i<7;i++)
        {

            int tmp=p[i][m]-p[i][n-1];
            ans[i+1]+=tmp;
        }

        int mannum=0;
for(int i=1;i<10;i++)
{
    if(ans[i]>=2)
        mannum=max(mannum,i);
}
        for (int i=1;i<10;i++)
        {
            if (!ans[i])  continue;

                for (int j=1;j<10;j++)
                {
                     if (!ans[j])  continue;
                     if(i==j)  continue;
                    mannum=max(mannum,gcd(i,j));
                }


        }
              printf("%d\n",mannum);

     }
    return 0;
}

先判断自大区间内每个数的是否是素数，在来对每个数进行分解，找出质因子种类，单纯这样做应该超时，所以比赛时的代码改进了些，又加了剪枝,没有前面的简洁



还有个地方可以改进：



#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int MAXN=1000000;
int prime[78510];
int F[MAXN+10];
int maxprime[MAXN+10];
//int dp[10][MAXN]
int p[7][MAXN+10];
 int gcd(int a,int b)
{
    int r;
    while(b>0)
    {
         r=a%b;
         a=b;
         b=r;
    }
    return a;
}
inline void  Eratosthenes()
{

      memset(maxprime,0,sizeof(maxprime));
      for(int i=2;i<=MAXN;i++)
      {
          if(!maxprime[i])
          for(int j=i;j<=MAXN;j+=i)
                  maxprime[j]=i;
      }


}




inline void numprime()
{
   memset(F,0,sizeof F);



    F[1]=0;
    for(int i=2;i<=MAXN;i++)  //求F[x]，这个地方看了别人的博客，可以改进,dp的思想
    {
        if(!maxprime[i])   {F[i]=1;continue;}
        int y=i;
        int x=maxprime[i];

            while(y%x==0)  y/=x;

             F[i]=F[y]+1;

    }


    for(int i=0;i<7;i++)
        p[i][1]=0;
    for(int i=2;i<=MAXN;i++)
    {
        for(int j=0;j<7;j++)
        {
            p[j][i]=p[j][i-1];
            if(   j+1==F[i] )
                p[j][i]++;

        }

    }
}


int main()
{
    Eratosthenes();
      numprime();

     int n,m;
     int T;

    cin>>T;
    while(T--)
     {
         scanf("%d%d",&n,&m);
         int ans[12];
         memset(ans,0,sizeof ans);

       for(int i=0;i<7;i++)
        {

            int tmp=p[i][m]-p[i][n-1];
            ans[i+1]+=tmp;
        }

        int mannum=0;
for(int i=1;i<10;i++)
{
    if(ans[i]>=2)
        mannum=max(mannum,i);
}
        for (int i=1;i<10;i++)
        {
            if (!ans[i])  continue;

                for (int j=1;j<10;j++)
                {
                     if (!ans[j])  continue;
                     if(i==j)  continue;
                    mannum=max(mannum,gcd(i,j));
                }


        }
              printf("%d\n",mannum);

     }
    return 0;
}


PoemK
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2019 Multi-University Training Contest 4(2019hdu多校第六场数据与标程）rar
08-11
在编程竞赛的世界里，HDU（Hangzhou Dianzi University）举办的Multi-University Training Contest一直备受关注，尤其是2019年的第六场赛事，更是吸引了众多参赛者一展才华。这个名为"2019 Multi-University ...
有2019 Multi-University Training Contest 9，hdu多校第9场的题解.zip
08-19
《2019 Multi-University Training Contest 9 HDU多校第9场题解解析》 在编程竞赛的世界中，ACM（国际大学生程序设计竞赛）是一项备受瞩目的活动，它旨在培养学生的算法设计、问题解决和编程能力。2019年，多所大学...
2019 Multi-University Training Contest 10数据标程.rar
08-22
标题中的“2019 Multi-University Training Contest 10数据标程.rar”指的是2019年举办的多所大学联合编程训练比赛的第十场竞赛的数据集和参考解程。这个压缩包通常包含了该比赛的所有题目、输入输出样例、评测标准...
有2019 Multi-University Training Contest 8数据标程.rar
08-19
有2019 Multi-University Training Contest 8，hdu多校第8场的题解，数据标程，有需要的可以下载哦
2019 Multi-University Training Contest 7数据标程.rar
08-19
《2019 Multi-University Training Contest 7数据标程》是针对 ACM（国际大学生程序设计竞赛）的一份宝贵资源，特别关注了 HDU（杭州电子科技大学）组织的多校第七场比赛。这份压缩包文件包含了该比赛的题解和数据标...
中国剩余定理 /孙子定理
便纵有千种风情
10-10 1423
1.若gcd(m,M)=1,则存在整数t，使得 t*M≡1(mod m)    存在t使得 t*M=1(mod m) 等价于 X*M+m*Y=1 有解   这个在  我写的 拓展欧几里德  里面已经详细证明过。 2. 方程组 X=a[i](mod m[i]) (且对于i!=j，gcd(m[i],m[j])=1)的解为 X=∑a[i]*t[i]*M[i]+k*M(k∈Z)
hdu 5731 Solid Dominoes Tilings 插头dp+容斥原理
便纵有千种风情
07-23 1367
题意：给出一个n*m大小的棋盘，需要你用1*2的砖铺满它，砖不可重叠，并且要求棋盘上没有行分割线或列分割线。 输出方法种数。需要取模。
poj 1496 Word Index 计数/组合数学
便纵有千种风情
06-12 804
给出一些串的排列规则，输入一个串，要你输出它的序数。 解: 先统计长度比它小的串个数，用组合。 再统计长度相等并且序数比它小的个数，扫描+组合。 Word Index Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 4955   Accepted: 2815
POJ 3518 Prime Gap 筛法+二分 水题一个
便纵有千种风情
03-12 765
Prime Gap Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 9622   Accepted: 5530 Description The sequence of n − 1 consecutive composite numbers (positive i
CF 559C. Gerald and Giant Chess 组合数学+DP
便纵有千种风情
09-22 740
题目链接题意：给出一个h*w的棋盘(h,w<=1e5),其中有n个位置不能走(n<=2000),现在要从左上角走到右下角，每步只能向下或者向右走一步。问有多少种走法？右下角保证可以走到。解法：对于右走x步，下走y步的无限制方案数是C(x+y,y)，可以记为C(x,y)。 首先将最右下角也作为一个不能走的位置,最后要求出到达这个位置的合法路径数dp[n]。 对所有不能走的位置排序，先比较行，再
拓展欧几里德
便纵有千种风情
10-06 739
写这个也是为了自己更好的学习数学专题 1.欧几里德算法 作用：求两个数a和b的最大公约数。 gcd(a,b)=gcd(b,a%b) 我们可以看到,上式是将原来函数的第二个参数放到了第一个参数的位置，然后第二个参数的位置放上 原来的第一个参数%原来第二参数。 高中时学过一个辗转相除法。 我们可以举个例子。 求24和10的最大公约数： 24  ÷ 10  =  2 ……4
poj 1365 Prime Land 唯一分解定理
便纵有千种风情
03-12 720
这个题，一大堆英文烦死了，但是貌似原数必须用long long存，我wa了半天，之前一直以为原数的范围时[3,32767],结果发现这可能是底数的范围。 Prime Land Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 3516   Accepted: 159
CF 553A. Kyoya and Colored Balls 组合数学 和dp有点关系
便纵有千种风情
04-05 674
其实和dp一点关系都没有，如果说有关系，那么就是阶段的选取。 如果以dp的思维考虑问题，首先要确定阶段，这个题肯定不能以正在考虑第几个球为阶段，因为状态存不下去，而且就算这存下去了，也不好算。正确的阶段是颜色，以颜色从小到大的顺序解题。 A. Kyoya and Colored Balls time limit per test 2 second
hdu 5389 Zero Escape DP+数学规律 给出证明 2015 Multi-University Training Contest 8
便纵有千种风情
08-16 608
Zero Escape Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 1008    Accepted Submission(s): 504 Problem Description Zero Escape,
hdu 5894 hannnnah_j’s Biological Test 排列组合
便纵有千种风情
09-18 588
题目题意：现在 m个考生人需要坐在有n个座位的圆桌上。你需要安排位置，使得任意两个考生之间相距至少k个位置。桌子有编号，考生a和b交换位置视作一种方案，问有多少方案，mod 1e9+7。(0 < m < n < 1e6, 0 < k < 1000)解法：首先必须有n>=m+k*m，否则答案是0。现在先考虑m个人的相对关系(即不考虑座位编号和人对应，先只考虑人与人间的间隔，即位置分配)， 先在n个
HDU 1438 钥匙计数之一 递推+组合 简洁的做法
便纵有千种风情
08-05 549
钥匙计数之一 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 1662    Accepted Submission(s): 723 Problem Description 一把锁匙有N个槽，槽深为1，2，3，4。
uva 861 Little Bishops 组合数学 (布棋)
便纵有千种风情
07-02 525
题意：给出n*n大小的棋盘，黑白两色相间，要在其中放m个相，问使之互不攻击的方案种数。 = ∑(白格子放k个,并且黑格子放m-k个的种数) 分别考虑黑白格子，对于棋盘进行变形，使得不能在斜角位置的条件 变为 不能在同行同列。 白格子的变形方法是：不考虑黑格子，将剩下的白格子顺时针旋转45度，然后压缩。(使得图形变为倒置的Ferres图像)。
uva 11538 - Chess Queen 先分步还是先分类？ 计数问题
便纵有千种风情
08-29 514
题目链接： https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2533 计数问题可以先考虑分类，也可以先考虑分步，采取不同方式后续处理也会不同。 那道题目我想到的是先分布（*），大致是先排组合（选位置）  ，后排列（ ）
UVA - 11582 Colossal Fibonacci Numbers! 巨大的斐波拉契数 鸽笼原理+模运算
便纵有千种风情
03-23 513
输入unsigned long long 型 a,b 和 不超过1000 的正整数n ，输出 f(a^b)%n，f()代表斐波那契数。 f(0)=0, f(1)=1 。 解： 因为f(i)=f(i-1)+f(i-2), 所以如果有   f(x-1)==f(i-1)&&f(x)==f(i) 且x！=i ，那么势必会出现循环。 n很小，在[1,n^2+2
A - LOOPS HDU - 3853
最新发布
07-28
回答: 引用\[1\]和引用\[2\]是关于解决HDU - 3853问题的AC代码。这段代码使用了动态规划的思路，通过计算每个点的期望能量来解决问题。其中，f\[i\]\[j\]表示走到(i, j)这个点的期望能量。代码中还有一些特殊情况的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值