C++博客-Residence for sdfond-随笔分类-算法 - 动态规划

UVa 861 Little Bishops

sdfond — Sat, 06 Feb 2010 09:58:00 GMT

【题目大意】
　　给定一个n*n的棋盘，求放置k个互不攻击的象的方法数。其中n <= 8，k <= n ^ 2。

【题目分析】
　　对于棋盘放车问题可以用组合数学的知识来解决，但是对于含禁区的摆放问题，虽然组合数学给出了经典的棋盘多项式+容斥原理的解法，但是实际中棋盘多项式的求解是很困难的，因此一般需要借助状态压缩动态规划求解。
　　现在题目中要求出互不攻击的象的方法数，象的攻击路线是斜的，是不是可以考虑采用放车的方法来解呢？将棋盘黑白染色，如果一个象在黑色的格子里面，那么它一定不会攻击到白色的格子，这样的话可以分开计数，然后最后利用乘法原理加起来就行了。把棋盘旋转45度，这样象的攻击路线就是直的了，如果只考虑一种颜色的话，那么问题就转变成了经典的放车问题了，可以利用动态规划解决。
　　设dp[i][j]表示前i行放了j个车的方法数，c[i]表示第i行可以放置的棋子数量，那么转移方程为：
　　　　dp[i][j] = dp[i-1][j] + dp[i-1][j-1] * (c[i] - (j - 1))
　　需要注意的是c数组应该是增序的，这样才能保证前面的j-1行放了车，对应这一行就有j-1个位置不可放了。
　　这个题目的dp方程不难想，但是如何把模型转化到放车问题是不容易想到的，尤其是将棋盘黑白染色后分开计数的想法，非常巧妙。

题目代码：

1 #include <iostream>
2 #include <algorithm>
3 using namespace std;
4 const int N = 70;
5
6 void init(int n, int c1[N], int c2[N])
7 {
8     memset(c1, 0, sizeof(int) * N);
9     memset(c2, 0, sizeof(int) * N);
10     for (int i = 1; i <= n; i++)
11     {
12         for (int j = 1; j <= n; j++)
13         {
14             if ((i + j) & 1)
15                 c2[(i+j)/2]++;
16             else
17                 c1[(i+j)/2]++;
18         }
19     }
20 }
21 void bishops(int n, int dp[N][N], int c[N])
22 {
23     for (int i = 0; i <= n; i++)
24         dp[i][0] = 1;
25     for (int i = 1; i <= n; i++)
26         for (int j = 1; j <= c[i]; j++)
27             dp[i][j] = dp[i-1][j] + dp[i-1][j-1] * (c[i] - j + 1);
28 }
29
30 int main()
31 {
32     int n, k, c1[N], c2[N], dp1[N][N], dp2[N][N], ans;
33
34     while (scanf("%d %d", &n, &k) == 2)
35     {
36         if (n == 0 && k == 0)
37             break;
38         init(n, c1, c2);
39         sort(c1 + 1, c1 + n + 1);
40         sort(c2 + 1, c2 + n);
41         memset(dp1, 0, sizeof(dp1));
42         memset(dp2, 0, sizeof(dp2));
43         bishops(n, dp1, c1);
44         bishops(n - 1, dp2, c2);
45         ans = 0;
46         for (int i = 0; i <= k; i++)
47             ans += dp1[n][i] * dp2[n-1][k-i];
48         printf("%d\n", ans);
49     }
50
51     return 0;
52 }

注：本文作于2009年6月23日 19点51分

sdfond 2010-02-06 17:58 发表评论

组合游戏总结——基本博弈问题

sdfond — Sat, 06 Feb 2010 00:55:00 GMT

【概述】
　　最近的几次比赛，博弈的题目一直不少，而且博弈问题是一块比较复杂、庞大的内容，因此在这里小结一下，希望能够帮自己理清一些思路，争取也多来几个系列，呵呵。

