纪中21日T3 2118. 最大公约数

(File IO): input:gcd.in output:gcd.out

时间限制: 1000 ms  空间限制: 262144 KB  具体限制

Goto ProblemSet

题目描述

给出两个正整数A，B，求它们的最大公约数。

输入

第一行一个正整数A。
第二行一个正整数B。

输出

在第一行输出一个整数，表示A，B的最大公约数。

样例输入

  1. 18
    24 

样例输出

  1. 6 

数据范围限制

在40%的数据中，1 ≤ A，B ≤ 10^6
在60%的数据中，1 ≤ A，B ≤ 10^18
在80%的数据中，1 ≤ A，B ≤ 10^100
在100%的数据中，1 ≤ A，B ≤ 10^1000

Solution

Algorithm1

正常的gcd（a，b）=gcd（b，a%b）；

开unsigned long long可得六十分（应该不会超时）

Code1

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstdio>
  4. #include<cstring>
  5. #include<cmath>
  6. #include<map>
  7. #include<set>
  8. #include<queue>
  9. #include<vector>
  10. #define IL inline
  11. using namespace std;
  12. unsigned long long gcd(unsigned long long a,unsigned long long b)
  13. {
  14.     return b==?a:gcd(b,a%b);
  15. }
  16. unsigned long long a,b;
  17. int main()
  18. {
  19.     cin>>a>>b;
  20.     cout<<gcd(a,b);
  21.      return ;
  22. }

Attention1

函数也要开ULL（缩写）

别把“%”写成“-”，否则在相减前要先使得a>b

而且那样就变成更相减损法了

Algorithm2

gcd二进制法

先看看a，b是不是2的倍数

如果都是，gcd（a，b）=2*gcd（a/2，b/2）；

如果a是，gcd（a，b）=gcd（a/2，b）；

如果b是，gcd（a，b）=gcd（a，b/2）；

如果都不是，gcd（a，b）=gcd（b，a%b）

最后一条=gcd（b，a-b）也可以

（为后面的高精度做铺垫）

Code2

  1.  #include<iostream>
  2.  #include<iomanip>
  3.  #include<algorithm>
  4.  #include<cstdio>
  5.  #include<cstring>
  6.  #include<cmath>
  7.  #include<map>
  8.  #include<set>
  9.  #include<queue>
  10.  #include<vector>
  11.  #define IL inline
  12.  using namespace std;
  13.  IL unsigned long long gcdbin(unsigned long long a,unsigned long long b)
  14.  {
  15.      if(!b) return a;
  16.      if(!(a|)&&!(b|)) return *gcdbin(a>>,b>>);
  17.      if(!(a|)&&(b&)) return gcdbin(a>>,b);
  18.      if((a&)&&!(b|)) return gcdbin(a,b>>);
  19.      return gcdbin(b,a%b);
  20.  }
  21.  unsigned long long a,b;
  22.  int main()
  23.  {
  24.      freopen("rand_gcd.txt","r",stdin);
  25.      cin>>a>>b;
  26.      cout<<gcdbin(a,b);
  27.       return ;
  28.  }

Code2

Algorithm3

不压位的高精度

高精度求余数很麻烦（按位求会比较快）

套用更相减损法

同时特判：如果a，b小于19位，依然采用二进制的辗转相除。

Code3

  1. 在GMOJ上……

Code3

由于是普通的更相减损，一旦数位超过20使用高精，速度就会很慢很慢很慢……

60分~80分不等

Algorithm4

高精压位

核心算法与Algorithm3相同

