HDU OJ -- Buy the Ticket

一、问题描述

1.概述

电影院售票，每张票50元。

现有两种类型的人来购票，第一种身上只有一张50元的钞票，用m表示这种类型的人的个数；第二种只有一张100元的钞票，用n表示这类型人的个数。

现给出两种类型的人数，问来购票的人共有多少种排队方式使得电影院的售票过程不会中断？

例如：当m=2，n=1时。

可能的不中断购票的排队序列为（m1，m2，n1），（m2，m1，n1），（m1，n1，m2），（m2，n1，m1）

若n排在第一位，如（n，...），则售票过程中断。

2.题目链接

HDU OJ -- Buy the Ticket

3.题目截图

如图1.1所示。

图1.1  题目截图

二、算法思路

下面通过（m=3,n=3）说明算法的思路，假设t为售票处拥有的50元数目，刚开始为0。

问题的求解如图2.1所示，图中用树形的结构说明了可能的排队序列，根节点下的每一层节点代表了队列中按次序排队的人。通过分析此图，可以看出：

可能的排队方式 = 各路径（根节点到叶子节点）包含的排队方式之和

各路径所包含的排队方式相同，这是因为，当（m=3,n=3）时，每个路径（排队方式）中的m要经过三个阶段：3选1、2选1、1选1；同理，n也要经过这三个阶段。所以各路径拥有的排队方式 = m! x n!

可能的排队方式 = 路径数 x 各路径拥有的排队方式 = 5 x 3! x 3! = 180。

所以，算法最主要是求出树中包含的路径数。

图2.1  m=3,n=3时问题的求解过程

为了满足题目中的限制条件，算法的实现经历了三个阶段。

下面的出现的括号内的m，n，t的组合表示在此条件下的路径数，如（m，n，t），（m，n）等

1.采用递归求路径数 -- 超出执行时间限制

根据题意以及下图，可以得出以下结论：

1）当m=0或n=0时，此时得到一条新的路径，这个作为递归函数的出口。

2）当t=0时，此时仅能从m中选取一个构成队列，即问题可以从（m，n，t）转化为（m-1，n，t+1）

3）当t!=0时，此时可以从m或n中选取一个构成队列，即问题可以从（m，n，t）转化为（m-1，n，t+1）+（m，n-1，t-1）

2.采用三维数组求路径数 -- 超出执行内存限制

采用递归很直观，但是对于执行时间和执行空间都是一笔巨大的开销。通过对递归过程的分析：

即当t=0时，（m，n，t） = （m-1，n，t+1）；当t!=0时，（m，n，t） = （m-1，n，t+1）+（m，n-1，t-1）

发现解答中大规模的问题可以转化为小规模的问题，所以可以采用三维数组的方式从小规模到大规模来实现算法。

数组中元素规律总结为下表2.1，表中MAX为问题的规模，这里是100，max（a，b）返回a和b中较大值的函数，根据此表可以很容易设计出相应的算法完成数组的构造。

表1.1  三维数组元素规律

m	n	t	路径数
0	1~MAX	n~MAX	1
1~MAX	0	0~MAX	1
1~MAX	1~MAX	max（n-m，0）~MAX	t=0，[m-1][n][t+1] t!=0，[m-1][n][t+1] + [m][n-1][t-1]

3.采用二维数组求路径数

第二种方法相对第一种在执行时间上有显著的改善，但是很遗憾超过了题目中规定的执行内存的限制，因此三维数组是不能采用的，但是同时又感觉这种递推向上的解法很好，故在此基础上对各种m，n组合的结果进行分析，发现了如下的规律：

1）m！=n时，（m，n） = （m-1，n） + （m，n-1）

2）m=n时，（m，n） = （m，n-1）

这个规律奠定了二维数组实现的方法，规律下图2.2所示，图中展示了m：1~9、n：0~m任意组合下所包含的路径数目。

图2.2  二维数组元素规律