竞赛中出现的组合游戏问题一般都满足以下特征：
　　　　1. 二人博弈游戏，每个人都采用对自己最有利的策略，并且是两个人轮流做出决策
　　　　2. 在游戏中的任意时刻，每个玩家可选择的状态是固定的，没有随机成分
　　　　3. 游戏在有限步数内结束，没有平局出现
　　大部分的题目都满足上述条件，因此这里只讨论在上述条件范畴内的博弈问题。这类博弈问题，通常还有若干分类。一种是规定移动最后一步的游戏者获胜，这种规则叫做Normal Play Rule；另一种是规定移动最后一步的游戏者输，这种规则叫做Misere Play Rule，也称为Anti-SG游戏。此外，对于游戏的双方，如果二者博弈的规则相同，那么称为这类游戏是对等(impartial games)的；否则称为不平等游戏(partizan games )。当初WHU的那场比赛就是由于对于这个概念不是很清晰，导致看完题目之后就用SG定理来做，浪费了很多机时。实际上，解决不平等博弈问题的方法和普通的博弈问题（SG游戏）是有区别的，一般会采用动态规划或者surreal number。

【博弈基础知识】
　　在SG游戏中，最为人熟知的是必胜必败态，也叫NP态理论。注意的是，P态对应的是先手必败态，N态对应的是先手必胜态。必胜必败态理论是：
　　1. All terminal positions are P-positions
　　2. From every N-position, there is at least one move to a P-position
　　3. From every P-position, every move is to an N-position
　　英文的表述非常简洁清晰，而且这个理论也很好理解，如果在当前状态的下一步可以走到必败态，那么当前玩家就可以走到那个状态，把必败态推给另一方；如果所有可达状态都是必胜态，那么当前玩家无论如何走，都会把必胜态让给对方。根据必胜必败态理论，我们可以递归的求出每个状态是N态还是P态。必胜必败态理论其实已经把博弈问题转化成了一个有向图，借助图这个模型来分析问题，使得问题变得形象了许多。需要注意的是，这种SG游戏对应的有向图是无环的，因为如果有环，那么游戏双方就可能在环上不停的转换状态，游戏不能在有限步终止，这样就不满足组合游戏的特征3了。
　　然而在很多时候仅仅知道某个状态是必胜还是必败是不够的，因为如果存在多个组合游戏（比如经典的Nim），对应的状态集合非常大，无法直接利用必胜必败态理论求解，因此需要用到博弈论中一个很重要的工具：SG函数。
　　某个状态的SG函数值定义为当前状态所有不可达的状态编号中最小的编号，其中终止态的SG函数值是0。有了这个工具，就引入一个非常强大的定理——SG分解定理：

　　多个组合游戏的SG函数值是每个组合游戏的函数值的和。（这里的和定义为异或操作）
　　
　　SG分解定理的证明不是很难，其实和Nim的证明很像。根据这个定理，我们就知道为什么Nim的解法是异或所有的石子个数了，因为每堆石子的SG值就是石子的个数。SG分解定理告诉我们任何SG游戏都可以转化成Nim游戏来做。
　　Nim中的一个变形就是拿走最后一块石子的人算输。通过修改SG的计算规则，可以得出相同的结论（因为当石子个数是1的时候SG值为0，因此要单独处理）；当然也可以利用一个叫做SJ定理的方法来做，依然是要处理当所有堆的SG值不大于1的情况。

【博弈基本模型】
　　除了Nim模型，很多模型都看似复杂，最后都划归到了Nim模型上，然后利用SG分解来做的。在证明两种模型等价的时候，可以通过计算SG值判断是否相同，或者通过判断必胜策略的走法将其转化为Nim。许多模型非常的神奇，其获胜策略又千差万别，因此无法一一列举，但是掌握一些经典模型是必须的，这样通过模型的转化可以简化问题的难度。
　　经典模型1：Nim变种。包括：
　　　　(1) 楼梯Nim。把奇数台阶的石子作为Nim，二者等价，因为必胜的策略是相同的。
　　　　(2) 每次可以取k堆，这个是经典的Moore Nim。它是泛化的Nim游戏。
　　　　(3) 两堆石子，每次可以取一堆或两堆，从两堆取得时候个数必须相同，谁先取完获胜。这个是著名的威佐夫博弈，跟黄金分割数有关，具体证明不是很清楚，但是用SG值打表可以找出规律。代码如下：

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
    const double k = (sqrt(5.0) + 1) / 2.0;
    int a, b, t;

    while (scanf("%d %d", &a, &b) == 2)
    {
        if (a > b)
            swap(a, b);
        t = b - a;
        if (a == (int)(t * k))
            puts("0");
        else
            puts("1");
    }

    return 0;
}

