uva 10334 Ray Through Glasses

原题：
Suppose we put two panes of glass back-to-back. How many ways a n are there for light rays to pass through or be reflected after changing direction n times? Following figure shows the situations when the value of n is 0, 1 and 2.

Input
It is a set of lines with an integer n where 0 ≤ n ≤ 1000 in each of them.
Output
For every one of these integers a line containing a n as described above.
Sample Input
0
1
2
Sample Output
1
2
3

中文：
给你两个玻璃板，一道光线射进来，折射n次的方式有多少种？

#include <bits/stdc++.h>
using namespace std;
const int maxn=1000;/*精度位数*/
/*(必选)类与基础功能定义，用法类似于unsigned(非负)*/
class bign
{
        friend istream& operator>>(istream&,bign&);/*输入运算符友元*/
        friend ostream& operator<<(ostream&,const bign&);/*输出运算符友元*/
        friend bign operator+(const bign&,const bign&);/*加号运算符友元*/
        friend bign operator*(const bign&,const bign&);/*乘号运算符友元*/
        friend bign operator*(const bign&,int);/*高精度乘以低精度乘法友元*/
        friend bign operator-(const bign&,const bign&);/*减号运算符友元*/
        friend bign operator/(const bign&,const bign&);/*除法运算符友元*/
        friend bign operator%(const bign&,const bign&);/*模运算符友元*/
        friend bool operator<(const bign&,const bign&);/*逻辑小于符友元*/
        friend bool operator>(const bign&,const bign&);/*逻辑大于符友元*/
        friend bool operator<=(const bign&,const bign&);/*逻辑小于等于符友元*/
        friend bool operator>=(const bign&,const bign&);/*逻辑大于等于符友元*/
        friend bool operator==(const bign&,const bign&);/*逻辑等符友元*/
        friend bool operator!=(const bign&,const bign&);/*逻辑不等符友元*/
    private:
        int len,s[maxn];
    public:
        bign(){memset(s,0,sizeof(s));len=1;}
        bign operator=(const char* num)
    {
                int i=0,ol;
                ol=len=strlen(num);
                while(num[i++]=='0'&&len>1)
                len--;
                memset(s,0,sizeof(s));
                for(i=0;i<len;i++)
                s[i]=num[ol-i-1]-'0';
                return *this;

    }
        bign operator=(int num)
    {
                char s[maxn];
                sprintf(s,"%d",num);
                *this=s;
                return *this;

    }
        bign(int num){*this=num;}
        bign(const char* num){*this=num;}
        string str() const
    {
                int i;
                string res="";
                for(i=0;i<len;i++)res=char(s[i]+'0')+res;
                if(res=="")res="0";
                return res;

    }

};
/*(可选)基本逻辑运算符重载*/
bool operator<(const bign& a,const bign& b)
{
        int i;
        if(a.len!=b.len)return a.len<b.len;
        for(i=a.len-1;i>=0;i--)
            if(a.s[i]!=b.s[i])
        return a.s[i]<b.s[i];
        return false;

}
bool operator>(const bign& a,const bign& b){return b<a;}
bool operator<=(const bign& a,const bign& b){return !(a>b);}
bool operator>=(const bign& a,const bign& b){return !(a<b);}
bool operator!=(const bign& a,const bign& b){return a<b||a>b;}
bool operator==(const bign& a,const bign& b){return !(a<b||a>b);}
/*(可选)加法运算符重载*/
bign operator+(const bign& a,const bign& b)
{
        int i,max=(a.len>b.len?a.len:b.len),t,c;
        bign sum;
        sum.len=0;
        for(i=0,c=0;c||i<max;i++)
    {
                t=c;
                if(i<a.len)t+=a.s[i];
                if(i<b.len)t+=b.s[i];
                sum.s[sum.len++]=t%10;
                c=t/10;

    }
        return sum;

}
/*(可选)乘法运算符重载(高精度乘高精度)*/
bign operator*(const bign& a,const bign& b)
{
        int i,j;
        bign res;
        for(i=0;i<a.len;i++)
    {
                for(j=0;j<b.len;j++)
        {
                        res.s[i+j]+=(a.s[i]*b.s[j]);
                        res.s[i+j+1]+=res.s[i+j]/10;
                        res.s[i+j]%=10;

        }

    }
        res.len=a.len+b.len;
        while(res.s[res.len-1]==0&&res.len>1)res.len--;
        if(res.s[res.len])res.len++;
        return res;

}
/*高精度乘以低精度(注意:必须是bign*int顺序不能颠倒,要么会与高精度乘高精度发生冲突*/
bign operator*(const bign& a,int b)
{
        int i,t,c=0;
        bign res;
        for(i=0;i<a.len;i++)
    {
                t=a.s[i]*b+c;
                res.s[i]=t%10;
                c=t/10;

    }
        res.len=a.len;
        while(c!=0)
    {
                res.s[i++]=c%10;
                c/=10;
                res.len++;

    }
        return res;

}
/*(可选)减法运算符重载*/
bign operator-(const bign& a,const bign& b)
{
        bign res;
        int i,len=(a.len>b.len)?a.len:b.len;
        for(i=0;i<len;i++)
    {
                res.s[i]+=a.s[i]-b.s[i];
                if(res.s[i]<0)
        {
                        res.s[i]+=10;
                        res.s[i+1]--;

        }

    }
        while(res.s[len-1]==0&&len>1)len--;
        res.len=len;
        return res;

}
/*(可选)除法运算符重载(注意:减法和乘法运算和>=运算符必选)*/
bign operator/(const bign& a,const bign& b)
{
        int i,len=a.len;
        bign res,f;
        for(i=len-1;i>=0;i--)
    {
                f=f*10;
                f.s[0]=a.s[i];
                while(f>=b)
        {
                        f=f-b;
                        res.s[i]++;

        }

    }
        while(res.s[len-1]==0&&len>1)len--;
        res.len=len;
        return res;

}
/*(可选)模运算符重载(注意:减法和乘法运算和>=运算符必选)*/
bign operator%(const bign& a,const bign& b)
{
        int i,len=a.len;
        bign res,f;
        for(i=len-1;i>=0;i--)
    {
                f=f*10;
                f.s[0]=a.s[i];
                while(f>=b)
        {
                        f=f-b;
                        res.s[i]++;

        }

    }
        return f;

}
/*(可选)X等运算符重载(注意:X法必选)*/
bign& operator+=(bign& a,const bign& b)
{
        a=a+b;
        return a;

}
bign& operator-=(bign& a,const bign& b)
{
        a=a-b;
        return a;

}
bign& operator*=(bign& a,const bign& b)
{
        a=a*b;
        return a;

}
bign& operator/=(bign& a,const bign& b)
{
        a=a/b;
        return a;

}
/*可选前缀++/--与后缀++/--(注意:加法必选)*/
bign& operator++(bign& a)
{
        a=a+1;
        return a;

}
bign& operator++(bign& a,int)
{
        bign t=a;
        a=a+1;
        return t;

}
bign& operator--(bign& a)
{
        a=a-1;
        return a;

}
bign& operator--(bign& a,int)
{
        bign t=a;
        a=a-1;
        return t;

}
istream& operator>>(istream &in,bign& x)
{
        string s;
        in>>s;
        x=s.c_str();
        return in;

}
ostream& operator<<(ostream &out,const bign& x)
{
        out<<x.str();
        return out;

}
bign f[1001];
int main()
{
    ios::sync_with_stdio(false);
    f[0]=1;
    f[1]=2;
    for(int i=2;i<=1000;i++)
    f[i]=f[i-1]+f[i-2];
    int n;
    while(cin>>n)
    cout<<f[n]<<endl;
    return 0;
}

解答：

观察地折射i次的反射方式，光线出去要么是从上面出去，要么是从下面出去。如果第i-1次是从上面射出，那么第i次一定是从下面射出，第i-2次是从下面射出。所以，只要把第i-1次的射线，反射一次直接射出，第i-2次的射线折射一次直接射出即可。
f[i]=f[i-1]+f[i-2]