HDU 1023 Train Problem II（Catalan + 大数）

• 原题链接：Here！
  
  
• 模板来袭：Here！
  
  
• 分析：此题和 问题3 本质相同，把火车抽象成元素，火车站抽象成栈。
  n个元素的入栈次序和出栈次序构成了一个2n个数字的序列（0~2n-1），因此设n个元素的序列不同出栈序列方式有f(2n)种。
  对于第0个元素，必然是入栈，那么它出栈的操作一定是2i+1（i是数字编号，编号从0开始）。
  把问题划分成 f(i) 和 f(2n-i-2)两个步骤，先完成f(i)，再完成f(2n-i-2)。
  例如
  2n次操作中第0次入栈 第1次出栈，中间间隔0次操作，操作方法为f(0)种，剩余2n-2次操作，2n-2次操作方法为f(2n-2)
  2n次操作中第0次入栈 第3次出栈，中间间隔2次操作，操作方法为f(2)种，剩余2n-4次操作，2n-4次操作方法为f(2n-4)
  ......
  
  转化成递归式f(2n)=f(0)*f(2n-2)+f(2)*f(2n-4)+f(4)*f(2n-6)+...+f(2n-4)*f(2)+f(2n-2)*f(0)。
  初始值f(0)=1，中间没有操作只能是1种情况，先入栈紧接着出栈
  f(2)=1
  f(4)=2
  f(6)=5
  ......
  即f(n)=h(n-1)
  
  
  