Code4

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstdio>
  4. #include<cstring>
  5. #include<cmath>
  6. #include<map>
  7. #include<set>
  8. #include<queue>
  9. #include<vector>
  10. #define IL inline
  11. using namespace std;
  12. const int L=;
  13. int a[L],b[L],t[L];
  14. int times=;
  15. string stra,strb;
  16. bool fail;
  17. IL bool cmp()
  18. {
  19.     for(int i=L-;i>=;i--)
  20.     {
  21.         if(a[i]>b[i]) return ;
  22.         if(a[i]<b[i]) return ;
  23.     }
  24.     return ;
  25. }
  26. IL void minus()
  27. {
  28.  
  29. }
  30. IL void diva()
  31. {
  32.     for(int i=L-;i>=;i--)
  33.     {
  34.         if(a[i]&) a[i-]+=;
  35.         a[i]>>=;
  36.     }
  37. }
  38. IL void divb()
  39. {
  40.     for(int i=L-;i>=;i--)
  41.     {
  42.         if(b[i]&) b[i-]+=;
  43.         b[i]>>=;
  44.     }
  45. }
  46. IL void div2()
  47. {
  48.     diva();
  49.     divb();
  50. }
  51. int main()
  52. {
  53. //    freopen("gcd.in","r",stdin);
  54. //    freopen("gcd.out","w",srdout);
  55.     cin>>stra>>strb;
  56.     for(unsigned int i=;i<stra.size();i++)
  57.         a[i]=stra[stra.size()-i-];
  58.     for(unsigned int i=;i<strb.size();i++)
  59.         b[i]=strb[strb.size()-i-];
  60.     do{
  61.         if(!(a[]|)&&!(b[]|)){
  62.             times*=;
  63.             div2();
  64.             continue;
  65.         }
  66.         if(!(a[]|)&&(b[]&))
  67.         {
  68.             diva();
  69.             continue;
  70.         }
  71.         if((a&)&&!(b|))
  72.         {
  73.             divb();
  74.             continue;
  75.         }
  76.  
  77.         fail=;
  78.         for(int i=;i<L;i++)
  79.         {
  80.             if(a[i]&&b[i])//会不会出现0与非0交错出现呢？概率是(1/10)^L吧……
  81.             {
  82.                 fail=;
  83.                 break;
  84.             }
  85.         }
  86.     }while(fail);
  87.     bool zeroa;//为了避免交换，不能确定那个是0
  88.     for(int i=;i<L;i++)
  89.     {
  90.         if(a[i]){
  91.             zeroa=;
  92.             break;
  93.         }
  94.         if(b[i]){
  95.             zeroa=;
  96.             break;
  97.         }
  98.     }
  99.     bool flag=;
  100.     if(zeroa)
  101.     for(int i=;i<L;i++)
  102.     {
  103.         a[i]*=times;
  104.         a[i+]+=(a[i]>>)+(a[i]>>);
  105.         a[i]%=;
  106.     }
  107.     else
  108.     for(int i=;i<L;i++)
  109.     {
  110.         b[i]*=times;
  111.         b[i+]+=(b[i]>>)+(b[i]>>);
  112.         b[i]%=;
  113.     }
  114.     if(zeroa)
  115.     for(int i=L-;i>=;i--)
  116.     {
  117.         if(a[i]) flag=;
  118.         if(flag) cout<<a[i];
  119.     }
  120.     else
  121.     for(int i=L-;i>=;i--)
  122.     {
  123.         if(b[i]) flag=;
  124.         if(flag) cout<<b[i];
  125.     }
  126.  
  127.      return ;
  128. }

Code4

Algorithm5

通过下面（最下面）的对拍发现，四种算法中，二进更相比普通更相更快（不是只有0.3毫秒么？）

高精（可以不压位）二进制更相减损术也不是很难打（而且判断也很快）

Algorithm6

之前是苦于没有时间打高精，终于在今天（2019-11-05 现在是00:17:29），我无意中点开了这篇题解，将我的高精度（甚至都没有压位）的模板稍作修改后边送上了“断头台”……

哈哈哈！

惊到我了！

Code6

