2401: 陶陶的难题I

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 89  Solved: 24
[Submit][Status]

Description

最近陶陶在研究数论，某天他偶然遇到一道题：对于给定的正整数���，求出
下面这样一个式子的值：

其中LCM(a���, b���)表示正整数���和���最小公倍数，即能同时被a���和b���整除的最小正
整数。
作为神犇的陶陶，当然轻松秒杀了这道题。不过他希望你写一个程序，用来
检验他算的答案是否正确。

Input

第一行包含一个正整数���T，表示有T���组测试数据。接下来���T<=10^5
行，每行给出一个正整数N,N<=10^6。

Output

包含T���行，依次给出对应的答案。

Sample Input

7
1
10
100
1000
10000
100000
1000000

Sample Output

1
2127
18446224
183011304660
1827127167830060
18269345553999897648
182690854273058293758232

　　 最开始试图通过一种很逗逼的做法弄这道题，其实也A的程序复杂度完全相同，都是一个调和计数的O(nlogn)，但是由于我最开始的方法for语句内高精度加要多算那么一两次，所以就稳稳地被卡常数了，而且这个常数致使我删掉了300+的高精度模板，改用一个pair表示int128。

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<cstring>
  4. #include<algorithm>
  5. #include<string>
  6. using namespace std;
  7. #define MAXN 1000001
  8. typedef long long qword;
  9. int prime[MAXN+],topp=-;
  10. bool pflag[MAXN+];
  11. int phi[MAXN+];
  12. qword maxval=100000000000000000LL;
  13. struct mypair
  14. {
  15.         qword first,second;
  16.         mypair(qword x,qword y):first(x),second(y){};
  17.         mypair(){};
  18.         inline void operator += (mypair& pp)
  19.         {
  20.                 first+=pp.first;
  21.                 second+=pp.second;
  22.                 if (second>=maxval)
  23.                 {
  24.                         first++;
  25.                         second-=maxval;
  26.                 }
  27.         }
  28.         inline void operator -=(mypair& pp)
  29.         {
  30.                 first-=pp.first;
  31.                 second-=pp.second;
  32.                 if (second<)
  33.                 {
  34.                         second+=maxval;
  35.                         first--;
  36.                 }
  37.         }
  38. };
  39. mypair res[MAXN+];
  40. void init()
  41. {
  42.         register int i,j;
  43.         phi[]=;
  44.         for (i=;i<MAXN;i++)
  45.         {
  46.                 if (!pflag[i])
  47.                 {
  48.                         prime[++topp]=i;
  49.                         phi[i]=i-;
  50.                 }
  51.                 for (j=;j<=topp && i*prime[j]<MAXN;j++)
  52.                 {
  53.                         pflag[i*prime[j]]=true;
  54.                         if (i%prime[j]==)
  55.                         {
  56.                                 phi[i*prime[j]]=phi[i]*prime[j];
  57.                                 break;
  58.                         }
  59.                         phi[i*prime[j]]=phi[i]*(prime[j]-);
  60.                 }
  61.         }
  62.         register mypair g,gt,g0;
  63.         g.first=g.second=;;
  64.         for (i=;i<MAXN;i++)res[i].first=,res[i].second=;
  65.         for (i=;i<MAXN;i++)
  66.         {
  67.                 g.first+=(qword)i*i*phi[i]/maxval;
  68.                 g.second+=(qword)i*i*phi[i]%maxval;
  69.                 if (g.second>=maxval)
  70.                 {
  71.                         g.first+=g.second/maxval;
  72.                         g.second%=maxval;
  73.                 }
  74.                 gt.first=gt.second=;g0=g;
  75.                 for (j=;i*j<MAXN;j++)
  76.                 {
  77.                         gt+=g0;
  78.                         res[i*j]+=gt;
  79.                         if (i*j+j<MAXN)
  80.                         {
  81.                                 res[(i+)*j]-=gt;
  82.                         }
  83.                 }
  84.         }
  85.         //for (i=1;i<MAXN;i++)res[i].first-=100000;
  86.         for (i=;i<MAXN;i++)
  87.                 res[i]+=res[i-];
  88. }
  89. int main()
  90. {
  91.         //freopen("input.txt","r",stdin);
  92.         //freopen("b.txt","w",stdout);
  93.         init();
  94.         qword i,j,k,x,y,z,n,m;
  95.         qword nn;
  96.         scanf("%lld",&nn);
  97.         qword ans=;
  98.         while (nn--)
  99.         {
  100.                 scanf("%lld",&n);
  101.                 if (res[n].first)
  102.                         printf("%lld%017lld\n",res[n].first,res[n].second);
  103.                 else
  104.                         printf("%lld\n",res[n].second);
  105.         }
  106. }

TLE

