BZOJ2729:[HNOI2012]排队(组合数学)

Description

某中学有 n 名男同学，m 名女同学和两名老师要排队参加体检。他们排成一条直线，并且任意两名女同学不能相邻，两名老师也不能相邻，那么一共有多少种排法呢？（注意：任意两个人都是不同的）

 

Input

只有一行且为用空格隔开的两个非负整数 n 和 m，其含义如上所述。

 

对于 30%的数据 n≤100,m≤100

 

对于 100%的数据 n≤2000,m≤2000

Output

输出文件 output.txt 仅包含一个非负整数，表示不同的排法个数。注意答案可能很大。

Sample Input

1 1

Sample Output

12

Solution

一种情况是两个老师中间只有一个人且这个人是女生。

即$A(n,n)*A(n+1,1)*A(2,2)*A(m,1)*A(n+2,m-1)$

另一种情况是两个老师中间不是只有一个女生，也就是两个老师中间一定有男生。

即$A(n,n)*A(n+1,2)*A(n+3,m)$

Code

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define MAX_L 20005
using namespace std;

class bign
{
    public:
        int len, s[MAX_L];
        bign();
        bign(const char*);
        bign(int);
        bool sign;
        string toStr() const;
        friend istream& operator>>(istream &,bign &);
        friend ostream& operator<<(ostream &,bign &);
        bign operator=(const char*);
        bign operator=(int);
        bign operator=(const string);
        bool operator>(const bign &) const;
        bool operator>=(const bign &) const;
        bool operator<(const bign &) const;
        bool operator<=(const bign &) const;
        bool operator==(const bign &) const;
        bool operator!=(const bign &) const;
        bign operator+(const bign &) const;
        bign operator++();
        bign operator++(int);
        bign operator+=(const bign&);
        bign operator-(const bign &) const;
        bign operator--();
        bign operator--(int);
        bign operator-=(const bign&);
        bign operator*(const bign &)const;
        bign operator*(const int num)const;
        bign operator*=(const bign&);
        bign operator/(const bign&)const;
        bign operator/=(const bign&);
        bign operator%(const bign&)const;
        bign factorial()const;
        bign Sqrt()const;
        bign pow(const bign&)const;
        void clean();
        ~bign();
};

bign::bign()
{
    memset(s,0,sizeof(s));
    len=1;
    sign=1;
}

bign::bign(const char *num)
{
    *this=num;
}

bign::bign(int num)
{
    *this=num;
}

string bign::toStr() const
{
    string res;
    res="";
    for (int i=0; i<len; i++)
        res=(char)(s[i]+'0')+res;
    if (res=="")
        res="0";
    if (!sign&&res!="0")
        res="-"+res;
    return res;
}

istream &operator>>(istream &in, bign &num)
{
    string str;
    in>>str;
    num=str;
    return in;
}

ostream &operator<<(ostream &out, bign &num)
{
    out<<num.toStr();
    return out;
}

bign bign::operator=(const char *num)
{
    memset(s,0,sizeof(s));
    char a[MAX_L]="";
    if (num[0]!='-')
        strcpy(a,num);
    else
        for (int i=1,l=strlen(num); i<l; i++)
            a[i-1]=num[i];
    sign=!(num[0]=='-');
    len=strlen(a);
    for (int i=0; i<strlen(a); i++)
        s[i]=a[len-i-1]-48;
    return *this;
}

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

bign bign::operator=(const string num)
{
    const char *tmp;
    tmp=num.c_str();
    *this=tmp;
    return *this;
}

bool bign::operator<(const bign &num) const
{
    if (sign^num.sign)
        return num.sign;
    if (len!=num.len)
        return len<num.len;
    for (int i=len-1; i>=0; i--)
        if (s[i]!=num.s[i])
            return sign?(s[i]<num.s[i]):(!(s[i]<num.s[i]));
    return !sign;
}

bool bign::operator>(const bign&num)const
{
    return num<*this;
}

bool bign::operator<=(const bign&num)const
{
    return !(*this>num);
}

bool bign::operator>=(const bign&num)const
{
    return !(*this<num);
}

bool bign::operator!=(const bign&num)const
{
    return *this>num || *this<num;
}

bool bign::operator==(const bign&num)const
{
    return !(num!=*this);
}

bign bign::operator+(const bign &num) const
{
    if (sign^num.sign)
    {
        bign tmp=sign?num:*this;
        tmp.sign=1;
        return sign?*this-tmp:num-tmp;
    }
    bign result;
    result.len=0;
    int temp=0;
    for (int i=0; temp || i<(max(len, num.len)); i++)
    {
        int t=s[i]+num.s[i]+temp;
        result.s[result.len++]=t % 10;
        temp=t/10;
    }
    result.sign=sign;
    return result;
}

