HDU 1250 很麻烦的题（大数相加）

Description

A Fibonacci sequence is calculated by adding the previous two members the sequence, with the first two members being both 1.
F(1) = 1, F(2) = 1, F(3) = 1,F(4) = 1, F(n>4) = F(n - 1) + F(n-2) + F(n-3) + F(n-4)
Your task is to take a number as input, and print that Fibonacci number.

Input

Each line will contain an integers. Process to end of file.

Output

For each case, output the result in a line.

Sample Input

100
Sample Output
4203968145672990846840663646

Note:

No generated Fibonacci number in excess of 2005 digits will be in the test data, ie. F(20) = 66526 has 5 digits.

在打比赛的时候这道题没做出来，赛后去博客找了下题解，发现有两类方法，第二种代码更短，但是第二种方法的输出%08d当时没看懂是什么意思，于是就按第一种方法补了下题解，后来同学给我说了下我才理解了第二种方法，思路其实一样的，都是定义一个二维数组，我将二维数组定义成v[n][m],那么n代表是第n个斐波那契数，后面的m存的是这个斐波那契数的值，我将两种方法都讲解一下吧

第一种

这种方法较第二种方法麻烦一些代码更多，定义了个二维数组v，比如v[m][2010]，m是第m个斐波那契数，后面的2010是存的这个斐波那契数的值，是从2010开始存的，然后依次往前存，v[m][2010]存的是第m个斐波那契数的个位，v[m][2009]存的是第m个斐波那契数的十位，然后依次往前，最后到v[m][5],因为最多2005位，从2010到5是2005位，然后输出的话是从前面开始判断，判断v[m][5]这个位数是否为0然后依次往前直到判断出不等于0,假如判断到v[m][n]不为0了，然后结束判断，表示v[m][n]表示的值的这一位是最大位，然后依次输出就行了

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
using namespace std;
char v[10000][2015];
int main()
{
    memset(v,0,sizeof(v));
    v[1][2010]=1,v[2][2010]=1,v[3][2010]=1,v[4][2010]=1;
    int j=2010,i=5;
    while(v[i-1][5]<=1)
    {
        for(int a=2010;a>=j;a--)
        {
            v[i][a]=v[i-1][a]+v[i-2][a]+v[i-3][a]+v[i-4][a];
        }
        for(int a=2010;a>=j;a--)
        {
            int l=v[i][a]/10;
            if(l>0)
            {
                v[i][a]=v[i][a]%10;
                v[i][a-1]=v[i][a-1]+l;
            }

        }
        if(v[i][j-1]>0)
        {
            j--;
        }
        i++;
    }
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int k;
        for(int a=0;a<=2010;a++)
        {
            if(v[n][a]+'0'!='0')
            {
                k=a;
                break;
            }
        }
        for(int a=k;a<=2010;a++)
        {
            printf("%c",v[n][a]+'0');
        }
        printf("\n");
    }
    return 0;
}

第二种

这种方法代码更少，和第一种方法的思路一样，不一样的是数组存的位数不一样，第一种v[m][2010]存的位数是个位，就1个位数，但是第二种方法 v[m][1]存放的是前8位数，斐波那契数的值超过8位数后才能进位到第二个数组v[m][2]，比如200000001,存放到数组中是 v [m][1]=00000001
v[m][2]=2
然后输出的话就是倒着输出先输出2，但是每个数组存放的是8位，你如果输出直接输出v[m][1]的话答案就是21，明显是错误的，应该输出%08d,把0补出来，这样输出后就是200000001，还有就是最高位输出应该是%d，剩余的位输出是%08d

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
using namespace std;
int v[10000][300];
int main()
{
    v[1][1]=1,v[2][1]=1,v[3][1]=1,v[4][1]=1;
    for(int i=5;i<10000;i++)
    {
        for(int j=1;j<300;j++)
        {
            v[i][j]+=v[i-1][j]+v[i-2][j]+v[i-3][j]+v[i-4][j];
            int l=v[i][j]/100000000;
            v[i][j]%=100000000;
            if(l>0)
            {
                v[i][j+1]+=l;
            }
        }
    }
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int j=300;
        while(v[n][j]==0)
        {
            j--;
        }
        printf("%d",v[n][j--]);
        for(int a=j;a>=1;a--)
        {
            printf("%08d",v[n][a]);
        }
        printf("\n");
    }
    return 0;
}