5、不等式数列--百度2017春招

[编程题] 不等式数列

时间限制：1秒

空间限制：32768K

度度熊最近对全排列特别感兴趣,对于1到n的一个排列,度度熊发现可以在中间根据大小关系插入合适的大于和小于符号(即 '>' 和 '<' )使其成为一个合法的不等式数列。但是现在度度熊手中只有k个小于符号即('<'')和n-k-1个大于符号(即'>'),度度熊想知道对于1至n任意的排列中有多少个排列可以使用这些符号使其为合法的不等式数列。 

输入描述:

输入包括一行,包含两个整数n和k(k < n ≤ 1000)

 

 

输出描述:

输出满足条件的排列数,答案对2017取模。

 

输入例子:

5 2

 

输出例子:

66

 

解题思路：首先想到的是暴力的方式解决该问题

1）求出所有1-n的数的全排列分别存入vector中

2）对每一种排列，如果前一个小于后一个，小于数目--；如果大于则，大于数目--

3）如果一次操作过后，xiaoyu为0 && dayu为0  则符合条件，result++

4）输出result%2017

#include <iostream>
#include <vector>
using namespace std;


void swap(int* p1,int* p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
vector<vector<int> > res;
//获得1-n 全排列的个数，并存储全排列结果
void recall(int* arr,int len,int index,int *count)
{
    vector<int> tmp;
    if (index<=0)
    {
        (*count)++;//由于优先级的关系，记得加括号
        for(int i=0;i<len;i++)
        {
            //cout<<arr[i]<<" ";
            tmp.push_back(arr[i]);
        }
        res.push_back(tmp);
        tmp.clear();
        //cout<<endl;
        return;
    }
    for (int i=index;i>=0;i--)
    {
        swap(&arr[index],&arr[i]);
        recall(arr,len,index-1,count);
        swap(&arr[index],&arr[i]);
    }
}


int main()
{
    int n;
    int k;
    while(cin>>n>>k)
    {
        int count = 0;
        int result = 0;
        int a[n];

        for(int i=0;i<n;i++)
        {
            a[i] = i+1;
        }
        recall(a,n,n-1,&count);
        //cout<<count<<endl;
        for(int i=0;i<count;i++)
        {
            int xiaoyu = k;
            int dayu = n - k - 1;
            for(int j=0;j<n-1;j++)
            {
                //cout<<res[i][j]<<"  ";
                if(res[i][j]< res[i][j+1])
                {
                    xiaoyu--;
                }
                else if(res[i][j]>res[i][j+1])
                {
                    dayu--;
                }
            }
            //cout<<endl;
            //cout<<"k"<<xiaoyu<<"add"<<dayu<<endl;
            if(xiaoyu==0 && dayu == 0)
            {
                result++;
            }
        }
        cout<<result%2017<<endl;
    }
    return 0;
}

正确解法：
递归公式：dp[i][j] = (dp[i - 1][j - 1] * (i - j) + dp[i - 1][j] * (j + 1)) % 2017;
dp[i][j]表示有i个数字及j个小于号所能组成的数量(大于号数量当然是i - j - 1次，后面需要使用)
而加入第i + 1个数字时，分以下四种情况：
1、如果将i+1插入当前序列的开头，即有了1<2，加入后成为3>1<2，会发现等于同时加入了一个大于号
2、如果将i+1插入当前序列末尾，即1<2变成了 1<2<3，会发现等于同时加入了一个小于号
3、如果将i+1加入一个小于号之间，即已经有 1<2了，向中间加入3，会发现变成了1<3>2，等于同时加入了一个大于号
4、如果将i+1加入一个大于号中间，即有了2>1，变成了2<3>1，等于同时加入了一个小于号
综上所述，dp[i][j]等于以上四种情况之和：
dp[i - 1][j]         //将i加在开头等于加入一个大于号，即要求i-1个数时已经有了j个小于号
dp[i - 1][j - 1]    //将i加在末尾等于加入一个小于号，即要求i-1个数时已经有了j-1个小于号
dp[i - 1][j] * j    //将i加在任意一个小于号之间，等于加入了一个大于号；即要求i-1个数时已经有了j个小于号，每个小于号都可以进行这样的一次插入
dp[i - 1][j - 1] * (i- j - 1)    //将i加在任意一个大于号之间，等于加入了一个小于号；即要求i-1个数时有了j-1个小于号，而此时共有(i - 1) - (j - 1)- 1个大于号，每个大于号都要进行一次这样的操作
合并同类项即为
dp[i][j] = (dp[i - 1][j - 1] * (i - j) + dp[i - 1][j] * (j + 1)) 
最后要记得取模。。。
初始化dp[i][0] = 1  因为全部为大于号时，只有一种排列方式;

#include <iostream>

using namespace std;

int main()
{
    int dp[1005][1005];
    int n, k;
    while(cin>>n>>k)
    {
        for(int i = 1; i <= n; i++)
        {
            dp[i][0] = 1;
        }
        for(int i = 2; i <= n; i++)
        {
            for(int j = 1; j <= k; j++)
            {
                dp[i][j] = (dp[i - 1][j - 1] * (i - j) + dp[i - 1][j] * (j + 1)) % 2017;
            }
        }
        cout << dp[n][k] % 2017 << endl;
    }
    return 0;
}