蒜头君的新游戏 dp

工作空闲之余，蒜头君经常带着同事们做游戏，最近蒜头君发明了一个好玩的新游戏：$n$ 位同事围成一个圈，同事 A 手里拿着一个兔妮妮的娃娃。蒜头君喊游戏开始，每位手里拿着娃娃的同事可以选择将娃娃传给左边或者右边的同学，当蒜头君喊游戏结束时，停止传娃娃。此时手里拿着娃娃的同事即是败者。

玩了几轮之后，蒜头君想到一个问题：有多少种不同的方法，使得从同事 A 开始传娃娃，传了 $m$次之后又回到了同事 A 手里。两种方法，如果接娃娃的同事不同，或者接娃娃的顺序不同均视为不同的方法。例如 $1->2->3->1$ 和 $1->3->2->1$ 是两种不同的方法。

输入格式

输入一行，输入两个整数 $n,m(3\le n\le 30,1\le m\le 30)$，表示一共有 $n$ 位同事一起游戏，一共传 $m$ 次娃娃。

输出格式

输出一行，输出一个整数，表示一共有多少种不同的传娃娃方法。

样例输入

3 3

样例输出

2

/*
这道题算是道老题, 想想第一次做的时候, 好不容易想出来的,
当时也感觉真正的dp入门了.
现在做却还是有一点波折.
首先是拆分过程, 定义子状态:
    从 A 开始传, 第 m 次传到 A , 那么只能从 A 的左边和右边传过去.
    现在定义状态 dp[m, 0] 为传了 m 次传到 A 的方法数,
    状态转移方程为 dp[m, 0] = dp[m - 1, 1] + dp[m - 1, (0 - 1) % n]
    dp[m - 1, 1] 表示 传了 m - 1 次, 传到 1 的方法数
    dp[m - 1, (0 - 1) % n] 表示 传了 m - 1 次, 传到 (0 - 1) % n的方法数
    
    取余的目的是将这些人围成一个环
*/
/*
这次做, 让我知道通过状态转移方程的做法与记忆化搜索的时间有很大差异
以下两个代码为第一次过的两个代码
*/
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn = 35;
int n, m;
ll dp[maxn][maxn];
ll search(int n_steps, int person);
int main()
{
    // memset(dp, -1, sizeof(dp));
    dp[0][0] = 1;
    cin >> n >> m;
    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 + n - 1) % n];
        }
    }
    cout << dp[m][0] << endl;
    return 0;
}
ll search(int n_steps, int person)// TLE
{// 可能是无用的状态有点多
    if(dp[n_steps][person] != -1)
        return dp[n_steps][person];
    if(n_steps == 0){
        if(person == 0)
            return dp[0][0] = 1;
        else
            return dp[0][person] = 0;
    }
    return search(n_steps - 1, (person + 1) % n)
            + search(n_steps - 1, (person + n - 1) % n);
}

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN = 35;
int dp[MAXN][MAXN];
int N, M;
int rec(int m, int pos)
{
    if(dp[m][pos] != -1)
        return dp[m][pos];
    int res;
    if(m == 0 && pos == 1)
        res = 1;
    else if(m == 0)
        res = 0;
    else if(pos == 1)
        res = rec(m - 1, 2) + rec(m - 1, N);
    else if(pos == N)
        res = rec(m - 1, 1) + rec(m - 1, N - 1);
    else
        res = rec(m - 1, pos - 1) + rec(m - 1, pos + 1);
    
    return dp[m][pos] = res;
}
int main()
{
    memset(dp, -1, sizeof(dp));
    cin >> N >> M;
    int ans = rec(M, 1);
    cout << ans << endl;
    return 0;
}

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    int n, m, dp[35][35];
    memset(dp, 0, sizeof(dp));
    cin >> n >> m;
    dp [1][0] = dp[0][1] = dp[0][n + 1] = 1;
    for(int i = 1; i <= m; ++i){
        for(int pos = 1; pos <= n; ++pos){
            dp[i][pos] = dp[i - 1][pos - 1] + dp[i - 1][pos + 1];
        }
        dp[i][n + 1] = dp[i][1];
        dp[i][0] = dp[i][n];
    }
    cout << dp[m][1] << endl;
    return 0;
}