uva 10862 Connect the Cable Wires

原题：
Asif is a student of East West University and he is currently working for the EWUISP to meet his relatively high tuition fees. One day, as a part of his job, he was instructed to connect cable wires to N houses. All the houses lie in a straight line. He wants to use only the minimum number of cable wires required to complete his task such that all the houses receive the cable service. A house can either get the connection from the main transmission center or it can get it from a house to its immediate left or right provided the latter house is already getting the service. You are to write a program that determines the number of different combinations of the cable wires that is possible so that every house receives the service.
Example: If there are two houses then 3 combinations are possible as shown in the figure.

Figure: circles represent the transmission center and the small rectangles represent the houses.
Input
Each line of input contains a positive integer N (N ≤ 2000). The meaning of N is described in the above paragraph. A value of 0 for N indicates the end of input which should not be processed.
Output
For each line of input you have to output, on a single line, the number of possible arrangements. You can safely assume that this number will have less than 1000 digits.
Sample Input
1
2
3
0
Sample Output
1
3
8

中文：
给你一个圈和n个方块，现在要让你把这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[2001];
int main()
{
    ios::sync_with_stdio(false);
    f[1]=1,f[2]=3;
    for(int i=3;i<=2000;i++)
        f[i]=3*f[i-1]-f[i-2];
    int n;
    while(cin>>n,n)
        cout<<f[n]<<endl;
    return 0;
}

解答：

用递推的思想来分析，设i个方块有f(i)种连接方法，考虑第i个方块连接，那么，第i个方块可以连接到左侧的方块上，此时与前面连接好的i-1个方块组合有f(i-1)种可能，如果第i个方块连接到圆上，则左侧的i-1个方块可以有f(i-1)种连接方法，若是第i-1个方块连接到连接到第i个方块上，则左侧有f(i-2）种方法，同样第i-2个方块和第i-1可以连到第i个方块上以此类推
f(i)=f(i)*2+f(i-1)+f(i-2)+f(i-3)+…+f(1)
如果用上面的公式打表会超时
由于f(i-1)=2*f(i-2)+f(i-3)+…+f(1)
代入上面的式子，可以化简成f(i)=3*f(i-1)-f(i-2)
用大数打表过了