　　换了一种方法，联想lcmsum的做法，通过与n互质数的和为n*phi[n]/2这个公式可以很轻松推出正解，但是还是非常慢，至少还是可以A掉吧。

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<cstring>
  4. #include<algorithm>
  5. #include<string>
  6. using namespace std;
  7. #define MAXN 1000001
  8. typedef unsigned long long qword;
  9. int prime[MAXN+],topp=-;
  10. bool pflag[MAXN+];
  11. int phi[MAXN+];
  12. qword maxval=100000000000000000LLU;
  13. struct mypair
  14. {
  15.         qword first,second;
  16.         mypair(qword x,qword y):first(x),second(y){};
  17.         mypair(){};
  18.         inline void operator += (mypair& pp)
  19.         {
  20.                 first+=pp.first;
  21.                 second+=pp.second;
  22.                 if (second>=maxval)
  23.                 {
  24.                         first++;
  25.                         second-=maxval;
  26.                 }
  27.         }
  28.         inline void operator -=(mypair& pp)
  29.         {
  30.                 first-=pp.first;
  31.                 second-=pp.second;
  32.                 if (second<)
  33.                 {
  34.                         second+=maxval;
  35.                         first--;
  36.                 }
  37.         }
  38. };
  39. mypair res[MAXN+];
  40. void init()
  41. {
  42.         register int i,j;
  43.         phi[]=;
  44.         for (i=;i<MAXN;i++)
  45.         {
  46.                 if (!pflag[i])
  47.                 {
  48.                         prime[++topp]=i;
  49.                         phi[i]=i-;
  50.                 }
  51.                 for (j=;j<=topp && i*prime[j]<MAXN;j++)
  52.                 {
  53.                         pflag[i*prime[j]]=true;
  54.                         if (i%prime[j]==)
  55.                         {
  56.                                 phi[i*prime[j]]=phi[i]*prime[j];
  57.                                 break;
  58.                         }
  59.                         phi[i*prime[j]]=phi[i]*(prime[j]-);
  60.                 }
  61.         }
  62.         for (i=;i<MAXN;i++)
  63.         {
  64.                 register qword x=(qword)phi[i]*i/;
  65.                 if (i==)x=;
  66.                 for (j=i;j<MAXN;j+=i)
  67.                 {
  68.                         res[j].second+=x*j;
  69.                         if (res[j].second>=maxval)
  70.                         {
  71.                                 res[j].first+=res[j].second/maxval;
  72.                                 res[j].second%=maxval;
  73.                         }
  74.                 }
  75.         }
  76.         for (i=;i<MAXN;i++)
  77.         {
  78.                 res[i].first*=,res[i].second*=;
  79.                 res[i].second-=i;
  80.                 if (res[i].second>=maxval)
  81.                 {
  82.                         res[i].second-=maxval;
  83.                         res[i].first++;
  84.                 }
  85.                 if (res[i].second<)
  86.                 {
  87.                         res[i].second+=maxval;
  88.                         res[i].first--;
  89.                 }
  90.                 res[i]+=res[i-];
  91.         }
  92.         return ;
  93.         /*
  94.         register mypair g,gt,g0;
  95.         g.first=g.second=0;;
  96.         for (i=1;i<MAXN;i++)res[i].first=0,res[i].second=0;
  97.         for (i=1;i<MAXN;i++)
  98.         {
  99.                 g.second+=(qword)i*i*phi[i];
  100.                 if (g.second>=maxval)
  101.                 {
  102.                         g.first+=g.second/maxval;
  103.                         g.second%=maxval;
  104.                 }
  105.                 gt.first=gt.second=0;g0=g;
  106.                 for (j=1;i*j<MAXN;j++)
  107.                 {
  108.                         gt+=g0;
  109.                         res[i*j]+=gt;
  110.                         if (i*j+j<MAXN)
  111.                         {
  112.                                 res[(i+1)*j]-=gt;
  113.                         }
  114.                 }
  115.         }
  116.         for (i=2;i<MAXN;i++)
  117.                 res[i]+=res[i-1];*/
  118. }
  119. int main()
  120. {
  121.         //freopen("input.txt","r",stdin);
  122.         //freopen("b.txt","w",stdout);
  123.         init();
  124.         qword i,j,k,x,y,z,n,m;
  125.         qword nn;
  126.         scanf("%lld",&nn);
  127.         qword ans=;
  128.         while (nn--)
  129.         {
  130.                 scanf("%lld",&n);
  131.                 if (res[n].first)
  132.                         printf("%llu%017llu\n",res[n].first,res[n].second);
  133.                 else
  134.                         printf("%llu\n",res[n].second);
  135.         }
  136. }

