接3
int compare_cata(const cata &x,const cata &y)         //x>y return 1;x<y return 0;x==y return 2;
{
    int len_x=x.length(),len_y=y.length();
    int displace=y.displacement;
    if(len_x>len_y)
    {
        return 1;
    }
    else if(len_x<len_y)
    {
        return 0;
    }
    
    else
    {
        for(int i=len_x-1;i>=0;i--)
        {
            if(x.data[i]!=y.data[i+displace])
            {
                break;
            }
        }
        if(-1==i)
        {
            return 2;
        }
        else
        {
            if(x.data[i]>y.data[i+displace])
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
    }
}///:p

void result(cata &m,cata &n,cata &result_combination,cata &result_catalan)           //出结果函数
{
    int cp;
    cata temp_1(1),temp_2(1),temp_1_1;
    temp_1.data[0]=1,temp_2.data[0]=2;
    temp_1.n=1,temp_2.n=1;
    temp_1_1=temp_1;
    cata combination_m,combination_n,temp_n,catalan_m,temp_finish;
    catalan_m=combination_m=m;

    if((cp=compare_cata(m/temp_2,n))==0)
    {
        m=combination_m;
        n=m-n;
        combination_n=n;    
        m=combination_m;
    }

    else
    {
        m=combination_m;
        combination_n=n;
    }
    int cp_boundary=cp;
    temp_finish=m-n+temp_1;
    temp_n=temp_1;
    temp_n+n;

    m=combination_m;
    while((cp=compare_cata(combination_m,temp_finish))==1)
    {
        combination_m-temp_1;
        m*combination_m;
    }
                                                     
    while((cp=compare_cata(combination_n,temp_1))==1)
    {
        combination_n-temp_1;
        n*combination_n;
    }
   
    cata catalan_div;
    if(cp_boundary!=2)
    {
        catalan_div=temp_finish-temp_1;                             //catalan_div存放这catalan的除数
        while((cp=compare_cata(temp_finish,temp_n))==1)
        {
            temp_finish-temp_1;
            catalan_div*temp_finish;
        }
        catalan_div*m*n;                                            //为提高效率,尽量用到了已知的m,n来算catalan_div,即m!
    }
    else
    {
        catalan_div=temp_1;
        catalan_div*m*n;
    }
    result_combination=m/n;

    temp_1+catalan_m+temp_1_1;
    m=catalan_m*temp_2;
    while((cp=compare_cata(catalan_m,temp_1))==1)
    {
        catalan_m-temp_1_1;
        m*catalan_m;
    }
    result_catalan=m/catalan_div;
}///:p

void boundary_result(cata &m,cata &result_combination,cata &result_catalan)
{
    int cp;
    cata temp_1(1),temp_2(1),temp_1_1,catalan_m,catalan_div;
    temp_1.data[0]=1,temp_2.data[0]=2;
    temp_1.n=1,temp_2.n=1;
    result_combination=temp_1;
    temp_1_1=temp_1;
    catalan_div=catalan_m=m;

    temp_1+catalan_m+temp_1_1;
    m=catalan_m*temp_2;
    while((cp=compare_cata(catalan_m,temp_1))==1)
    {
        catalan_m-temp_1_1;
        m*catalan_m;
    }

    catalan_m=catalan_div;
    while((cp=compare_cata(catalan_m,temp_1_1))==1)
    {
        catalan_m-temp_1_1;
        catalan_div*catalan_m;
    }

    result_catalan=m/catalan_div;
}///:p

inline void cata::printcata(ofstream &out) const
{
    for(int i=n-1;i>=0;i--)
    {
        out<<data[i];
    }
    out<<endl;
}