zoukankan html css js c++ java

2016"百度之星"

1
3
8

Hint

如果序列是：(111)。可以构造出如下三个新序列：(111), (21), (12)。

仔细写一下，是一个斐波那契数列哦，当然要有大数（存在n==0）不要输出，换行就行！

  1 #include <iostream>
  2 #include <stdio.h>
  3 #include <string.h>
  4 using namespace std;
  5 
  6 
  7 
  8 #define DIGIT   4      //四位隔开,即万进制
  9 #define DEPTH   10000        //万进制
 10 #define MAX     100    //题目最大位数/4，要不大直接设为最大位数也行
 11 typedef int bignum_t[MAX+1];
 12 
 13 /************************************************************************/
 14 /* 读取操作数，对操作数进行处理存储在数组里                             */
 15 /************************************************************************/
 16 int read(bignum_t a,istream&is=cin)
 17 {
 18     char buf[MAX*DIGIT+1],ch ;
 19     int i,j ;
 20     memset((void*)a,0,sizeof(bignum_t));
 21     if(!(is>>buf))return 0 ;
 22     for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
 23         ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;
 24     for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
 25     for(i=1;i<=a[0];i++)
 26         for(a[i]=0,j=0;j<DIGIT;j++)
 27             a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;
 28     for(;!a[a[0]]&&a[0]>1;a[0]--);
 29     return 1 ;
 30 }
 31 
 32 void write(const bignum_t a,ostream&os=cout)
 33 {
 34     int i,j ;
 35     for(os<<a[i=a[0]],i--;i;i--)
 36         for(j=DEPTH/10;j;j/=10)
 37             os<<a[i]/j%10 ;
 38 }
 39 
 40 int comp(const bignum_t a,const bignum_t b)
 41 {
 42     int i ;
 43     if(a[0]!=b[0])
 44         return a[0]-b[0];
 45     for(i=a[0];i;i--)
 46         if(a[i]!=b[i])
 47             return a[i]-b[i];
 48     return 0 ;
 49 }
 50 
 51 int comp(const bignum_t a,const int b)
 52 {
 53     int c[12]=
 54     {
 55     }
 56     ;
 57     for(c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);
 58     return comp(a,c);
 59 }
 60 
 61 int comp(const bignum_t a,const int c,const int d,const bignum_t b)
 62 {
 63     int i,t=0,O=-DEPTH*2 ;
 64     if(b[0]-a[0]<d&&c)
 65         return 1 ;
 66     for(i=b[0];i>d;i--)
 67     {
 68         t=t*DEPTH+a[i-d]*c-b[i];
 69         if(t>0)return 1 ;
 70         if(t<O)return 0 ;
 71     }
 72     for(i=d;i;i--)
 73     {
 74         t=t*DEPTH-b[i];
 75         if(t>0)return 1 ;
 76         if(t<O)return 0 ;
 77     }
 78     return t>0 ;
 79 }
 80 /************************************************************************/
 81 /* 大数与大数相加                                                       */
 82 /************************************************************************/
 83 void add(bignum_t a,const bignum_t b)
 84 {
 85     int i ;
 86     for(i=1;i<=b[0];i++)
 87         if((a[i]+=b[i])>=DEPTH)
 88             a[i]-=DEPTH,a[i+1]++;
 89     if(b[0]>=a[0])
 90         a[0]=b[0];
 91     else
 92         for(;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);
 93     a[0]+=(a[a[0]+1]>0);
 94 }
 95 /************************************************************************/
 96 /* 大数与小数相加                                                       */
 97 /************************************************************************/
 98 void add(bignum_t a,const int b)
 99 {
100     int i=1 ;
101     for(a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);
102     for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
103 }
104 /************************************************************************/
105 /* 大数相减(被减数>=减数)                                               */
106 /************************************************************************/
107 void sub(bignum_t a,const bignum_t b)
108 {
109     int i ;
110     for(i=1;i<=b[0];i++)
111         if((a[i]-=b[i])<0)
112             a[i+1]--,a[i]+=DEPTH ;
113     for(;a[i]<0;a[i]+=DEPTH,i++,a[i]--);
114     for(;!a[a[0]]&&a[0]>1;a[0]--);
115 }
116 /************************************************************************/
117 /* 大数减去小数(被减数>=减数)                                           */
118 /************************************************************************/
119 void sub(bignum_t a,const int b)
120 {
121     int i=1 ;
122     for(a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
123     for(;!a[a[0]]&&a[0]>1;a[0]--);
124 }
125 
126 void sub(bignum_t a,const bignum_t b,const int c,const int d)
127 {
128     int i,O=b[0]+d ;
129     for(i=1+d;i<=O;i++)
130         if((a[i]-=b[i-d]*c)<0)
131             a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH ;
132     for(;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
133     for(;!a[a[0]]&&a[0]>1;a[0]--);
134 }
135 /************************************************************************/
136 /* 大数相乘，读入被乘数a，乘数b，结果保存在c[]                          */
137 /************************************************************************/
138 void mul(bignum_t c,const bignum_t a,const bignum_t b)
139 {
140     int i,j ;
141     memset((void*)c,0,sizeof(bignum_t));
142     for(c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)
143         for(j=1;j<=b[0];j++)
144             if((c[i+j-1]+=a[i]*b[j])>=DEPTH)
145                 c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH ;
146     for(c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);
147 }
148 /************************************************************************/
149 /* 大数乘以小数，读入被乘数a，乘数b，结果保存在被乘数                   */
150 /************************************************************************/
151 void mul(bignum_t a,const int b)
152 {
153     int i ;
154     for(a[1]*=b,i=2;i<=a[0];i++)
155     {
156         a[i]*=b ;
157         if(a[i-1]>=DEPTH)
158             a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH ;
159     }
160     for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
161     for(;!a[a[0]]&&a[0]>1;a[0]--);
162 }
163 
164 void mul(bignum_t b,const bignum_t a,const int c,const int d)
165 {
166     int i ;
167     memset((void*)b,0,sizeof(bignum_t));
168     for(b[0]=a[0]+d,i=d+1;i<=b[0];i++)
169         if((b[i]+=a[i-d]*c)>=DEPTH)
170             b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH ;
171     for(;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);
172     for(;!b[b[0]]&&b[0]>1;b[0]--);
173 }
174 /**************************************************************************/
175 /* 大数相除,读入被除数a，除数b，结果保存在c[]数组                         */
176 /* 需要comp()函数                                                         */
177 /**************************************************************************/
178 void div(bignum_t c,bignum_t a,const bignum_t b)
179 {
180     int h,l,m,i ;
181     memset((void*)c,0,sizeof(bignum_t));
182     c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1 ;
183     for(i=c[0];i;sub(a,b,c[i]=m,i-1),i--)
184         for(h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)
185             if(comp(b,m,i-1,a))h=m-1 ;
186             else l=m ;
187     for(;!c[c[0]]&&c[0]>1;c[0]--);
188     c[0]=c[0]>1?c[0]:1 ;
189 }
190 
191 void div(bignum_t a,const int b,int&c)
192 {
193     int i ;
194     for(c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);
195     for(;!a[a[0]]&&a[0]>1;a[0]--);
196 }
197 /************************************************************************/
198 /* 大数平方根，读入大数a，结果保存在b[]数组里                           */
199 /* 需要comp()函数                                                       */
200 /************************************************************************/
201 void sqrt(bignum_t b,bignum_t a)
202 {
203     int h,l,m,i ;
204     memset((void*)b,0,sizeof(bignum_t));
205     for(i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)
206         for(h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)
207             if(comp(b,m,i-1,a))h=m-1 ;
208             else l=m ;
209     for(;!b[b[0]]&&b[0]>1;b[0]--);
210     for(i=1;i<=b[0];b[i++]>>=1);
211 }
212 /************************************************************************/
213 /* 返回大数的长度                                                       */
214 /************************************************************************/
215 int length(const bignum_t a)
216 {
217     int t,ret ;
218     for(ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);
219     return ret>0?ret:1 ;
220 }
221 /************************************************************************/
222 /* 返回指定位置的数字，从低位开始数到第b位，返回b位上的数               */
223 /************************************************************************/
224 int digit(const bignum_t a,const int b)
225 {
226     int i,ret ;
227     for(ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);
228     return ret%10 ;
229 }
230 /************************************************************************/
231 /* 返回大数末尾0的个数                                                  */
232 /************************************************************************/
233 int zeronum(const bignum_t a)
234 {
235     int ret,t ;
236     for(ret=0;!a[ret+1];ret++);
237     for(t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);
238     return ret ;
239 }
240 
241 void comp(int*a,const int l,const int h,const int d)
242 {
243     int i,j,t ;
244     for(i=l;i<=h;i++)
245         for(t=i,j=2;t>1;j++)
246             while(!(t%j))
247                 a[j]+=d,t/=j ;
248 }
249 
250 void convert(int*a,const int h,bignum_t b)
251 {
252     int i,j,t=1 ;
253     memset(b,0,sizeof(bignum_t));
254     for(b[0]=b[1]=1,i=2;i<=h;i++)
255         if(a[i])
256             for(j=a[i];j;t*=i,j--)
257                 if(t*i>DEPTH)
258                     mul(b,t),t=1 ;
259     mul(b,t);
260 }
261 /************************************************************************/
262 /* 组合数                                                               */
263 /************************************************************************/
264 void combination(bignum_t a,int m,int n)
265 {
266     int*t=new int[m+1];
267     memset((void*)t,0,sizeof(int)*(m+1));
268     comp(t,n+1,m,1);
269     comp(t,2,m-n,-1);
270     convert(t,m,a);
271     delete[]t ;
272 }
273 /************************************************************************/
274 /* 排列数                                                               */
275 /************************************************************************/
276 void permutation(bignum_t a,int m,int n)
277 {
278     int i,t=1 ;
279     memset(a,0,sizeof(bignum_t));
280     a[0]=a[1]=1 ;
281     for(i=m-n+1;i<=m;t*=i++)
282         if(t*i>DEPTH)
283             mul(a,t),t=1 ;
284     mul(a,t);
285 }
286 
287 #define SGN(x) ((x)>0?1:((x)<0?-1:0))
288 #define ABS(x) ((x)>0?(x):-(x))
289 
290 int read(bignum_t a,int&sgn,istream&is=cin)
291 {
292     char str[MAX*DIGIT+2],ch,*buf ;
293     int i,j ;
294     memset((void*)a,0,sizeof(bignum_t));
295     if(!(is>>str))return 0 ;
296     buf=str,sgn=1 ;
297     if(*buf=='-')sgn=-1,buf++;
298     for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
299         ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;
300     for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
301     for(i=1;i<=a[0];i++)
302         for(a[i]=0,j=0;j<DIGIT;j++)
303             a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;
304     for(;!a[a[0]]&&a[0]>1;a[0]--);
305     if(a[0]==1&&!a[1])sgn=0 ;
306     return 1 ;
307 }
308 struct bignum
309 {
310     bignum_t num ;
311     int sgn ;
312     public :
313     inline bignum()
314     {
315         memset(num,0,sizeof(bignum_t));
316         num[0]=1 ;
317         sgn=0 ;
318     }
319     inline int operator!()
320     {
321         return num[0]==1&&!num[1];
322     }
323     inline bignum&operator=(const bignum&a)
324     {
325         memcpy(num,a.num,sizeof(bignum_t));
326         sgn=a.sgn ;
327         return*this ;
328     }
329     inline bignum&operator=(const int a)
330     {
331         memset(num,0,sizeof(bignum_t));
332         num[0]=1 ;
333         sgn=SGN (a);
334         add(num,sgn*a);
335         return*this ;
336     }
337     ;
338     inline bignum&operator+=(const bignum&a)
339     {
340         if(sgn==a.sgn)add(num,a.num);
341         else if
342             (sgn&&a.sgn)
343         {
344             int ret=comp(num,a.num);
345             if(ret>0)sub(num,a.num);
346             else if(ret<0)
347             {
348                 bignum_t t ;
349                 memcpy(t,num,sizeof(bignum_t));
350                 memcpy(num,a.num,sizeof(bignum_t));
351                 sub (num,t);
352                 sgn=a.sgn ;
353             }
354             else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
355         }
356         else if(!sgn)
357             memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn ;
358         return*this ;
359     }
360     inline bignum&operator+=(const int a)
361     {
362         if(sgn*a>0)add(num,ABS(a));
363         else if(sgn&&a)
364         {
365             int  ret=comp(num,ABS(a));
366             if(ret>0)sub(num,ABS(a));
367             else if(ret<0)
368             {
369                 bignum_t t ;
370                 memcpy(t,num,sizeof(bignum_t));
371                 memset(num,0,sizeof(bignum_t));
372                 num[0]=1 ;
373                 add(num,ABS (a));
374                 sgn=-sgn ;
375                 sub(num,t);
376             }
377             else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
378         }
379         else if
380             (!sgn)sgn=SGN(a),add(num,ABS(a));
381         return*this ;
382     }
383     inline bignum operator+(const bignum&a)
384     {
385         bignum ret ;
386         memcpy(ret.num,num,sizeof (bignum_t));
387         ret.sgn=sgn ;
388         ret+=a ;
389         return ret ;
390     }
391     inline bignum operator+(const int a)
392     {
393         bignum ret ;
394         memcpy(ret.num,num,sizeof (bignum_t));
395         ret.sgn=sgn ;
396         ret+=a ;
397         return ret ;
398     }
399     inline bignum&operator-=(const bignum&a)
400     {
401         if(sgn*a.sgn<0)add(num,a.num);
402         else if
403             (sgn&&a.sgn)
404         {
405             int ret=comp(num,a.num);
406             if(ret>0)sub(num,a.num);
407             else if(ret<0)
408             {
409                 bignum_t t ;
410                 memcpy(t,num,sizeof(bignum_t));
411                 memcpy(num,a.num,sizeof(bignum_t));
412                 sub(num,t);
413                 sgn=-sgn ;
414             }
415             else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
416         }
417         else if(!sgn)add (num,a.num),sgn=-a.sgn ;
418         return*this ;
419     }
420     inline bignum&operator-=(const int a)
421     {
422         if(sgn*a<0)add(num,ABS(a));
423         else if(sgn&&a)
424         {
425             int  ret=comp(num,ABS(a));
426             if(ret>0)sub(num,ABS(a));
427             else if(ret<0)
428             {
429                 bignum_t t ;
430                 memcpy(t,num,sizeof(bignum_t));
431                 memset(num,0,sizeof(bignum_t));
432                 num[0]=1 ;
433                 add(num,ABS(a));
434                 sub(num,t);
435                 sgn=-sgn ;
436             }
437             else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
438         }
439         else if
440             (!sgn)sgn=-SGN(a),add(num,ABS(a));
441         return*this ;
442     }
443     inline bignum operator-(const bignum&a)
444     {
445         bignum ret ;
446         memcpy(ret.num,num,sizeof(bignum_t));
447         ret.sgn=sgn ;
448         ret-=a ;
449         return ret ;
450     }
451     inline bignum operator-(const int a)
452     {
453         bignum ret ;
454         memcpy(ret.num,num,sizeof(bignum_t));
455         ret.sgn=sgn ;
456         ret-=a ;
457         return ret ;
458     }
459     inline bignum&operator*=(const bignum&a)
460     {
461         bignum_t t ;
462         mul(t,num,a.num);
463         memcpy(num,t,sizeof(bignum_t));
464         sgn*=a.sgn ;
465         return*this ;
466     }
467     inline bignum&operator*=(const int a)
468     {
469         mul(num,ABS(a));
470         sgn*=SGN(a);
471         return*this ;
472     }
473     inline bignum operator*(const bignum&a)
474     {
475         bignum ret ;
476         mul(ret.num,num,a.num);
477         ret.sgn=sgn*a.sgn ;
478         return ret ;
479     }
480     inline bignum operator*(const int a)
481     {
482         bignum ret ;
483         memcpy(ret.num,num,sizeof (bignum_t));
484         mul(ret.num,ABS(a));
485         ret.sgn=sgn*SGN(a);
486         return ret ;
487     }
488     inline bignum&operator/=(const bignum&a)
489     {
490         bignum_t t ;
491         div(t,num,a.num);
492         memcpy (num,t,sizeof(bignum_t));
493         sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn ;
494         return*this ;
495     }
496     inline bignum&operator/=(const int a)
497     {
498         int t ;
499         div(num,ABS(a),t);
500         sgn=(num[0]==1&&!num [1])?0:sgn*SGN(a);
501         return*this ;
502     }
503     inline bignum operator/(const bignum&a)
504     {
505         bignum ret ;
506         bignum_t t ;
507         memcpy(t,num,sizeof(bignum_t));
508         div(ret.num,t,a.num);
509         ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn ;
510         return ret ;
511     }
512     inline bignum operator/(const int a)
513     {
514         bignum ret ;
515         int t ;
516         memcpy(ret.num,num,sizeof(bignum_t));
517         div(ret.num,ABS(a),t);
518         ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);
519         return ret ;
520     }
521     inline bignum&operator%=(const bignum&a)
522     {
523         bignum_t t ;
524         div(t,num,a.num);
525         if(num[0]==1&&!num[1])sgn=0 ;
526         return*this ;
527     }
528     inline int operator%=(const int a)
529     {
530         int t ;
531         div(num,ABS(a),t);
532         memset(num,0,sizeof (bignum_t));
533         num[0]=1 ;
534         add(num,t);
535         return t ;
536     }
537     inline bignum operator%(const bignum&a)
538     {
539         bignum ret ;
540         bignum_t t ;
541         memcpy(ret.num,num,sizeof(bignum_t));
542         div(t,ret.num,a.num);
543         ret.sgn=(ret.num[0]==1&&!ret.num [1])?0:sgn ;
544         return ret ;
545     }
546     inline int operator%(const int a)
547     {
548         bignum ret ;
549         int t ;
550         memcpy(ret.num,num,sizeof(bignum_t));
551         div(ret.num,ABS(a),t);
552         memset(ret.num,0,sizeof(bignum_t));
553         ret.num[0]=1 ;
554         add(ret.num,t);
555         return t ;
556     }
557     inline bignum&operator++()
558     {
559         *this+=1 ;
560         return*this ;
561     }
562     inline bignum&operator--()
563     {
564         *this-=1 ;
565         return*this ;
566     }
567     ;
568     inline int operator>(const bignum&a)
569     {
570         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);
571     }
572     inline int operator>(const int a)
573     {
574         return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);
575     }
576     inline int operator>=(const bignum&a)
577     {
578         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);
579     }
580     inline int operator>=(const int a)
581     {
582         return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);
583     }
584     inline int operator<(const bignum&a)
585     {
586         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);
587     }
588     inline int operator<(const int a)
589     {
590         return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);
591     }
592     inline int operator<=(const bignum&a)
593     {
594         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);
595     }
596     inline int operator<=(const int a)
597     {
598         return sgn<0?(a<0?comp(num,-a)>=0:1):
599         (sgn>0?(a>0?comp(num,a)<=0:0):a>=0);
600     }
601     inline int operator==(const bignum&a)
602     {
603         return(sgn==a.sgn)?!comp(num,a.num):0 ;
604     }
605     inline int operator==(const int a)
606     {
607         return(sgn*a>=0)?!comp(num,ABS(a)):0 ;
608     }
609     inline int operator!=(const bignum&a)
610     {
611         return(sgn==a.sgn)?comp(num,a.num):1 ;
612     }
613     inline int operator!=(const int a)
614     {
615         return(sgn*a>=0)?comp(num,ABS(a)):1 ;
616     }
617     inline int operator[](const int a)
618     {
619         return digit(num,a);
620     }
621     friend inline istream&operator>>(istream&is,bignum&a)
622     {
623         read(a.num,a.sgn,is);
624         return  is ;
625     }
626     friend inline ostream&operator<<(ostream&os,const bignum&a)
627     {
628         if(a.sgn<0)
629             os<<'-' ;
630         write(a.num,os);
631         return os ;
632     }
633     friend inline bignum sqrt(const bignum&a)
634     {
635         bignum ret ;
636         bignum_t t ;
637         memcpy(t,a.num,sizeof(bignum_t));
638         sqrt(ret.num,t);
639         ret.sgn=ret.num[0]!=1||ret.num[1];
640         return ret ;
641     }
642     friend inline bignum sqrt(const bignum&a,bignum&b)
643     {
644         bignum ret ;
645         memcpy(b.num,a.num,sizeof(bignum_t));
646         sqrt(ret.num,b.num);
647         ret.sgn=ret.num[0]!=1||ret.num[1];
648         b.sgn=b.num[0]!=1||ret.num[1];
649         return ret ;
650     }
651     inline int length()
652     {
653         return :: length(num);
654     }
655     inline int zeronum()
656     {
657         return :: zeronum(num);
658     }
659     inline bignum C(const int m,const int n)
660     {
661         combination(num,m,n);
662         sgn=1 ;
663         return*this ;
664     }
665     inline bignum P(const int m,const int n)
666     {
667         permutation(num,m,n);
668         sgn=1 ;
669         return*this ;
670     }
671 };
672 int main()
673 {
674     bignum a[1000];
675     a[1]=1;
676     a[2]=2;
677     int n;
678     for(int i=3;i<=300;i++)
679     {
680         a[i]=a[i-1]+a[i-2];
681     }
682     while(cin>>n)
683     {
            if(n==0)
            cout<<"
";
            else
684         cout<<a[n]<<endl;
685     }
686     return 0;
687 }

查看全文

相关阅读:
Java8初体验（二）Stream语法详解
 java8的新特性以及用法简介
 HDFS之SequenceFile和MapFile
深入分析Parquet列式存储格式【转】
Flume中的HDFS Sink配置参数说明【转】
采用alluxio提升MR job和Spark job性能的注意点
 spark on alluxio和MR on alluxio测试(改进版)【转】
python入门-分类和回归各种初级算法
 C++函数调用时的参数传递-3中传递方式
 OpenCV颜色空间——HLS颜色空间

原文地址：https://www.cnblogs.com/yinghualuowu/p/5494593.html