[dp算法]逃离农场

牛牛在农场饲养了n只奶牛,依次编号为0到n-1, 牛牛的好朋友羊羊帮牛牛照看着农场.有一天羊羊看到农场中逃走了k只奶牛,但是他只会告诉牛牛逃走的k只奶牛的编号之和能被n整除。你现在需要帮牛牛计算有多少种不同的逃走的奶牛群。因为结果可能很大,输出结果对1,000,000,007取模。
例如n = 7 k = 4:
7只奶牛依次编号为0到6, 逃走了4只
编号和为7的有:{0, 1, 2, 4}
编号和为14的有:{0, 3, 5, 6}, {1, 2, 5, 6}, {1, 3, 4, 6},{2, 3, 4, 5}
4只牛的编号和不会大于18,所以输出5.

输入描述:
输入包括一行,两个整数n和k(1 ≤ n ≤ 1000),(1 ≤ k ≤ 50),以空格分割。

输出描述:
输出一个整数表示题设所求的种数。

输入例子:
7 4

输出例子:
5

看了下网的一些解法，基本的dp状态方程都是可以写对的。问题再于实现时候的上来就使用状态压缩了，而且也没解释明白，看得一头雾水。这里写一下过程
首先定义
使用dp[i][j][t]表示前i+1头奶牛中选取j头的和除以n余为t的方案数。

这里是i+1头，所以i的取值范围是0~n-1的。

j的取值是可以取0的，也就是一头都没逃走，j在循环里面的最大值是i和k的最小者。

好了，接下来是状态方程
则方案分为两种：选取了第i头奶牛和没有选取第i头奶牛两个子问题

没有选择第i头奶牛的方案数： dp[i−1][j][t]
选择第i头奶牛的方案数：dp[i−1][j−1][((t+n)−i)%n]

解释一下这个((t+n)−i)%n，第一，因为选了第i头牛，所以剩下的余数应该是用t-i，但是因为可能会出现负数，所以再加个n。然后再用n取余，就可以得到减去i之后，余数应该是多大。

下面先不用状态压缩来实现算法：

int func(int n, int k) {
    vector<vector<vector<int>>> dp;
    vector<int> vec1;
    vector<vector<int>> vec2;
    vec1.resize(n); //因为只能取0~n-1共n个数
    vec2.resize(k + 1, vec1); //可以取0~k共k+1个数
    dp.resize(n, vec2); //因为只能取0~n-1共n个数
    
    for (int m=0; m<n; m++) {//先初始化全部元素都为0
        for (int i = 0; i<k+1; i++) {
            for (int j=0; j<n; j++) {
                dp[m][i][j] = 0;
            }
        }
    }
    
    //初始赋值 ,i = 0时， 存在1头牛，选出0个，余n为0，这是一种唯一方案； 选出1个，余n为0，也是一种唯一方案
    dp[0][1][0] = dp[0][0][0] = 1;
    
    for (auto i = 1; i < n; i++) {//前i+1头奶牛
    {
        for (auto j = 0; j <= MIN(k, i+1); j++)//选择j头奶牛。因为i对应有i+1头牛
        {
            for (auto t = 0; t < n; ++t)//余t
            {
                if (j > 0) { //因为这里会涉及到 j-1，需要确保它打于0
                    dp[i][j][t] = (dp[i-1][j][t] + dp[i-1][j - 1][((t + n) - i) % n]);
                } else {
                    if (t == 0) { //当j==0的时候，也就是一头牛都没逃走，那么这个时候余数必须是0才有值，取其他余数都是0
                        dp[i][j][t] = 1;
                    }
                }
            }
        }
    }
    
    return dp[n-1][k][0];
}

这个算法没啥好说的，就是按照状态方程实现。然后留意一下初始化条件和j-1的状态就行。

然后来看看状态压缩的。留意到状态转移方程，其实每次计算新的i的时候，它只会用到i-1的二维数组的值。所以可以只使用一个二维数组去保存状态值就行了。所以状态方程可以写成

dp[j][t] = (dp[j][t] + dp[j - 1][((t + n) - i) % n]);

因为赋值的时候是先取等号右边的值去计算的，所以赋值语句是正确的。就像a=a+1，这个计算的a结果为原始的a+1一样。
这里有一个问题就是dp[j - 1][((t + n) - i) % n]这一项，里面依赖了j-1这项，所以我们必须先计算j，然后在计算j-1.否则的话，如果先计算了j-1，那么这个j-1的所有项对应的i都会加1，和j对应的i就对不上了。

int func2(int n, int k) {
    vector<vector<int>> dp;
    vector<int> vec;
    vec.resize(n + 1);
    dp.resize(k + 1, vec);
    
    for (int i = 0; i<k+1; i++) {
        for (int j=0; j<n; j++) {
            dp[i][j] = 0;
        }
    }
    dp[1][0] = dp[0][0] = 1; //网上有些写法，只写了dp[0][0] = 1其实是不对的
    for (auto i = 1; i < n; i++)//前i+1头奶牛
    {
        for (auto j = MIN(k, i+1); j > 0; --j)//选择j头奶牛。
// 需要留意的就是这个，这里必须用递减来做，因为状态方程依赖于j-1，
//如果我们使用递增，就会先计算了j-1，然后再计算j，这样，j-1就会变成了下一个循环的i。
//比如现在正在计算i=2，计算完了j-1之后，j-1所对应的元素的值都会增加到对应i=3，
//然后你再计算j的时候，就会用到i=3的j-1的项。那样就不对了。
        {
            for (auto t = 0; t < n; ++t)//余t
            {
                dp[j][t] = (dp[j][t] + dp[j - 1][((t + n) - i) % n]) ;
            }
        }
    }
    return dp[k][0];
}

转载于:https://www.jianshu.com/p/baa65c60d733

猜你喜欢