　　　　(4) Subtraction Games。一种通用的Nim游戏，每次从可用状态集合中选择下一步的状态，有很多变形，核心思想还是计算SG函数值。
　　　　(5) Take-and-Break Game。每次把局面分成多个Nim子游戏，利用SG分解定理求出对应的SG值。
　　经典模型2：翻硬币游戏(Coin Turning Game)
　　　　(1) 一维的翻硬币游戏，每次可以翻1个或两个。通过单独考虑每个可以翻的硬币发现，Coin Turning Game的SG值和Nim等价，因此两个模型等价。需要注意的是，许多翻硬币游戏根据题目的要求，一般编号从0开始。
　　　　(2) 一维的翻硬币游戏，每次可以翻1个或两个，限定了翻第二枚硬币的范围，那么就和Subtraction Game等价了。
　　　　(3) 一维的翻硬币游戏，每次可以翻1个、2个或3个，这个游戏叫做Mock Turtles，有一个神奇的规律，是Odious Number序列。
　　　　(4) 高维的翻硬币游戏，需要用到Nim积和Tartan定理。
　　翻硬币模型的变化更多，很多模型都有一些奇妙的规律，需要打表才能发现。
　　经典模型3：删边游戏(Green Hackenbush)
　　　　(1) 树的删边游戏：Colon原理证明这种模型和Nim依然是等价的，多个叉的SG值异或就是对应根节点的SG值。
　　　　(2) 无向图删边游戏：利用Fursion定理收缩圈，然后就转换成树的删边游戏了，不过这个定理还不会证。

注：本文作于2009年8月3日 09点33分

sdfond 2010-02-06 08:55 发表评论

一个棋盘覆盖问题

sdfond — Sat, 12 Dec 2009 12:10:00 GMT

　　昨天看到名为“矩阵也疯狂”的帖子，老帖了，不过都是很有意思、很经典的题目。其中的第四题是说一个3*n的棋盘用1*2的棋子覆盖，求有多少种覆盖方法，结果模m，其中m、n < 2 ^ 32。
　　不考虑数据范围，一个O(n^2)的dp很容易想到，设f[n]是所求答案，n是奇数结果为0，否则有：
　　　　f[n] = f[n-2] * 3 + f[n-4] * 2 + f[n-6] * 2 + ...
　　一个2 * 3的棋盘有3种摆法，一个4*3的棋盘需要相互交错的摆放，因此有2种摆法，其余依次类推。
　　但是这个递推方程对于这样的数据量肯定是无法接受的。将方程进行化简：
　　　　f[n] = f[n-2] * 3 + (3 * f[n-4] + f[n-6] * 2 + ...) - f[n-4]
　　　　　　 = f[n-2] * 3 + f[n-2] - f[n-4]
　　　　　　 = 4 * f[n-2] - f[n-4]
　　这样就转化成了线性递推方程，可以用矩阵来做了。
　　话说这个题目我在HOJ上做的时候因为数据小就直接O(n^2)了，看来对于一个题目仔细思考、发散思维还是很重要的。
　　既然3*n的可以做，那么4*n应该也可以。后来发现居然还真有这个题：POJ 3420。4*n的递推方程为：
　　　　f[n] = f[n-1] + 4 * f[n-2] + 2 * f[n-3] + 3 * f[n-4] + 2 * f[n-5] + 3 * f[n-6] + ...
　　　　　　 = 5 * f[n-2] + 6 * f[n-3] + 5 * f[n-4] + 5 * f[n-5] + ...
　　　　　　 = 5 * f[n-2] + (5 * f[n-3] + 6 * f[n-4] + 5 * f[n-5] + ...) + f[n-3] - f[n-4]
　　　　　　 = 5 * f[n-2] + f[n-1] + f[n-3] - f[n-4]
　　后面的做法就一样了，算法复杂度(4 ^ 3 * log n)。