由于是模板，所以代码较长。

  1.  #include<iostream>
  2.  #include<cstring>
  3.  #include<cstdio>
  4.  #include<cmath>
  5.  using namespace std;
  6.  
  7.  bool insigma(char ch){
  8.      return ch=='-'||(''<=ch&&ch<='');
  9.  }
  10.  
  11.  const int maxn = ;
  12.  struct number{
  13.      int num[maxn];
  14.      int len;
  15.      bool fu;
  16.  
  17.      number(){//初始化
  18.          len=fu=;
  19.          memset(num,,sizeof(num));
  20.      }
  21.  
  22.      int updata_len(){//更新长度
  23.          for(int i=maxn-;i>=;i--) if(num[i]) return len=i+;
  24.          return len=;
  25.      }
  26.  
  27.      //    /*
  28.      number operator= (int x){//隐式转换
  29.          fu=(x<);
  30.          num[]=abs(x);
  31.          if(x>) carry_bit();
  32.          if(x<-) back_space();
  33.          return *this;
  34.      }
  35.  //    */
  36.      /*
  37.      number (int x){//有bug的构造函数 暂时用重载=替代
  38.          fu=(x<0);
  39.          num[0]=abs(x);
  40.          if(x>9) carry_bit();
  41.          if(x<-9) back_space();
  42.      }
  43.      */
  44.  
  45.      void input(){
  46.  //        /*
  47.          string a;
  48.          cin>>a;
  49.          if(a[]=='-'){
  50.              fu=;
  51.              len=a.size()-;
  52.              for(unsigned int i=;i<a.size()-;i++) num[i]=a[a.size()-i-]-'';
  53.          }
  54.          else{
  55.              len=a.size();
  56.              for(unsigned int i=;i<a.size();i++)    num[i]=a[a.size()-i-]-'';
  57.          }
  58.  
  59.  //        */
  60.          /*
  61.          len=0;
  62.          char ch;
  63.          while(!insigma(ch=getchar()));
  64.          if(ch=='-')
  65.              fu=true;
  66.          else
  67.              num[len++]=ch-'0';
  68.          while(isdigit(ch=getchar())){
  69.              num[len++]=ch-'0';
  70.          }
  71.          int t;
  72.          for(int i=0;i<len;i++)
  73.          {
  74.              t=num[i];
  75.              num[i]=num[len-i-1];
  76.              num[len-i-1]=t;
  77.          }
  78.          */
  79.      }
  80.  
  81.      void output(){
  82.          if(fu) cout<<"-";
  83.          bool flag=;
  84.          for(int i=len;i>;i--){
  85.              if(num[i]) flag=;
  86.              if(num[i]>) carry_bit();
  87.              if(flag) putchar(num[i]+'');//putchar加速
  88.          }
  89.          putchar(num[]+'');
  90.      }
  91.  
  92.      friend istream & operator>> (istream &in, number &obj);
  93.      friend ostream & operator<< (ostream &out, number &obj);
  94.  
  95.      int compare(number x){//2=    1> 0<
  96.          if(fu^x.fu){
  97.              if(fu) return ;
  98.              else return ;
  99.          }
  100.          for(int i=max(len,x.len);i>=;i--)
  101.          {
  102.              if(num[i]>x.num[i]) return !fu;//大于 (1)
  103.              if(num[i]<x.num[i]) return fu;//小于 (0)
  104.          }
  105.          return ;//相等
  106.      }
  107.  
  108.      //利用compare()重载比较运算符 
  109.  
  110.      bool operator> (number x){
  111.          return (compare(x)==);
  112.      } 
  113.  
  114.      bool operator< (number x){
  115.          return (compare(x)==);
  116.      }
  117.  
  118.      bool operator>= (number x){
  119.          return !(*this<x);
  120.      }
  121.  
  122.      bool operator<= (number x){
  123.          return !(*this>x);
  124.      }
  125.  
  126.      bool operator== (number x){
  127.          return compare(x)==;
  128.      }
  129.  
  130.      bool operator!= (number x){
  131.          return compare(x)!=;
  132.      }
  133.  
  134.      number operator++ (){
  135.          num[]++;
  136.          if(num[]>) carry_bit();
  137.          return *this;
  138.      }
  139.  
  140.      number operator++ (int){
  141.          number save=*this;
  142.          ++*this;
  143.          return save;
  144.      }
  145.  
  146.      number operator-- (){
  147.          num[]--;
  148.          if(num[]<) back_space();
  149.          return *this;
  150.      }
  151.  
  152.      number operator-- (int){
  153.          number save=*this;
  154.          num[]--;
  155.          if(num[]<) back_space();
  156.          return save;
  157.      }
  158.  
  159.      bool judge_zero(){
  160.          for(int i=maxn-;i>=;i--)
  161.              if(num[i]) return ;
  162.          return ;
  163.      }
  164.  
  165.      bool judge_non_zero(){
  166.          return !judge_zero();
  167.      }
  168.  
  169.      bool convert_bool(){
  170.          return !judge_zero();
  171.      }
  172.  
  173.      bool even(){
  174.          if(num[]%) return ;
  175.          return ;
  176.      }
  177.  
  178.      bool odd(){
  179.          if(num[]%) return ;
  180.          return ;
  181.      }
  182.  
  183.      void carry_bit(){
  184.          for(int i=;i<maxn;i++){
  185.              num[i+]+=num[i]/;
  186.              num[i]%=;
  187.          }
  188.          updata_len();
  189.      }
  190.  
  191.      void back_space(){
  192.          for(int i=;i<maxn;i++){
  193.              while(num[i]<) num[i]+=,num[i+]--;
  194.          }
  195.      }
  196.  
  197.      number operator+ (int x){
  198.          number newness=*this;
  199.          newness.num[]+=x;
  200.          if(newness.num[]>) newness.carry_bit();
  201.          return newness;
  202.      }
  203.  
  204.      number operator+ (number x){
  205.          number res=x;
  206.          for(int i=;i<maxn;i++)
  207.          {
  208.              res.num[i]+=num[i];
  209.          }
  210.          res.carry_bit();
  211.          return res;
  212.      }
  213.  
  214.      number operator+= (int x){
  215.          *this=(*this+x);
  216.          return *this;
  217.      }
  218.  
  219.      number operator+= (number x){
  220.          *this=*this+x;
  221.          return *this;
  222.      }
  223.  
  224.      number operator- (number x){
  225.          number i,j;
  226.          if(compare(x)) {i=*this,j=x;}
  227.          else {i=x,j=*this;}
  228.          for(int t=;t<maxn;t++)
  229.          {
  230.              i.num[t]-=j.num[t];
  231.          }
  232.          i.back_space();
  233.          return i;
  234.      }
  235.  
  236.      number operator-= (number x){
  237.          *this=*this-x;
  238.          return *this;
  239.      }
  240.  
  241.      number operator* (number x){
  242.          number sum;
  243.          sum.fu=fu^x.fu;
  244.          for(int i=;i<updata_len();i++)
  245.          for(int j=;j<x.updata_len();j++)
  246.          {
  247.              if(i+j>maxn-) continue;
  248.              sum.num[i+j]+=num[i]*x.num[j];
  249.          }
  250.          sum.carry_bit();
  251.          return sum;
  252.      }
  253.  
  254.      number operator*= (number x){
  255.          return *this=*this*x;
  256.      }
  257.  
  258.      number factor(){
  259.          number ans,t;
  260.          t.num[]=;
  261.          ans.num[]=;
  262.          for(;t<=*this;t.num[]+=,t.carry_bit())
  263.              ans*=t;
  264.          return ans;
  265.      }
  266.  
  267.      number division2(){
  268.          for(int i=maxn-;i>=;i--){
  269.              if(num[i]&&&i!=) num[i-]+=;
  270.              num[i]>>=;
  271.          }
  272.          return *this;
  273.      }
  274.  };
  275.  
  276.  istream & operator>> (istream &in, number &obj)
  277.  {
  278.      string a;
  279.      in>>a;
  280.      if(a[]=='-'){
  281.          obj.fu=;
  282.          obj.len=a.size()-;
  283.          for(unsigned int i=;i<a.size()-;i++) obj.num[i]=a[a.size()-i-]-'';
  284.      }
  285.      else{
  286.          obj.len=a.size();
  287.          for(unsigned int i=;i<a.size();i++) obj.num[i]=a[a.size()-i-]-'';
  288.      }
  289.      if (!in) obj = number();
  290.      return in;
  291.  }
  292.  
  293.  ostream & operator<< (ostream &out, number &obj)
  294.  {
  295.      if(obj.fu) cout<<"-";
  296.          bool flag=;
  297.          for(int i=obj.len;i>;i--){
  298.              if(obj.num[i]) flag=;
  299.              if(obj.num[i]>) obj.carry_bit();
  300.              if(flag) out<<obj.num[i];
  301.          }
  302.          out<<obj.num[];
  303.      return out;
  304.  }
  305.  
  306.  number gcd_rec(number a,number b){
  307.      if(b.judge_zero()) return a;
  308.      return gcd_rec(b,a-b);
  309.  }
  310.  
  311.  number gcd(number a,number b){
  312.      if(a.judge_zero()) return a;
  313.      number t;
  314.      for(;;t=b,b=a-b,a=t)
  315.          if(b.judge_zero()) return a;
  316.      return a;
  317.  }
  318.  
  319.  number power(number a,number n){
  320.      number zero;
  321.      number c;c=;
  322.      for(;n>zero;n.division2(),a*=a) if(n.odd()) c*=a;
  323.      return c;
  324.  }
  325.  
  326.  int main()
  327.  {
  328.      freopen("gcd.in","r",stdin);
  329.      freopen("gcd.out","w",stdout);
  330.      number a,b,c;
  331.      cin>>a>>b;
  332.      c=gcd(a,b);
  333.      cout<<c;
  334.      return ;
  335.  }