bzoj 2401: 陶陶的难题I 数论的更多相关文章

  1. BZOJ 3672[NOI2014]购票（树链剖分+线段树维护凸包+斜率优化） + BZOJ 2402 陶陶的难题II （树链剖分+线段树维护凸包+分数规划+斜率优化）

    前言 刚开始看着两道题感觉头皮发麻,后来看看题解,发现挺好理解,只是代码有点长. BZOJ 3672[NOI2014]购票 中文题面,题意略: BZOJ 3672[NOI2014]购票 设f(i)f( ...

  2. bzoj 2402: 陶陶的难题II 二分答案维护凸包

    2402: 陶陶的难题II Time Limit: 40 Sec  Memory Limit: 128 MBSec  Special JudgeSubmit: 68  Solved: 45[Submi ...

  3. [BZOJ2402]陶陶的难题II(树链剖分+线段树维护凸包+分数规划)

    陶陶的难题II 时间限制:40s      空间限制:128MB 题目描述 输入格式 第一行包含一个正整数N,表示树中结点的个数. 第二行包含N个正实数,第i个数表示xi (1<=xi<= ...

  4. 【BZOJ2401】陶陶的难题I 欧拉函数+线性筛

    [BZOJ2401]陶陶的难题I 题意:求,n<=1000000,T<=100000 题解:直接做是n*sqrt(n)的,显然会TLE,不过这题a和b都是循环到n,那么就可以进行如下的神奇 ...

  5. P1676陶陶吃苹果 - vijos

    描述 curimit知道陶陶很喜欢吃苹果.于是curimit准备在陶陶生日的时候送给他一棵苹果树. curimit准备了一棵这样的苹果树作为生日礼物:这棵苹果树有n个节点,每个节点上有c[i]个苹果, ...

  6. 武汉科技大学ACM：1007: 陶陶摘苹果

    Problem Description 厘米高的板凳,当她不能直接用手摘到苹果的时候,就会踩到板凳上再试试. 个苹果到地面的高度,以及陶陶把手伸直的时候能够达到的最大高度,请帮陶陶算一下她能够摘到的苹 ...

  7. 洛谷-陶陶摘苹果（升级版）-BOSS战-入门综合练习1

    题目描述 Description 又是一年秋季时,陶陶家的苹果树结了n个果子.陶陶又跑去摘苹果,这次她有一个a公分的椅子.当他手够不着时,他会站到椅子上再试试. 这次与NOIp2005普及组第一题不同 ...

  8. NOIP2005-普及组复赛-第一题-陶陶摘苹果

    题目描述 Description 陶陶家的院子里有一棵苹果树,每到秋天树上就会结出10个苹果.苹果成熟的时候,陶陶就会跑去摘苹果.陶陶有个30厘米高的板凳,当她不能直接用手摘到苹果的时候,就会踩到板凳 ...

  9. noip普及组2005 陶陶摘苹果

    陶陶摘苹果 描述 陶陶家的院子里有一棵苹果树,每到秋天树上就会结出10个苹果.苹果成熟的时候,陶陶就会跑去摘苹果.陶陶有个30厘米高的板凳,当她不能直接用手摘到苹果的时候,就会踩到板凳上再试试. 现在 ...

随机推荐

  1. 谓词(NSPredicate)

    OC中的谓词操作是针对于数组类型的,他就好比数据库中的查询操作,数据源就是数组,这样的好处是我们不需要编写很多代码就可以去操作数组,同时也起到过滤的作用,我们可以编写简单的谓词语句,就可以从数组中过滤 ...

  2. Nexus搭建Maven服务器

    参考:http://blog.csdn.net/ichsonx/article/details/14642897 1. 为什么使用Nexus 如果没有私服,我们所需的所有构件都需要通过maven的中央 ...

  3. Java8特性---关于Null

    为了防止无良网站的爬虫抓取文章,特此标识,转载请注明文章出处.LaplaceDemon/SJQ. http://www.cnblogs.com/shijiaqi1066/p/5713941.html ...

  4. css定义多重背景动画

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <style typ ...

  5. Extjs combobox设置默认值

    转载:http://www.54mask.com/extjs-combobox-default-value.html 相信很多人都遇到了在ExtJS框架中设置combo组件默认值的需求,ExtJS框架 ...

  6. 序列化之Parcelable

    序列化主要是用来传递类的信息,一般java有提供serializable类,这个类用的较多,不过在android上面似乎效率不高,于是google开发了针对性的优化的接口,parcelable接口. ...

  7. Gerrit 删除项目

    今天手滑把一个Gerrit上的项目epa写成了epp,想找个重命名的地方也找不到...到网络上搜索了下,发现都是改数据库的,然后就进入的数据库: $ ssh -p 29418 10.27.149.22 ...

  8. .NET笔记系列：LAMBDA表达式常用写法

    这里主要是将数据库中的常用操作用LAMBDA表达式重新表示了下,用法不多,但相对较常用,等有时间了还会扩展,并将查询语句及LINQ到时也一并重新整理下: 1.select语句:books.Select ...

  9. Solr4.7新建core

    Solr里面的core就像数据库里面的一个表,用来管理索引和相关配置. 一. 使用示例core 下载的solr完整包里面solr-4.7.0\example\multicore这个文件夹下面有2个示例 ...

  10. IOS_视图实现圆角效果的三种方法及比较

    通过代码,至少有三种方法可以为视图加上圆角效果.附例子:https://github.com/weipin/RoundedCorner 方法一.layer.cornerRadius 第一种方法最简单, ...