bign bign::operator++()
{
    *this=*this+1;
    return *this;
}

bign bign::operator++(int)
{
    bign old=*this;
    ++(*this);
    return old;
}

bign bign::operator+=(const bign &num)
{
    *this=*this+num;
    return *this;
}

bign bign::operator-(const bign &num) const
{
    bign b=num,a=*this;
    if (!num.sign && !sign)
    {
        b.sign=1;
        a.sign=1;
        return b-a;
    }
    if (!b.sign)
    {
        b.sign=1;
        return a+b;
    }
    if (!a.sign)
    {
        a.sign=1;
        b=bign(0)-(a+b);
        return b;
    }
    if (a<b)
    {
        bign c=(b-a);
        c.sign=false;
        return c;
    }
    bign result;
    result.len=0;
    for (int i=0, g=0; i<a.len; i++)
    {
        int x=a.s[i]-g;
        if (i<b.len) x -= b.s[i];
        if (x >= 0) g=0;
        else
        {
            g=1;
            x += 10;
        }
        result.s[result.len++]=x;
    }
    result.clean();
    return result;
}

bign bign::operator * (const bign &num)const
{
    bign result;
    result.len=len+num.len;

    for (int i=0; i<len; i++)
        for (int j=0; j<num.len; j++)
            result.s[i+j] += s[i] * num.s[j];

    for (int i=0; i<result.len; i++)
    {
        result.s[i+1] += result.s[i]/10;
        result.s[i] %= 10;
    }
    result.clean();
    result.sign=!(sign^num.sign);
    return result;
}

bign bign::operator*(const int num)const
{
    bign x=num;
    bign z=*this;
    return x*z;
}
bign bign::operator*=(const bign&num)
{
    *this=*this * num;
    return *this;
}

bign bign::operator /(const bign&num)const
{
    bign ans;
    ans.len=len-num.len+1;
    if (ans.len<0)
    {
        ans.len=1;
        return ans;
    }

    bign divisor=*this, divid=num;
    divisor.sign=divid.sign=1;
    int k=ans.len-1;
    int j=len-1;
    while (k >= 0)
    {
        while (divisor.s[j]==0) j--;
        if (k > j) k=j;
        char z[MAX_L];
        memset(z, 0, sizeof(z));
        for (int i=j; i >= k; i--)
            z[j-i]=divisor.s[i]+'0';
        bign dividend=z;
        if (dividend<divid)
        {
            k--;
            continue;
        }
        int key=0;
        while (divid*key <= dividend) key++;
        key--;
        ans.s[k]=key;
        bign temp=divid*key;
        for (int i=0; i<k; i++)
            temp=temp * 10;
        divisor=divisor-temp;
        k--;
    }
    ans.clean();
    ans.sign=!(sign^num.sign);
    return ans;
}

bign bign::operator/=(const bign&num)
{
    *this=*this/num;
    return *this;
}

bign bign::operator%(const bign& num)const
{
    bign a=*this, b=num;
    a.sign=b.sign=1;
    bign result, temp=a/b*b;
    result=a-temp;
    result.sign=sign;
    return result;
}

bign bign::pow(const bign& num)const
{
    bign result=1;
    for (bign i=0; i<num; i++)
        result=result*(*this);
    return result;
}

bign bign::factorial()const
{
    bign result=1;
    for (bign i=1; i <= *this; i++)
        result*=i;
    return result;
}

void bign::clean()
{
    if (len==0) len++;
    while (len>1 && s[len-1]=='')
        len--;
}

bign bign::Sqrt()const
{
    if(*this<0)return -1;
    if(*this<=1)return *this;
    bign l=0,r=*this,mid;
    while(r-l>1)
    {
        mid=(l+r)/2;
        if(mid*mid>*this) r=mid;
        else l=mid;
    }
    return l;
}

bign::~bign()
{
}

bign A(int n,int m)
{
    bign ans;
    ans=1;
    for (int i=n-m+1; i<=n; ++i) ans*=i;
    return ans;
}

int n,m; 

int main()
{
    scanf("%d%d",&n,&m);
    bign ans=A(n,n)*A(n+1,2)*A(n+3,m)+A(n,n)*A(n+1,1)*A(2,2)*A(m,1)*A(n+2,m-1);
    cout<<ans;
}