• CODE:
  写法1：
  

  #include<iostream>
  #include<cstdio>
  #include<cstring>
  using namespace std;
  #define MAX 100
  #define BASE 10000
  void multiply(int a[],int Max,int b){	// 大数乘法 
  	int array=0;
  	for(int i=Max-1;i>=0;i--){
  		array += b*a[i];
  		a[i] = array%BASE;
  		array /= BASE;
  	}
  }
  void divide(int a[],int Max,int b){		// 大数除法 
  	int div=0;
  	for(int i=0;i<Max;i++){
  		div = div*BASE + a[i];
  		a[i] = div/b;
  		div %= b; 
  	} 
  }
  
  int main(){
  	int a[101][MAX],i,j,n;
  	memset(a[1],0,MAX*sizeof(int));
  	for(i=2 , a[1][MAX-1]=1;i<101;i++){
  		memcpy(a[i],a[i-1],MAX*sizeof(int));	// h[i] =  h[i-1]
  		multiply(a[i],MAX,4*i-2);				// h[i] *= (4*i-2)
  		divide(a[i],MAX,i+1);					// h[i] /= (i+1)
  	}
  	while(cin>>n){
  		for(i=0;i<MAX && a[n][i]==0;i++);		// 去掉数组前为0的数字
  		cout<<a[n][i++];						// 输出第一个非0数
  		for(;i<MAX;i++)
  			printf("%04d",a[n][i]);				//输出后面的数，保持每位5个长度
  		cout<<endl; 
  	}
  	return 0;
  }

  
  写法2：大数类
  

  #include<iostream> 
  #include<cstring>  
  #include<string>   
  #include<iomanip>   
  #include<algorithm>   
  using namespace std;   
    
  #define MAXN 9999  
  #define MAXSIZE 10  
  #define DLEN 4  
    
  class BigNum  
  {   
  private:   
      int a[500];    //可以控制大数的位数   
      int len;       //大数长度  
  public:   
      BigNum(){ len = 1;memset(a,0,sizeof(a)); }   //构造函数  
      BigNum(const int);       //将一个int类型的变量转化为大数  
      BigNum(const char*);     //将一个字符串类型的变量转化为大数  
      BigNum(const BigNum &);  //拷贝构造函数  
      BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算  
    
      friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符  
      friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符  
    
      BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算   
      BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算   
      BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算   
      BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算  
    
      BigNum operator^(const int  &) const;    //大数的n次方运算  
      int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算      
      bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较  
      bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较  
    
      void print();       //输出大数  
  };   
  BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数  
  {   
      int c,d = b;  
      len = 0;  
      memset(a,0,sizeof(a));  
      while(d > MAXN)  
      {  
          c = d - (d / (MAXN + 1)) * (MAXN + 1);   
          d = d / (MAXN + 1);  
          a[len++] = c;  
      }  
      a[len++] = d;  
  }  
  BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数  
  {  
      int t,k,index,l,i;  
      memset(a,0,sizeof(a));  
      l=strlen(s);     
      len=l/DLEN;  
      if(l%DLEN)  
          len++;  
      index=0;  
      for(i=l-1;i>=0;i-=DLEN)  
      {  
          t=0;  
          k=i-DLEN+1;  
          if(k<0)  
              k=0;  
          for(int j=k;j<=i;j++)  
              t=t*10+s[j]-'0';  
          a[index++]=t;  
      }  
  }  
  BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数  
  {   
      int i;   
      memset(a,0,sizeof(a));   
      for(i = 0 ; i < len ; i++)  
          a[i] = T.a[i];   
  }   
  BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算  
  {  
      int i;  
      len = n.len;  
      memset(a,0,sizeof(a));   
      for(i = 0 ; i < len ; i++)   
          a[i] = n.a[i];   
      return *this;   
  }  
  istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符  
  {  
      char ch[MAXSIZE*4];  
      int i = -1;  
      in>>ch;  
      int l=strlen(ch);  
      int count=0,sum=0;  
      for(i=l-1;i>=0;)  
      {  
          sum = 0;  
          int t=1;  
          for(int j=0;j<4&&i>=0;j++,i--,t*=10)  
          {  
              sum+=(ch[i]-'0')*t;  
          }  
          b.a[count]=sum;  
          count++;  
      }  
      b.len =count++;  
      return in;  
    
  }  
  ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符  
  {  
      int i;    
      cout << b.a[b.len - 1];   
      for(i = b.len - 2 ; i >= 0 ; i--)  
      {   
          cout.width(DLEN);   
          cout.fill('0');   
          cout << b.a[i];   
      }   
      return out;  
  }  
    
  BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算  
  {  
      BigNum t(*this);  
      int i,big;      //位数     
      big = T.len > len ? T.len : len;   
      for(i = 0 ; i < big ; i++)   
      {   
          t.a[i] +=T.a[i];   
          if(t.a[i] > MAXN)   
          {   
              t.a[i + 1]++;   
              t.a[i] -=MAXN+1;   
          }   
      }   
      if(t.a[big] != 0)  
          t.len = big + 1;   
      else  
          t.len = big;     
      return t;  
  }  
  BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算   
  {    
      int i,j,big;  
      bool flag;  
      BigNum t1,t2;  
      if(*this>T)  
      {  
          t1=*this;  
          t2=T;  
          flag=0;  
      }  
      else  
      {  
          t1=T;  
          t2=*this;  
          flag=1;  
      }  
      big=t1.len;  
      for(i = 0 ; i < big ; i++)  
      {  
          if(t1.a[i] < t2.a[i])  
          {   
              j = i + 1;   
              while(t1.a[j] == 0)  
                  j++;   
              t1.a[j--]--;   
              while(j > i)  
                  t1.a[j--] += MAXN;  
              t1.a[i] += MAXN + 1 - t2.a[i];   
          }   
          else  
              t1.a[i] -= t2.a[i];  
      }  
      t1.len = big;  
      while(t1.a[t1.len - 1] == 0 && t1.len > 1)  
      {  
          t1.len--;   
          big--;  
      }  
      if(flag)  
          t1.a[big-1]=0-t1.a[big-1];  
      return t1;   
  }   
    
  BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算   
  {   
      BigNum ret;   
      int i,j,up;   
      int temp,temp1;     
      for(i = 0 ; i < len ; i++)  
      {   
          up = 0;   
          for(j = 0 ; j < T.len ; j++)  
          {   
              temp = a[i] * T.a[j] + ret.a[i + j] + up;   
              if(temp > MAXN)  
              {   
                  temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);   
                  up = temp / (MAXN + 1);   
                  ret.a[i + j] = temp1;   
              }   
              else  
              {   
                  up = 0;   
                  ret.a[i + j] = temp;   
              }   
          }   
          if(up != 0)   
              ret.a[i + j] = up;   
      }   
      ret.len = i + j;   
      while(ret.a[ret.len - 1] == 0 && ret.len > 1)  
          ret.len--;   
      return ret;   
  }   
  BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算  
  {   
      BigNum ret;   
      int i,down = 0;     
      for(i = len - 1 ; i >= 0 ; i--)  
      {   
          ret.a[i] = (a[i] + down * (MAXN + 1)) / b;   
          down = a[i] + down * (MAXN + 1) - ret.a[i] * b;   
      }   
      ret.len = len;   
      while(ret.a[ret.len - 1] == 0 && ret.len > 1)  
          ret.len--;   
      return ret;   
  }  
  int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算      
  {  
      int i,d=0;  
      for (i = len-1; i>=0; i--)  
      {  
          d = ((d * (MAXN+1))% b + a[i])% b;    
      }  
      return d;  
  }  
  BigNum BigNum::operator^(const int & n) const    //大数的n次方运算  
  {  
      BigNum t,ret(1);  
      int i;  
      if(n<0)  
          exit(-1);  
      if(n==0)  
          return 1;  
      if(n==1)  
          return *this;  
      int m=n;  
      while(m>1)  
      {  
          t=*this;  
          for( i=1;i<<1<=m;i<<=1)  
          {  
              t=t*t;  
          }  
          m-=i;  
          ret=ret*t;  
          if(m==1)  
              ret=ret*(*this);  
      }  
      return ret;  
  }  
  bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较  
  {   
      int ln;   
      if(len > T.len)  
          return true;   
      else if(len == T.len)  
      {   
          ln = len - 1;   
          while(a[ln] == T.a[ln] && ln >= 0)  
              ln--;   
          if(ln >= 0 && a[ln] > T.a[ln])  
              return true;   
          else  
              return false;   
      }   
      else  
          return false;   
  }  
  bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较  
  {  
      BigNum b(t);  
      return *this>b;  
  }  
    
  void BigNum::print()    //输出大数  
  {   
      int i;     
      cout << a[len - 1];   
      for(i = len - 2 ; i >= 0 ; i--)  
      {   
          cout.width(DLEN);   
          cout.fill('0');   
          cout << a[i];   
      }   
      cout << endl;  
  }  
  int main(){  
      int i,n;  
      BigNum h[101];      //定义大数的对象数组  
      h[0]=1;  
      for(i=1;i<101;i++)  
          h[i]=h[i-1]*(4*i-2)/(i+1);  
      while(scanf("%d",&n)==1 && n!=-1){  
          h[n].print();  
      }  
  }