Bestcoder #54(hdu 5427&5428&5429&5430)

hdu 5427 简单的排序。取后四位作为年份，按照年份由大到小排序，输出时注意不要把中间的空格输出就ok。

#include <iostream>#include <string>#include <cstring>#include <algorithm>using namespace std;struct node{    string age;    int year;}N[200];bool comp(node a,node b){    return a.year>b.year;}int main(){    int T,n;    string s;    cin>>T;    while(T--)    {        cin>>n;        getchar();        for(int j=0;j<n;j++)        {         getline(cin,s);         int cur=0,k=1000;         for(int i=s.length()-4;i<s.length();i++)         {            cur+=(s[i]-'0')*k;            k/=10;        }        N[j].age=s.substr(0,s.length()-5);        N[j].year=cur;        }                sort(N,N+n,comp);        for(int i=0;i<n;i++)        cout<<N[i].age<<endl;    }    return 0;    } 

hdu 5428：

质因数分解，然后取所有中的最小的两个的乘积，注意结果可能会爆int，要使用long long。

一个数一定会有质因数（除了1），一个数可以分解成多个质因数的乘积，例如12=2*2*3,。

求n的质因数的方法：

法一。因为质因数顾名思义，即是质数也是因数，那么我们可以从2-sqrt(n)+1,求出其中的质数，然后以此判断能否被n整除。也可以从2-(sqrt(n)+1,循环判断i能否被n整除，在判断是否是质数。第一种方法比第二种快。

最简单的方法是下面这种，求x的质因数，保存在数组a中。原理是，质因数中肯定从2开始，先求出最小的质因数first，然后在另一个质因数，n/=first,就相当于再求这个数的最小质因数，从first开始，一直都是这个循环过程。

        cin>>x;        for(int j=2;j<=sqrt(x);j++){            while(x%j==0){                a[num++]=j;                    x/=j;            }        }        if(x>1)a[num++]=x;

下面是这道题的代码：

#include <cstdio>#include <iostream>#include <string>#include <cstring>#include <algorithm>#include <cmath>using namespace std;int vis[1000008];int num[200];int tot;void fget(int m){for(int i=2;i*i<=m;i++)           {                 while(m%i==0)  {                 vis[++tot]=i;                 m=m/i;    }         } if(m>1)vis[++tot]=m;  }int main(){int T,n;cin>>T;while(T--){scanf("%d",&n);//memset(vis,0,sizeof(vis));tot=0;for(int i=0;i<n;i++){   scanf("%d",&num[i]);            fget(num[i]);}if(tot<2){    cout<<-1<<endl;   continue;}    sort(vis+1,vis+tot+1);    printf("%I64d\n",(long long)vis[2]*vis[1]);}return 0;} 

hdu 5429：

等比数列判定+大数，注意输入全是整数。

这时，我们不能忘记等比数列的一个等价式，即s[i-1]*s[i+1]==s[i]*[i]

当然，一些边界值需要另外判断，例如项数n<3的，和数列中存在0的

比如说数列 0 0 0 0 是等比数列，它的公比可以是除0以外的任何实数

但是 1 0 0 0 又不是等比数列，因为公比不可以为0

因此，在判断存在0的数列时，只需判断是不是数列中所有的元素都为0即可

先来java版本。

/** Problem: HDU No.5429* Running time: 380MS* Complier: JAVA* Author: javaherongwei* Create Time: 17:05 2015/9/6 星期日*/import java.util.*;import java.io.*;import java.math.*;public class Main {    public static void main(String args[])    {      Scanner cin=new Scanner(new BufferedInputStream(System.in));      int t=cin.nextInt();      BigInteger fac[]= new BigInteger[105];      BigInteger f1,f2;      while(t-->0)      {          int n=cin.nextInt();          int sum=0;          for(int i=0; i<n; ++i)          {              fac[i]=cin.nextBigInteger();              if(fac[i].compareTo(BigInteger.ZERO)==0) sum++;          }          if(sum!=0)          {              if(sum==n) System.out.println("Yes");              else System.out.println("No");              continue;          }          int ok=0;          for(int i=1; i<n-1; ++i)          {               if(fac[i-1].multiply(fac[i+1]).compareTo(fac[i].multiply(fac[i]))!=0)               {                       ok=1;                       break;               }          }          if(ok==1) System.out.println("No");          else System.out.println("Yes");      }    }}

接下来是好用的C++大数版

#include <iostream>#include <cstring>using namespace std;#define DIGIT   4      //四位隔开,即万进制#define DEPTH   10000        //万进制#define MAX     251    //题目最大位数/4，要不大直接设为最大位数也行typedef int bignum_t[MAX+1];/************************************************************************//* 读取操作数，对操作数进行处理存储在数组里                             *//************************************************************************/int read(bignum_t a,istream&is=cin){    char buf[MAX*DIGIT+1],ch ;    int i,j ;    memset((void*)a,0,sizeof(bignum_t));    if(!(is>>buf))return 0 ;    for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)    ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;    for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');    for(i=1;i<=a[0];i++)    for(a[i]=0,j=0;j<DIGIT;j++)    a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;    for(;!a[a[0]]&&a[0]>1;a[0]--);    return 1 ;}void write(const bignum_t a,ostream&os=cout){    int i,j ;    for(os<<a[i=a[0]],i--;i;i--)    for(j=DEPTH/10;j;j/=10)    os<<a[i]/j%10 ;}int comp(const bignum_t a,const bignum_t b){    int i ;    if(a[0]!=b[0])    return a[0]-b[0];    for(i=a[0];i;i--)    if(a[i]!=b[i])    return a[i]-b[i];    return 0 ;}int comp(const bignum_t a,const int b){    int c[12]=    {        1    }    ;    for(c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);    return comp(a,c);}int comp(const bignum_t a,const int c,const int d,const bignum_t b){    int i,t=0,O=-DEPTH*2 ;    if(b[0]-a[0]<d&&c)    return 1 ;    for(i=b[0];i>d;i--)    {        t=t*DEPTH+a[i-d]*c-b[i];        if(t>0)return 1 ;        if(t<O)return 0 ;    }    for(i=d;i;i--)    {        t=t*DEPTH-b[i];        if(t>0)return 1 ;        if(t<O)return 0 ;    }    return t>0 ;}/************************************************************************//* 大数与大数相加                                                       *//************************************************************************/void add(bignum_t a,const bignum_t b){    int i ;    for(i=1;i<=b[0];i++)    if((a[i]+=b[i])>=DEPTH)    a[i]-=DEPTH,a[i+1]++;    if(b[0]>=a[0])    a[0]=b[0];    else    for(;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);    a[0]+=(a[a[0]+1]>0);}/************************************************************************//* 大数与小数相加                                                       *//************************************************************************/void add(bignum_t a,const int b){    int i=1 ;    for(a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);    for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);}/************************************************************************//* 大数相减(被减数>=减数)                                               *//************************************************************************/void sub(bignum_t a,const bignum_t b){    int i ;    for(i=1;i<=b[0];i++)    if((a[i]-=b[i])<0)    a[i+1]--,a[i]+=DEPTH ;    for(;a[i]<0;a[i]+=DEPTH,i++,a[i]--);    for(;!a[a[0]]&&a[0]>1;a[0]--);}/************************************************************************//* 大数减去小数(被减数>=减数)                                           *//************************************************************************/void sub(bignum_t a,const int b){    int i=1 ;    for(a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);    for(;!a[a[0]]&&a[0]>1;a[0]--);}void sub(bignum_t a,const bignum_t b,const int c,const int d){    int i,O=b[0]+d ;    for(i=1+d;i<=O;i++)    if((a[i]-=b[i-d]*c)<0)    a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH ;    for(;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);    for(;!a[a[0]]&&a[0]>1;a[0]--);}/************************************************************************//* 大数相乘，读入被乘数a，乘数b，结果保存在c[]                          *//************************************************************************/void mul(bignum_t c,const bignum_t a,const bignum_t b){    int i,j ;    memset((void*)c,0,sizeof(bignum_t));    for(c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)    for(j=1;j<=b[0];j++)    if((c[i+j-1]+=a[i]*b[j])>=DEPTH)    c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH ;    for(c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);}/************************************************************************//* 大数乘以小数，读入被乘数a，乘数b，结果保存在被乘数                   *//************************************************************************/void mul(bignum_t a,const int b){    int i ;    for(a[1]*=b,i=2;i<=a[0];i++)    {        a[i]*=b ;        if(a[i-1]>=DEPTH)        a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH ;    }    for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);    for(;!a[a[0]]&&a[0]>1;a[0]--);}void mul(bignum_t b,const bignum_t a,const int c,const int d){    int i ;    memset((void*)b,0,sizeof(bignum_t));    for(b[0]=a[0]+d,i=d+1;i<=b[0];i++)    if((b[i]+=a[i-d]*c)>=DEPTH)    b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH ;    for(;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);    for(;!b[b[0]]&&b[0]>1;b[0]--);}/**************************************************************************//* 大数相除,读入被除数a，除数b，结果保存在c[]数组                         *//* 需要comp()函数                                                         *//**************************************************************************/void div(bignum_t c,bignum_t a,const bignum_t b){    int h,l,m,i ;    memset((void*)c,0,sizeof(bignum_t));    c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1 ;    for(i=c[0];i;sub(a,b,c[i]=m,i-1),i--)    for(h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)    if(comp(b,m,i-1,a))h=m-1 ;    else l=m ;    for(;!c[c[0]]&&c[0]>1;c[0]--);    c[0]=c[0]>1?c[0]:1 ;}void div(bignum_t a,const int b,int&c){    int i ;    for(c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);    for(;!a[a[0]]&&a[0]>1;a[0]--);}/************************************************************************//* 大数平方根，读入大数a，结果保存在b[]数组里                           *//* 需要comp()函数                                                       *//************************************************************************/void sqrt(bignum_t b,bignum_t a){    int h,l,m,i ;    memset((void*)b,0,sizeof(bignum_t));    for(i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)    for(h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)    if(comp(b,m,i-1,a))h=m-1 ;    else l=m ;    for(;!b[b[0]]&&b[0]>1;b[0]--);    for(i=1;i<=b[0];b[i++]>>=1);}/************************************************************************//* 返回大数的长度                                                       *//************************************************************************/int length(const bignum_t a){    int t,ret ;    for(ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);    return ret>0?ret:1 ;}/************************************************************************//* 返回指定位置的数字，从低位开始数到第b位，返回b位上的数               *//************************************************************************/int digit(const bignum_t a,const int b){    int i,ret ;    for(ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);    return ret%10 ;}/************************************************************************//* 返回大数末尾0的个数                                                  *//************************************************************************/int zeronum(const bignum_t a){    int ret,t ;    for(ret=0;!a[ret+1];ret++);    for(t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);    return ret ;}void comp(int*a,const int l,const int h,const int d){    int i,j,t ;    for(i=l;i<=h;i++)    for(t=i,j=2;t>1;j++)    while(!(t%j))    a[j]+=d,t/=j ;}void convert(int*a,const int h,bignum_t b){    int i,j,t=1 ;    memset(b,0,sizeof(bignum_t));    for(b[0]=b[1]=1,i=2;i<=h;i++)    if(a[i])    for(j=a[i];j;t*=i,j--)    if(t*i>DEPTH)    mul(b,t),t=1 ;    mul(b,t);}/************************************************************************//* 组合数                                                               *//************************************************************************/void combination(bignum_t a,int m,int n){    int*t=new int[m+1];    memset((void*)t,0,sizeof(int)*(m+1));    comp(t,n+1,m,1);    comp(t,2,m-n,-1);    convert(t,m,a);    delete[]t ;}/************************************************************************//* 排列数                                                               *//************************************************************************/void permutation(bignum_t a,int m,int n){    int i,t=1 ;    memset(a,0,sizeof(bignum_t));    a[0]=a[1]=1 ;    for(i=m-n+1;i<=m;t*=i++)    if(t*i>DEPTH)    mul(a,t),t=1 ;    mul(a,t);}#define SGN(x) ((x)>0?1:((x)<0?-1:0))#define ABS(x) ((x)>0?(x):-(x))int read(bignum_t a,int&sgn,istream&is=cin){    char str[MAX*DIGIT+2],ch,*buf ;    int i,j ;    memset((void*)a,0,sizeof(bignum_t));    if(!(is>>str))return 0 ;    buf=str,sgn=1 ;    if(*buf=='-')sgn=-1,buf++;    for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)    ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;    for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');    for(i=1;i<=a[0];i++)    for(a[i]=0,j=0;j<DIGIT;j++)    a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;    for(;!a[a[0]]&&a[0]>1;a[0]--);    if(a[0]==1&&!a[1])sgn=0 ;    return 1 ;}struct bignum{    bignum_t num ;    int sgn ;    public :    inline bignum()    {        memset(num,0,sizeof(bignum_t));        num[0]=1 ;        sgn=0 ;    }    inline int operator!()    {        return num[0]==1&&!num[1];    }    inline bignum&operator=(const bignum&a)    {        memcpy(num,a.num,sizeof(bignum_t));        sgn=a.sgn ;        return*this ;    }    inline bignum&operator=(const int a)    {        memset(num,0,sizeof(bignum_t));        num[0]=1 ;        sgn=SGN (a);        add(num,sgn*a);        return*this ;    }    ;    inline bignum&operator+=(const bignum&a)    {        if(sgn==a.sgn)add(num,a.num);        else if        (sgn&&a.sgn)        {            int ret=comp(num,a.num);            if(ret>0)sub(num,a.num);            else if(ret<0)            {                bignum_t t ;                memcpy(t,num,sizeof(bignum_t));                memcpy(num,a.num,sizeof(bignum_t));                sub (num,t);                sgn=a.sgn ;            }            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;        }        else if(!sgn)            memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn ;        return*this ;    }    inline bignum&operator+=(const int a)    {        if(sgn*a>0)add(num,ABS(a));        else if(sgn&&a)        {            int  ret=comp(num,ABS(a));            if(ret>0)sub(num,ABS(a));            else if(ret<0)            {                bignum_t t ;                memcpy(t,num,sizeof(bignum_t));                memset(num,0,sizeof(bignum_t));                num[0]=1 ;                add(num,ABS (a));                sgn=-sgn ;                sub(num,t);            }            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;        }        else if            (!sgn)sgn=SGN(a),add(num,ABS(a));        return*this ;    }    inline bignum operator+(const bignum&a)    {        bignum ret ;        memcpy(ret.num,num,sizeof (bignum_t));        ret.sgn=sgn ;        ret+=a ;        return ret ;    }    inline bignum operator+(const int a)    {        bignum ret ;        memcpy(ret.num,num,sizeof (bignum_t));        ret.sgn=sgn ;        ret+=a ;        return ret ;    }    inline bignum&operator-=(const bignum&a)    {        if(sgn*a.sgn<0)add(num,a.num);        else if        (sgn&&a.sgn)        {            int ret=comp(num,a.num);            if(ret>0)sub(num,a.num);            else if(ret<0)            {                bignum_t t ;                memcpy(t,num,sizeof(bignum_t));                memcpy(num,a.num,sizeof(bignum_t));                sub(num,t);                sgn=-sgn ;            }            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;        }        else if(!sgn)add (num,a.num),sgn=-a.sgn ;        return*this ;    }    inline bignum&operator-=(const int a)    {        if(sgn*a<0)add(num,ABS(a));        else if(sgn&&a)        {            int  ret=comp(num,ABS(a));            if(ret>0)sub(num,ABS(a));            else if(ret<0)            {                bignum_t t ;                memcpy(t,num,sizeof(bignum_t));                memset(num,0,sizeof(bignum_t));                num[0]=1 ;                add(num,ABS(a));                sub(num,t);                sgn=-sgn ;            }            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;        }        else if            (!sgn)sgn=-SGN(a),add(num,ABS(a));        return*this ;    }    inline bignum operator-(const bignum&a)    {        bignum ret ;        memcpy(ret.num,num,sizeof(bignum_t));        ret.sgn=sgn ;        ret-=a ;        return ret ;    }    inline bignum operator-(const int a)    {        bignum ret ;        memcpy(ret.num,num,sizeof(bignum_t));        ret.sgn=sgn ;        ret-=a ;        return ret ;    }    inline bignum&operator*=(const bignum&a)    {        bignum_t t ;        mul(t,num,a.num);        memcpy(num,t,sizeof(bignum_t));        sgn*=a.sgn ;        return*this ;    }    inline bignum&operator*=(const int a)    {        mul(num,ABS(a));        sgn*=SGN(a);        return*this ;    }    inline bignum operator*(const bignum&a)    {        bignum ret ;        mul(ret.num,num,a.num);        ret.sgn=sgn*a.sgn ;        return ret ;    }    inline bignum operator*(const int a)    {        bignum ret ;        memcpy(ret.num,num,sizeof (bignum_t));        mul(ret.num,ABS(a));        ret.sgn=sgn*SGN(a);        return ret ;    }    inline bignum&operator/=(const bignum&a)    {        bignum_t t ;        div(t,num,a.num);        memcpy (num,t,sizeof(bignum_t));        sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn ;        return*this ;    }    inline bignum&operator/=(const int a)    {        int t ;        div(num,ABS(a),t);        sgn=(num[0]==1&&!num [1])?0:sgn*SGN(a);        return*this ;    }    inline bignum operator/(const bignum&a)    {        bignum ret ;        bignum_t t ;        memcpy(t,num,sizeof(bignum_t));        div(ret.num,t,a.num);        ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn ;        return ret ;    }    inline bignum operator/(const int a)    {        bignum ret ;        int t ;        memcpy(ret.num,num,sizeof(bignum_t));        div(ret.num,ABS(a),t);        ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);        return ret ;    }    inline bignum&operator%=(const bignum&a)    {        bignum_t t ;        div(t,num,a.num);        if(num[0]==1&&!num[1])sgn=0 ;        return*this ;    }    inline int operator%=(const int a)    {        int t ;        div(num,ABS(a),t);        memset(num,0,sizeof (bignum_t));        num[0]=1 ;        add(num,t);        return t ;    }    inline bignum operator%(const bignum&a)    {        bignum ret ;        bignum_t t ;        memcpy(ret.num,num,sizeof(bignum_t));        div(t,ret.num,a.num);        ret.sgn=(ret.num[0]==1&&!ret.num [1])?0:sgn ;        return ret ;    }    inline int operator%(const int a)    {        bignum ret ;        int t ;        memcpy(ret.num,num,sizeof(bignum_t));        div(ret.num,ABS(a),t);        memset(ret.num,0,sizeof(bignum_t));        ret.num[0]=1 ;        add(ret.num,t);        return t ;    }    inline bignum&operator++()    {        *this+=1 ;        return*this ;    }    inline bignum&operator--()    {        *this-=1 ;        return*this ;    }    ;    inline int operator>(const bignum&a)    {        return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);    }    inline int operator>(const int a)    {        return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);    }    inline int operator>=(const bignum&a)    {        return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);    }    inline int operator>=(const int a)    {        return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);    }    inline int operator<(const bignum&a)    {        return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);    }    inline int operator<(const int a)    {        return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);    }    inline int operator<=(const bignum&a)    {        return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);    }    inline int operator<=(const int a)    {        return sgn<0?(a<0?comp(num,-a)>=0:1):        (sgn>0?(a>0?comp(num,a)<=0:0):a>=0);    }    inline int operator==(const bignum&a)    {        return(sgn==a.sgn)?!comp(num,a.num):0 ;    }    inline int operator==(const int a)    {        return(sgn*a>=0)?!comp(num,ABS(a)):0 ;    }    inline int operator!=(const bignum&a)    {        return(sgn==a.sgn)?comp(num,a.num):1 ;    }    inline int operator!=(const int a)    {        return(sgn*a>=0)?comp(num,ABS(a)):1 ;    }    inline int operator[](const int a)    {        return digit(num,a);    }    friend inline istream&operator>>(istream&is,bignum&a)    {        read(a.num,a.sgn,is);        return  is ;    }    friend inline ostream&operator<<(ostream&os,const bignum&a)    {        if(a.sgn<0)            os<<'-' ;        write(a.num,os);        return os ;    }    friend inline bignum sqrt(const bignum&a)    {        bignum ret ;        bignum_t t ;        memcpy(t,a.num,sizeof(bignum_t));        sqrt(ret.num,t);        ret.sgn=ret.num[0]!=1||ret.num[1];        return ret ;    }    friend inline bignum sqrt(const bignum&a,bignum&b)    {        bignum ret ;        memcpy(b.num,a.num,sizeof(bignum_t));        sqrt(ret.num,b.num);        ret.sgn=ret.num[0]!=1||ret.num[1];        b.sgn=b.num[0]!=1||ret.num[1];        return ret ;    }    inline int length()    {        return :: length(num);    }    inline int zeronum()    {        return :: zeronum(num);    }    inline bignum C(const int m,const int n)    {        combination(num,m,n);        sgn=1 ;        return*this ;    }    inline bignum P(const int m,const int n)    {        permutation(num,m,n);        sgn=1 ;        return*this ;    }};bignum a[105],zero;int main(){    int i,t,n;    zero=0;    cin>>t;    while(t--)    {        cin>>n;        int cnt=0;        for(i=0;i<n;++i)         {            cin>>a[i];            if(a[i]==zero) ++cnt;        }        if(cnt&&cnt!=n) cout<<"No"<<endl;        else{            for(i=1;i<n-1;++i)                if(a[i]*a[i]!=a[i-1]*a[i+1]) break;            if(i<n-1) cout<<"No"<<endl;            else cout<<"Yes"<<endl;        }    }    return 0 ;}

hdu 5430：

既约分数，即分子分母互质的分数，如果不是既约分数的话相当于同一种反射方案循环多次。源自：UVa12493

#include<cstdio>  #include<iostream>  #include<cstring>  #include<algorithm>  using namespace std;    int gcd(int a,int b)  {      return b==0?a:gcd(b,a%b);  }  int main()  {      int t,n;      scanf("%d",&t);      while(t--)      {          scanf("%d",&n);          int ans=0;          for(int i=1; i<=n; i++)              if(gcd(i,n+1)==1) ans++;          printf("%d\n",ans);      }      return 0;  }