Impression

如果你有兴趣……

  1. #pragma GCC optimize(2)
  2. #include<iostream>
  3. #include<algorithm>
  4. #include<cstdio>
  5. #include<cstring>
  6. #include<cmath>
  7. #include<map>
  8. #include<set>
  9. #include<queue>
  10. #include<vector>
  11. #define IL inline
  12. using namespace std;
  13. unsigned long long gcd(unsigned long long a,unsigned long long b)
  14. {
  15.     return b==?a:gcd(b,a%b);
  16. }
  17. unsigned long long a,b;
  18. int main()
  19. {
  20.     freopen("rand_gcd.txt","r",stdin);
  21.     cin>>a>>b;
  22.     cout<<gcd(a,b);
  23.      return ;
  24. }

gcd.cpp

  1. #pragma GCC optimize(2)
  2. #include<iostream>
  3. #include<algorithm>
  4. #include<cstdio>
  5. #include<cstring>
  6. #include<cmath>
  7. #include<map>
  8. #include<set>
  9. #include<queue>
  10. #include<vector>
  11. #define IL inline
  12. using namespace std;
  13. unsigned long long gx(unsigned long long a,unsigned long long b)
  14. {
  15.     if(a<b) swap(a,b);
  16.     return b==?a:gx(b,a-b);
  17. }
  18. unsigned long long a,b;
  19. int main()
  20. {
  21.     freopen("rand_gcd.txt","r",stdin);
  22.     cin>>a>>b;
  23.     cout<<gx(a,b);
  24.      return ;
  25. }