sdfond 2009-12-12 20:10 发表评论

POJ 2411 Mondriaan's Dream

sdfond — Fri, 31 Jul 2009 00:12:00 GMT

这个题目去年就过了，用得是状态压缩dp，不过没用dfs预处理，当时做得不是很明白，还是参考网上的一个代码做的。
现在重新做了一下这个题目，请教了icecream，学会了一个很简练的做法，而且比较好理解还好写。
首先还是状态的表示，用0表示没有放木块，用1表示放了木块。此外，对于一个横放的木块，对应的两位都用1表示；对于一个竖放的木块，第一行用1表示，第二行用0表示。这只是一种设状态的方式，当然还有别的设法，但是这种方法在接下来就会发现优点。

状态表示完就要处理转移了，如何判断一个转移是否合法比较难办，用一个dfs却可以简洁的解决这个问题。
对于上一行到下一行的转移，规定上一行一定填满，这样有三种方式：
    dfs(col + 1, (s1 << 1) | 1, s2 << 1, n);
    dfs(col + 1, s1 << 1, (s2 << 1) | 1, n);
    dfs(col + 2, (s1 << 2) | 3, (s2 << 2) | 3, n);
第一种上面是1，那么下面一定是0，表示是一个竖放的木块。
第二种上面是0，就是说这个位置一定是一个竖放木块的下半截，那么下一行肯定是要另起一行了，放一个竖放或者横放的木块都必须是1。
第三种相当于上下两行各放一个横木块。
实现的时候我用了一个vector记录每个状态所有可行的转移，这样在dp的时候可以加快一些效率。

还有一个问题需要考虑，那就是初值和最终的结果。如果寻找合法状态，依然比较麻烦，假设共有n行，可以分别在这n行上下新加两行。下面一行都是1，由于第n行肯定要填满，这样新加的全1的行就相当于顶住了第n行使其没有凸出（有凸出那么第n+1行有0），而通过第n行到第n+1行转移保留了所有合法状态；同理最上面加的那行保证第一行没有凸出。最后第n+1行对应全1的状态就是最终的结果了。通过新加行巧妙地解决了初值和终值。

实现的时候也需要注意一下，在TSP问题中，外层循环是状态，内层是点，之所以这样写因为在枚举点的时候，可能会从比当前编号大的点转移，但是由于无论怎样转移过来的状态肯定比当前状态小（去掉了1），所以先从小到大枚举状态就保证转移过来的状态一定是算过的。而这个题目里面正好反过来，因为状态可能从比当前状态大的状态转移过来，而行数肯定是从编号小的行转移，因此先枚举行就能保证转移过来的状态一定是更新过的。

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 11;

vector<int> g[1<<N];
long long dp[N+2][1<<N];

void dfs(int col, int s1, int s2, int n)
{
    if (col >= n)
    {
        if (s1 < (1 << n) && s2 < (1 << n))
            g[s2].push_back(s1);
        return;
    }
    dfs(col + 1, (s1 << 1) | 1, s2 << 1, n);
    dfs(col + 1, s1 << 1, (s2 << 1) | 1, n);
    dfs(col + 2, (s1 << 2) | 3, (s2 << 2) | 3, n);
}
long long calc(int m, int n)
{
    if (m < n)  swap(m, n);
    dfs(0, 0, 0, n);
    int state = 1 << n;

    dp[0][0] = 1;
    for (int i = 1; i <= m + 1; i++)
        for (int s = 0; s < state; s++)
            for (int j = 0; j < g[s].size(); j++)
                dp[i][s] += dp[i-1][g[s][j]];
    return dp[m+1][state-1];
}

