蓝桥杯-摆动序列 【动态规划】

摆动序列

【问题描述】
如果一个序列的奇数项都比前一项大，偶数项都比前一项小，则称为一个摆动序列。即 a[2i]<a[2i-1], a[2i+1]>a[2i]。
小明想知道，长度为 m，每个数都是 1 到 n 之间的正整数的摆动序列一共有多少个。
【输入格式】
输入一行包含两个整数 m，n。
【输出格式】
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
【样例输入】
3 4
【样例输出】
14
【样例说明】
以下是符合要求的摆动序列：
2 1 2
2 1 3
2 1 4
3 1 2
3 1 3
3 1 4
3 2 3
3 2 4
4 1 2
4 1 3
4 1 4
4 2 3
4 2 4
4 3 4
【评测用例规模与约定】
对于 20% 的评测用例，1 <= n, m <= 5；
对于 50% 的评测用例，1 <= n, m <= 10；
对于 80% 的评测用例，1 <= n, m <= 100；
对于所有评测用例，1 <= n, m <= 1000。

解题思路：

m<=1000，暴力的话必然会超时，这道题可以用动态规划的思路。

建立一个dp[i][j]]数组，表示第i个位置 数字j 有几种选择方式

比如题目中的例子，

第一个位置的话，

显然不能选1,2 3 4都可以。

第二个位置，要比第一个位置的数字 小，

那么数字1 可以选择3次，数字2 可以选择2次，数字3，可以选择1次。

第三个位置，要比第一个位置的数字 大，

数字1肯定没得选，比谁都小。

数字2可以选3次（第二个位置可以有3个1）；

数字3可以选择5次，（第二个位置可以有3个1，2个2）；

数字4可以选择4次，（第二个位置可以有3个1，2个2，1个3）；

 

综上，可以总结出 状态转移方程：

     当i为奇数时：dp[i][j] = dp[i-1][1] + dp[i-1][2] + ...... + dp[i-1][j-1]

     当i为偶数时:  dp[i][j] = dp[i-1][j+1] + dp[i-1][j+2] + ....... + dp[i-1][n]

 

#include <iostream>
using namespace std;
int dp[1005][1005];
int main()
{
    int m, n, i, j, k;
    cin >> m >> n;
    int sum = 0;
    dp[0][1] = 1;

    for (i = 1; i <= m; i++)
    {
        if (i & 1)
        {
            for (j = 2; j <= n; j++)
            {
                int temp = 0;
                for (k = 1; k <= j - 1; k++)
                    temp = (temp + dp[i - 1][k]) % 10000;
                dp[i][j] = temp;
            }
        }
        else
        {

            for (j = 1; j <= n - 1; j++)
            {
                int temp = 0;
                for (k = j + 1; k <= n; k++)
                    temp = (temp + dp[i - 1][k]) % 10000;
                dp[i][j] = temp;
            }
        }
    }
    for (i = 1; i <= n; i++)
        sum = (sum + dp[m][i]) % 10000;

    cout << sum << endl;
    //system("pause");
    return 0;
}

 

然后看了 亓官劼 大神写的博客https://qiguanjie.blog.csdn.net/article/details/105622530

意识到在每个位置 在计算dp[i][j] = dp[i-1][1] + dp[i-1][2] + ...... + dp[i-1][j-1]的时候，会产生很多重复，可以进一步优化。

找规律：

          

         

会发现：

奇数行中：dp[i][j] = dp[i][j+1] + dp[i-1][j-1]

偶数行中，dp[i][j] = dp[i][j-1] + dp[i-1][j+1]

 

#include <iostream>
using namespace std;

int dp[1005][1005];
int main()
{
    int m, n, i, j, k;
    cin >> m >> n;
    dp[0][1] = 1;

    for (i = 1; i <= m; i++)
    {
        if (i & 1)
            for (j = 2; j <= n; j++)
                dp[i][j] = (dp[i][j + 1] + dp[i - 1][j - 1]) % 10000;

        else
            for (j = 1; j <= n - 1; j++)
                dp[i][j] = (dp[i][j - 1] + dp[i - 1][j + 1]) % 10000;
    }

    int sum = m & 1 ? dp[m][1] : dp[m][n];

    cout << sum << endl;
    system("pause");
    return 0;
}