gx.cpp

  1. #pragma GCC optimize(2)
  2. #include<iostream>
  3. #include<iomanip>
  4. #include<algorithm>
  5. #include<cstdio>
  6. #include<cstring>
  7. #include<cmath>
  8. #include<map>
  9. #include<set>
  10. #include<queue>
  11. #include<vector>
  12. #define IL inline
  13. using namespace std;
  14. IL unsigned long long gcdbin(unsigned long long a,unsigned long long b)
  15. {
  16.     if(!b) return a;
  17.     if(!(a|)&&!(b|)) return *gcdbin(a>>,b>>);
  18.     if(!(a|)&&(b&)) return gcdbin(a>>,b);
  19.     if((a&)&&!(b|)) return gcdbin(a,b>>);
  20.     return gcdbin(b,a%b);
  21. }
  22. unsigned long long a,b;
  23. int main()
  24. {
  25.     freopen("rand_gcd.txt","r",stdin);
  26.     cin>>a>>b;
  27.     cout<<gcdbin(a,b);
  28.      return ;
  29. }

gcdbin

  1. #pragma GCC optimize(2)
  2. #include<iostream>
  3. #include<iomanip>
  4. #include<algorithm>
  5. #include<cstdio>
  6. #include<cstring>
  7. #include<cmath>
  8. #include<map>
  9. #include<set>
  10. #include<queue>
  11. #include<vector>
  12. #define IL inline
  13. using namespace std;
  14. IL unsigned long long gxbin(unsigned long long a,unsigned long long b)
  15. {
  16.     if(!b) return a;
  17.     if(!(a|)&&!(b|)) return *gxbin(a>>,b>>);
  18.     if(!(a|)&&(b&)) return gxbin(a>>,b);
  19.     if((a&)&&!(b|)) return gxbin(a,b>>);
  20.     if(a<b) swap(a,b);
  21.     return gxbin(b,a%b);
  22. }
  23. unsigned long long a,b;
  24. int main()
  25. {
  26.     freopen("rand_gcd.txt","r",stdin);
  27.     cin>>a>>b;
  28.     cout<<gxbin(a,b);
  29.      return ;
  30. }