int main()
{
    int m, n;

    while (scanf("%d %d", &m, &n) == 2)
    {
        if (m == 0 && n == 0)
            break;
        for (int i = 0; i < (1 << N); i++)
            g[i].clear();
        memset(dp, 0, sizeof(dp));
        printf("%I64d\n", calc(m, n));
    }

    return 0;
}

sdfond 2009-07-31 08:12 发表评论

最大M子段和

sdfond — Fri, 19 Jun 2009 03:18:00 GMT

　　给定n个数求这n个数划分成互不相交的m段的最大m子段和。
　　经典的动态规划优化的问题。设f(i, j)表示前i个数划分成j段，且包括第i个数的最大m子段和，那么有dp方程：
　　　　f(i, j) = max { f(i - 1, j) + v[i], max {f(k, j - 1) + v[i]}(k = j - 1 ... i - 1) }
　　也就是说第i个数要么自己划到第j段，要么和前一个数一起划到第j段里面，转移是O(n)的，总复杂度O(n * n * m)。
　　可以引入一个辅助数组来优化转移。设g(i, j)表示前i个数划分成j段的最大子段和（注意第i个数未必在j段里面），那么递推关系如下：
　　　　g(i, j) = max{g(i - 1, j), f(i, j)}，分是否加入第i个数来转移
　　这样f的递推关系就变成：
　　　　f(i, j) = max{f(i - 1, j), g(i - 1, j - 1)} + v[i]，转移变成了O(1)
　　这样最后的结果就是g[n][m]，通过引入辅助数组巧妙的优化了转移。实现的时候可以用一维数组，速度很快。

附HDU 1024题目代码：

#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 1000010, INF = 0x3fffffff;

int f[N], g[N], a[N];

int max_sum(int m, int n)
{
    int i, j, t;
    for (i = 1; i <= n; i++)
    {
        t = min(i, m);
        for (j = 1; j <= t; j++)
        {
            f[j] = max(f[j], g[j-1]) + a[i];
            g[j-1] >?= f[j-1];
        }
        g[j-1] >?= f[j-1];
    }
    return g[m];
}

int main()
{
    int m, n;

    while (scanf("%d %d", &m, &n) == 2 && m && n)
    {
        for (int i = 1; i <= n; i++)
        {
            f[i] = g[i] = -INF;
            scanf("%d", &a[i]);
        }
        printf("%d\n", max_sum(m, n));
    }

    return 0;
}

sdfond 2009-06-19 11:18 发表评论

USACO 3.4 Raucous Rockers

sdfond — Tue, 10 Mar 2009 07:31:00 GMT

终于通了第三章。

这个题目我设的三维状态，dp[i][j][k]表示前i个歌曲放在前j个唱片中第j个唱片用了k分钟的最大歌曲数。
转移方程：dp[i][j][k] = max{ dp[i-1][j][k-w[i]] + 1, dp[i-1][j][k], dp[i-1][j-1][p] } p = 0...t
跟背包问题差不多，就是加了一个唱片个数和容量的限制。三维状态一维转移，时间复杂度 O(n * m * t * t)

/*
ID: shyprom1
PROG: rockers
LANG: C++
*/
#include <cstdio>

int main()
{
    freopen("rockers.in", "r", stdin);
    freopen("rockers.out", "w", stdout);
    const int N = 32;
    int n, m, t, v, dp[N][N] = {0}, ans = 0;

    scanf("%d %d %d", &n, &t, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &v);
        for (int j = 1; j <= m; j++)
        {
            for (int k = t; k >= 0; k--)
            {
                for (int p = 1; p <= t; p++)
                    dp[j][k] >?= dp[j-1][p];
                if (k >= v)
                    dp[j][k] >?= dp[j][k-v] + 1;
            }
        }
    }
    for (int i = 0; i <= t; i++)
        ans >?= dp[m][i];
    printf("%d\n", ans);

    return 0;
}

sdfond 2009-03-10 15:31 发表评论