三、算法实现（c++）

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
class NumStr
{
public:
    string str;
    NumStr()=default;
    NumStr(string str):str(str){}
    bool operator==(NumStr& oprand)
    {
        if(str.size()!=oprand.str.size())
            return false;
        for(unsigned i=0;i<str.size();i++)
        {
            if(str[i]!=oprand.str[i])
                return false;
        }
        return true;
    }
    bool operator<=(NumStr& oprand)
    {
        unsigned len1=str.size();
        unsigned len2=oprand.str.size();
        if(len1>len2)
            return false;
        else if(len1<len2)
            return true;
        for(int i=len1-1;i>=0;i--)
        {
            if(str[i]>oprand.str[i])
                return false;
            else if (str[i]<oprand.str[i])
                return true;
        }
        return true;
    }
    NumStr operator+(NumStr& oprand)
    {
        NumStr ret;
        bool carry=0;
        unsigned minLen=str.size()<=oprand.str.size()?str.size():oprand.str.size();
        char tmp;
        for(unsigned i=0;i<minLen;i++)
        {
            tmp=str[i]+oprand.str[i]+carry-'0';
            if(tmp>'9')
            {
                carry=1;
                tmp-=10;
            }
            else
            {
                carry=0;
            }
            ret.str+=tmp;
        }
        if(str.size()>minLen)
        {
            for(unsigned i=minLen;i<str.size();i++)
            {
                tmp=str[i]+carry;
                if(tmp>'9')
                {
                    carry=1;
                    tmp-=10;
                }
                else
                {
                    carry=0;
                }
                ret.str+=tmp;
            }
        }
        if(oprand.str.size()>minLen)
        {
            for(unsigned i=minLen;i<oprand.str.size();i++)
            {
                tmp=oprand.str[i]+carry;
                if(tmp>'9')
                {
                    carry=1;
                    tmp-=10;
                }
                else
                {
                    carry=0;
                }
                ret.str+=tmp;
            }
        }
        if(carry)
            ret.str+='1';
        return ret;
    }
    NumStr operator*(unsigned char oprand)
    {
        NumStr ret;
        unsigned char carry=0;
        unsigned char tmp;
        for(unsigned i=0;i<str.size();i++)
        {
            tmp=(str[i]-'0')*oprand+carry;
            ret.str+=(tmp%10+'0');
            carry=tmp/10;
        }
        if(carry!=0)
            ret.str+=(carry+'0');
        return ret;
    }
    NumStr operator*(NumStr& oprand)
    {
        NumStr ret,tmpStr;
        for(unsigned i=0;i<oprand.str.size();i++)
        {
            if(oprand.str[i]!='0')
            {
                tmpStr=*this*(oprand.str[i]-'0');
                if(i>0)
                    tmpStr.str.insert(0,i,'0');
                ret=ret+tmpStr;
            }
        }
        return ret;
    }
    void print()
    {
        for(int i=str.size()-1;i>=0;i--)
            cout<<str[i];
    }
};
//NumStr f[101][101];
NumStr g[101][101];
NumStr y[101][101];
//unsigned long long branches;
void branches()
{
    int i,j;
    for(i=1;i<=100;i++)
    {
            y[i][0]=NumStr("1");
    }
    y[1][1]=NumStr("1");
    for(i=2;i<=100;i++)
    {
        for(j=1;j<=i;j++)
        {
            if(i==j)
                y[i][j]=y[i][j-1];
            else
                y[i][j]=y[i-1][j]+y[i][j-1];
        }
    }
}
void dealMN()
{
    g[1][0]=g[1][1]=NumStr("1");
    unsigned i,j;
    NumStr tmp;
    for(i=2;i<=100;i++)
    {
        for(j=0;j<=i;j++)
        {
            if(j==i)
            {
                tmp=NumStr(to_string(j));
                reverse(tmp.str.begin(),tmp.str.end());
                g[i][j]=g[i][j-1]*tmp;
            }
            else
            {
                tmp=NumStr(to_string(i));
                reverse(tmp.str.begin(),tmp.str.end());
                g[i][j]=g[i-1][j]*tmp;
            }
        }
    }
}
void preDeal()
{
    dealMN();
    branches();
//
//        N=NumStr("0");
//        for(unsigned n=0;n<=m;n++,N=N+one)
//        {
//            branches=0;
//            ticket(m,n,0);
//            f[m][n]=NumStr(to_string(branches));
//            f[m][n]=f[m][n]*g[m][n];
//        }
//    }
}

int main()
{
    using namespace std;
    preDeal();
//    for(unsigned i=1;i<10;i++)
//    {
//        for(unsigned j=0;j<=i;j++)
//        {
//            y[i][j].print();
//            cout<<'\t';
//        }
//        cout<<endl;
//    }
    unsigned m,n,no=1;
    NumStr res;
    //cout<<sizeof(y)<<endl;
    while(cin>>m>>n && (m!=0 || n!=0))
    {
        cout<<"Test #"<<no++<<":\n";
        if(n>m)
            cout<<0<<endl;
        else
        {
            res=y[m][n]*g[m][n];
            res.print();
            cout<<endl;
        }
    }
    return 0;
}