gxbin.cpp

  1. #pragma GCC optimize(2)
  2. #include<iostream>
  3. #include<algorithm>
  4. #include<cstdio>
  5. #include<cstring>
  6. #include<cmath>
  7. #include<map>
  8. #include<set>
  9. #include<queue>
  10. #include<vector>
  11. #include<windows.h>
  12. #include<ctime>
  13. #define IL inline
  14. using namespace std;
  15. int main()
  16. {
  17.     freopen("rand_gcd.txt","w",stdout);
  18.     srand(time(NULL));
  19.     cout<<(unsigned long long)rand()*rand()*rand()<<endl;
  20.     cout<<(unsigned long long)rand()*rand()*rand()<<endl;
  21.      return ;
  22. }

rand_gcd.cpp

  1. #pragma GCC optimize(2)
  2. #include<iostream>
  3. #include<algorithm>
  4. #include<cstdio>
  5. #include<cstring>
  6. #include<cmath>
  7. #include<map>
  8. #include<set>
  9. #include<queue>
  10. #include<vector>
  11. #include<ctime>
  12. #define IL inline
  13. using namespace std;
  14. int avg[];
  15. int times;
  16. int main()
  17. {
  18.     system("random_gcd.exe");
  19.     int s1=clock();
  20.     system("gcd.exe");
  21.     int s2=clock();
  22.     system("gcdbin.exe");
  23.     int s3=clock();
  24.     system("gx.exe");
  25.     int s4=clock();
  26.     system("gxbin.exe");
  27.     int e=clock();
  28. //    cout<<"\n辗转相除："<<s2-s1<<"ms\n";
  29. //    cout<<"二进辗转："<<s3-s2<<"ms\n";
  30. //    cout<<"更相减损："<<s4-s3<<"ms\n";
  31. //    cout<<"二进更相："<<e-s4<<"ms\n";
  32.     avg[]+=s2-s1;
  33.     avg[]+=s3-s2;
  34.     avg[]+=s4-s3;
  35.     avg[]+=e-s4;
  36.     times++;
  37.     if(times>=)
  38.     {
  39.         system("cls");
  40.         cout<<"总计"<<times<<"组数据\n";
  41.         cout<<"平均用时：\n";
  42.         cout<<"辗转相除："<<avg[]/(times*1.0)<<"ms\n";
  43.         cout<<"二进辗转："<<avg[]/(times*1.0)<<"ms\n";
  44.         cout<<"更相减损："<<avg[]/(times*1.0)<<"ms\n";
  45.         cout<<"二进更相："<<avg[]/(times*1.0)<<"ms\n";
  46.         return ;
  47.     }
  48.     main();
  49.      return ;
  50. }

gcd对拍.cpp

1000组数据运算结果如下

End

