快速理解动态规划入门例题

可行路径数目

Problem Description

棋盘上A点有一个过河卒，需要走到目标B点。卒行走的规则：可以向下、或者向右。同时在棋盘上C点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。棋盘用坐标表示，A点（0，0）、B点（n，m）（n，m为不超过15的整数），同样马的位置坐标是需要给出的。现在要求你计算出卒从A点能够到达B点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

Input

一行四个数据，用空格分隔，分别表示B点的坐标和马的坐标。

Output

一个数据，表示所有的路径条数。

Sample Input

6 6 3 3
Sample Output

6

思路：
用$dp[i][j]$表示到点$(i,j)$的路径数目，初始化第一行和第一列。递推方程为：
$$dp[i][j]=dp[i-1][j]+dp[i][j-1]$$

代码：

#include <iostream>
using namespace std;
int n, m, xma, yma;
int map[22][22];
int dp[22][22];
int dx[9] = {0, -2, -1, 1, 2, 2, 1, -1, -2};
int dy[9] = {0, 1, 2, 2, 1, -1, -2, -2, -1};

int main() {
    cin >> n >> m >> xma >> yma;
    for (int i = 0; i <= 8; i++) {
        if (xma + dx[i] >= 0 && xma + dx[i] <= n && yma + dy[i] >= 0 && yma + dy[i] <= m) {
            map[xma + dx[i]][yma + dy[i]] = 1;
        }
    }
    for (int i = 0; i <= n; i++) {
        if (!map[i][0])
            dp[i][0] = 1;
        else
            dp[i][0] = 0;
    }
    for (int i = 0; i <= m; i++) {
        if (!map[0][i])
            dp[0][i] = 1;
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (map[i][j])
                dp[i][j] = 0;
            else
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    cout << dp[n][m];
    return 0;
}

墙壁涂色

蒜头君觉得白色的墙面好单调，他决定给房间的墙面涂上颜色。

他买了 3 种颜料分别是红、黄、蓝，然后把房间的墙壁竖直地划分成 n 个部分，蒜头希望每个相邻的部分颜色不能相同。

他想知道一共有多少种给房间上色的方案。

例如，当 n = 5 时，下面就是一种合法方案。

由于墙壁是一个环形，所以下面这个方案就是不合法的。

输入格式
一个整数 n，表示房间被划分成多少部分。（1 <=n<=50）

输出格式
一个整数，表示给墙壁涂色的合法方案数。

样例输入
4

样例输出
18

思路：

设dp[i]为长度为i的方案数，然后找出 dp[n] 与 dp[n - 1] 和 dp[n - 2] 的关系。

当块数大于3时，考虑第 1 块和 n-1块颜色不一样的情况，现在第 n 块要和第 n-1和 1 都不一样，但是只有 3 种颜色，所以 n 只有一种颜色选择，这种情况方案数正好是 dp[n-1]。

考虑第 1 块和 n-1 块颜色一样的情况，第 n-2 块必然要和第 n-1 块不同，同时也就和第 1 块不同，前面 n-2 块方案数是 dp[n-2]，第 n 块要和第 1 块和第 n-1块不同，有 2 种选择，所以这种情况方案数是 2∗dp[n−2]。
上面 2 种情况加起来就是总方案数。

代码：

#include <iostream>
using namespace std;
int n;
int dp[10000];

int main() {
    cin >> n;
    dp[1] = 3, dp[2] = 6, dp[3] = 6;
    for (int i = 4; i <= n; i++) {
        dp[i] = dp[i - 1] + 2 * dp[i - 2];
    }
    cout << dp[n];
    return 0;
}

新游戏

问题描述
工作空闲之余，蒜头君经常带着同事们做游戏，最近蒜头君发明了一个好玩的新游戏：n 位同事围成一个圈，同事 A 手里拿着一个兔妮妮的娃娃。蒜头君喊游戏开始，每位手里拿着娃娃的同事可以选择将娃娃传给左边或者右边的同学，当蒜头君喊游戏结束时，停止传娃娃。此时手里拿着娃娃的同事即是败者。
玩了几轮之后，蒜头君想到一个问题：有多少种不同的方法，使得从同事 A 开始传娃娃，传了 m 次之后又回到了同事 A 手里。两种方法，如果接娃娃的同事不同，或者接娃娃的顺序不同均视为不同的方法。例如1−>2−>3−>1 和 1->3->2->1 是两种不同的方法。
输入格式
输入一行，输入两个整数n,m(3≤n≤30,1≤m≤30)，表示一共有 n 位同事一起游戏，一共传 m 次娃娃。
输出格式
输出一行，输出一个整数，表示一共有多少种不同的传娃娃方法。
样例输入
3 3
样例输出
2
思路：
假设起点为0。设$dp[i][j]$是传了i次传到j的方法数，则有$$dp[i][j]=dp[i-1][j+1]+dp[i-1][j+1]$$
另外注意这是一个环状结构，于是采用%n的方式来模仿环状。

代码：

#include <iostream>
using namespace std;
int n, m;
int dp[31][31];

int main() {
    cin >> n >> m;
    dp[0][0] = 1;
    for (int i = 1; i <= m; i++) {
        for (int j = 0; j < n; j++)
            dp[i][j] = dp[i - 1][(j + 1) % n] + dp[i - 1][(j - 1 + n) % n];
    }
    cout << dp[m][0];
    return 0;
}