纪中21日T3 2118. 【2016-12-30普及组模拟】最大公约数的更多相关文章

  1. 洛谷P1880 [NOI1995]石子合并 纪中21日c组T4 2119. 【2016-12-30普及组模拟】环状石子归并

    洛谷P1880 石子合并 纪中2119. 环状石子归并 洛谷传送门 题目描述1 在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆,并将新的一堆的石 ...

  2. 纪中21日c组模拟赛

    AWSL  AWSL  AWSL  AWSL AWSL  AWSL  AWSL  AWSL AWSL  AWSL  AWSL  AWSL AWSL  AWSL  AWSL  AWSL 题解传送 T1  ...

  3. 纪中21日c组T1 1575. 二叉树

    1575. 二叉树 (File IO): input:tree.in output:tree.out 时间限制: 1000 ms  空间限制: 262144 KB  具体限制   Goto Probl ...

  4. 纪中10日T3 2296. 神殿 bfs

    2296. 神殿 (File IO): input:temple.in output:temple.out 时间限制: 1500 ms  空间限制: 524288 KB  具体限制 Goto Prob ...

  5. 纪中21日c组T2 2117. 【2016-12-30普及组模拟】台风

    2117. 台风 (File IO): input:storm.in output:storm.out 时间限制: 1000 ms  空间限制: 262144 KB  具体限制 Goto Proble ...

  6. 纪中5日T3 1566. 幸运锁(lucky.pas/c/cpp)

    1566. 幸运锁(lucky.pas/c/cpp) 题目描述 有一把幸运锁,打开它将会给你带来好运,但开锁时需要输入一个正整数(没有前导0).幸运锁有一种运算,对于一个正整数,返回他的相邻两位数字间 ...

  7. 纪中17日T1 2321. 方程

    纪中17日T1 2321. 方程 (File IO): input:cti.in output:cti.out 时间限制: 1000 ms  空间限制: 262144 KB  具体限制   Goto ...

  8. 纪中10日T1 2313. 动态仙人掌

    纪中10日 2313. 动态仙人掌 (File IO): input:dinosaur.in output:dinosaur.out 时间限制: 1500 ms  空间限制: 524288 KB  具 ...

  9. 纪中23日c组T3 2161. 【2017.7.11普及】围攻 斐波那契数列

    2161. 围攻 (File IO): input:siege.in output:siege.out 时间限制: 1000 ms  空间限制: 262144 KB  具体限制   Goto Prob ...

随机推荐

  1. node + multer存储element-ui上传的图片

    说明 element-ui的Upload组件可以帮助我们上传我们的图片到我们的服务器,可以使用action参数上传图片,也可以使用http-request自定义上传方式.这里我们使用自定义的方式上传. ...

  2. python+selenium爬取百度文库不能下载的word文档

    有些时候我们需要用到百度文库的某些文章时,却发现需要会员才能下载,很难受,其实我们可以通过爬虫的方式来获取到我们所需要的文本. 工具:python3.7+selenium+任意一款编辑器 前期准备:可 ...

  3. c和c++中读取数据的方式总结

    目录 c 输出 printf() 输入 scanf getchar(), putchar() gets(), puts() c++ 输入 cin() getline() get() 输出 cout 最 ...

  4. 如何更改Jframe里Jpanel的大小

    先贴代码: package xiya; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; ...

  5. vs2012 编译 zlib 1.2.8

    1. 下载     http://zlib.net/zlib-1.2.8.tar.gz 2. 编译     - 解压到目录,如d:\library     - 开启VS2012的Command Pro ...

  6. Go语言实现：【剑指offer】正则表达式匹配

    该题目来源于牛客网<剑指offer>专题. 请实现一个函数用来匹配包括 . 和 * 的正则表达式.模式中的字符.表示任意一个字符,而 * 表示它前面的字符可以出现任意次(包含0次). 在本 ...

  7. 异步并发利器：实际项目中使用CompletionService提升系统性能的一次实践

    场景 随着互联网应用的深入,很多传统行业也都需要接入到互联网.我们公司也是这样,保险核心需要和很多保险中介对接,比如阿里.京东等等.这些公司对于接口服务的性能有些比较高的要求,传统的核心无法满足要求, ...

  8. Apache 相关 mod_rewrite ,RewriteCond,{HTTP_HOST}

    1．给子域名加www标记  RewriteCond %{HTTP_HOST} ^([a-z.]+)?example\.com$ [NC] RewriteCond %{HTTP_HOST} !^www\ ...

  9. Doug Hennig的自定义 DataEnvironment 和 CursorAdapter 类文件 -- SFDataClasses

    Doug Hennig的自定义 DataEnvironment 和 CursorAdapter 类文件 -- SFDataClasses.vcx,其中包括:SFCursorAdapter 和 SFDa ...

  10. Sparc V8

    Sparc V8指令 在sparc V8手册中p83(Table A-1 Mapping of Synthetic Instructions to SPARC Instructions)有合成指令sy ...