在线高清一区,欧美高清你懂得,免费在线一区二区

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

【概�q��?br>　　最�q�的几次比赛�Q�博弈的题目一直不��，而且博弈问题是一块比较复杂、庞大的内容�Q�因此在�q�里��结一下，希望能够帮自��q��清一些思�\�Q�争取也多来几个�p�d��Q�呵��c�?/p> 竞赛中出现的�l�合游戏问题一般都满��以下特征�Q?br>　　　　1. 二�h博弈游戏�Q�每个�h都采用对自己最有利的策略，�q�且是两个�h轮流做出决策
　　　　2. 在游戏中的�Q意时刻，每个玩家可选择的状态是固定的，没有随机成分
　　　　3. 游戏在有限步数内�l�束�Q�没有��^局出现
　　大部分的题目都满��上�q�条�Ӟ��因此�q�里只讨论在上述条�g范畴内的博弈问题。这�c�d��弈问题，通常�q�有若干分类。一�U�是规定�U�d��最后一步的游戏者获胜，�q�种规则叫做Normal Play Rule�Q�另一�U�是规定�U�d��最后一步的游戏者输�Q�这�U�规则叫�?span style="color: red;">Misere Play Rule�Q�也�U�CؓAnti-SG游戏。此外，对于游戏的双方，如果二者博弈的规则相同�Q�那么称��c�L��戏是对等(impartial games)的；否则�U�Cؓ不��^�{�游�?/span>(partizan games )。当初WHU的那场比赛就是由于对于这个概念不是很清晰�Q�导致看完题目之后就用SG定理来做�Q�浪费了很多机时。实际上�Q�解决不�q�等博弈问题的方法和普通的博弈问题�Q�SG游戏�Q�是有区别的�Q�一般会采用动态规划或者surreal number�?br>
【博弈基��知识�?br>　　在SG游戏中，最��Z�h熟知的是必胜必��|态，也叫NP态理论。注意的是，P态对应的是先手必败态，N态对应的是先手必胜态。必胜必败态理论是�Q?br>　　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
　　英文的表�q�非常简�z�清晎ͼ�而且�q�个理论也很好理解，如果在当前状态的下一步可以走到必败态，那么当前玩家��可以走到那个状态，把必败态推�l�另一方；如果所有可辄��态都是必胜态，那么当前玩家无论如何赎ͼ�都会把必胜态让�l�对斏V��根据必胜必败态理论，我们可以递归的求出每个状态是N态还是P态。必胜必败态理论其实已�l�把博弈问题转化成了一个有向图�Q�借助图这个模型来分析问题�Q��得问题变得�Ş象了许多。需要注意的是，�q�种SG游戏对应的有向图是无环的�Q�因为如果有环，那么游戏双方��可能在环上不停的�{换状态，游戏不能在有限步�l�止�Q�这样就不满��组合游戏的特征3了�?br>　　然而在很多时候仅仅知道某个状态是必胜�q�是必��|是不够的�Q�因为如果存在多个组合游戏（比如�l�典的Nim�Q�，对应的状态集合非常大�Q�无法直接利用必胜必败态理论求解，因此需要用到博弈论中一个很重要的工��P��SG函数�?br>　　某个状态的SG函数值定义�ؓ当前状态所有不可达的状态编号中最��的�~�号�Q�其中终止态的SG函数值是0。有了这个工��P��引入一个非常强大的定理——SG分解定理�Q?br>
　　多个�l�合游戏的SG函数值是每个�l�合游戏的函数值的和�?/span>�Q�这里的和定义�ؓ异或操作�Q?br>　　
　　SG分解定理的证明不是很难，其实和Nim的证明很像。根据这个定理，我们��q��道�ؓ什么Nim的解法是异或所有的矛_��个数了，因�ؓ每堆矛_��的SG值就是石子的个数。SG分解定理告诉我们��M��SG游戏都可以�{化成Nim游戏来做�?br>　　Nim中的一个变形就是拿走最后一块石子的人算输。通过修改SG的计��规则，可以得出相同的结论（因�ؓ当石子个数是1的时候SG��gؓ0�Q�因此要单独处理�Q�；当然也可以利用一个叫做SJ定理的方法来做，依然是要处理当所有堆的SG��g��大于1的情��c�?br>
【博弈基本模型�?br>　　除了Nim模型�Q�很多模型都看似复杂�Q�最后都划归��C��Nim模型上，然后利用SG分解来做的。在证明两种模型�{��h的时候，可以通过计算SG值判断是否相同，或者通过判断必胜�{�略的走法将其�{化�ؓNim。许多模型非常的��奇�Q�其莯��{�略又千差万别，因此无法一一列�D�Q�但是掌握一些经典模型是必须的，�q�样通过模型的�{化可以简化问题的隑ֺ��?br>　　�l�典模型1�Q�Nim变种�?/span>包括�Q?br>　　　　(1) 楼梯Nim。把奇数台阶的石子作为Nim�Q�二者等��P��因�ؓ必胜的策略是相同的�?br>　　　　(2) 每次可以取k堆，�q�个是经典的Moore Nim。它是泛化的Nim游戏�?br>　　　　(3) 两堆矛_��Q�每�ơ可以取一堆或两堆�Q�从两堆取得时候个数必��ȝ��同，谁先取完莯��。这个是著名的威佐夫博弈�Q�跟黄金分割数有养I��具体证明不是很清楚，但是用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。一�U�通用的Nim游戏�Q�每�ơ从可用状态集合中选择下一步的状态，有很多变形，核心思想�q�是计算SG函数倹{�?br>　　　　(5) Take-and-Break Game。每�ơ把局面分成多个Nim子游戏，利用SG分解定理求出对应的SG倹{�?br>　　�l�典模型2�Q�翻��币游戏(Coin Turning Game)
　　　　(1) 一�l�的��ȝ��币游戏，每次可以��?个或两个。通过单独考虑每个可以��ȝ��币发现�Q�Coin Turning Game的SG值和Nim�{��h�Q�因此两个模型等仗��需要注意的是，许多��ȝ��币游戏根据题目的要求�Q�一般编号从0开始�?br>　　　　(2) 一�l�的��ȝ��币游戏，每次可以��?个或两个�Q�限定了��ȝ��二枚��币的范��_��那么��和Subtraction Game�{��h了�?br>　　　　(3) 一�l�的��ȝ��币游戏，每次可以��?个�?个或3个，�q�个游戏叫做Mock Turtles�Q�有一个神奇的规律�Q�是Odious Number序列�?br>　　　　(4) 高维的翻��币游戏�Q�需要用到Nim�U�和Tartan定理�?br>　　��ȝ��币模型的变化更多�Q�很多模型都有一些奇妙的规律�Q�需要打表才能发现�?br>　　�l�典模型3�Q�删�Ҏ��?Green Hackenbush)
　　　　(1) 树的删边游戏�Q�Colon原理证明�q�种模型和Nim依然是等��L��Q�多个叉的SG值异或就是对应根节点的SG倹{�?br>　　　　(2) 无向囑ֈ��Ҏ��戏：利用Fursion定理收羃圈，然后��p�{换成树的删边游戏了，不过�q�个定理�q�不会证�?

注：本文作于2009�q?�?�?09�?3�?br>

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

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

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

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

POJ 2411 Mondriaan's Dream

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

�q�个题目��d��p��了，用得是状态压�~�dp�Q�不�q�没用dfs预处理，当时做得不是很明白，�q�是参考网上的一个代码做的�?br>现在重新做了一下这个题目，��h��了icecream�Q�学会了一个很��l�的做法�Q�而且比较好理解还好写�?br>首先�q�是状态的表示�Q�用0表示没有放木块，�?表示放了木块。此外，对于一个横攄��木块�Q�对应的两位都用1表示�Q�对于一个竖攄��木块�Q�第一行用1表示�Q�第二行�?表示。这只是一�U�设状态的方式�Q�当然还有别的设法，但是�q�种�Ҏ��在接下来��׃��发现优点�?/p>

状态表�C�完��p��处理转移了，如何判断一个�{�U�L��否合法比较难办，用一个dfs却可以简�z�的解决�q�个问题�?br>对于上一行到下一行的转移�Q�规定上一行一定填满，�q�样有三�U�方式：
    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);
�W�一�U�上面是1�Q�那么下面一定是0�Q�表�C�是一个竖攄��木块�?br>�W�二�U�上面是0�Q�就是说�q�个位置一定是一个竖放木块的下半截，那么下一行肯定是要另起一行了�Q�放一个竖放或者横攄��木块都必��L��1�?br>�W�三�U�相当于上下两行各放一个横木块�?br>实现的时候我用了一个vector记录每个状态所有可行的转移�Q�这样在dp的时候可以加快一些效率�?/p>

�q�有一个问题需要考虑�Q�那��是初值和最�l�的�l�果。如果寻扑֐�法状态，依然比较�ȝ��Q�假讑օ�有n行，可以分别在这n行上下新加两行。下面一行都�?�Q�由于第n行肯定要填满�Q�这��h��加的�?的行��q��当于��住了第n行��其没有凸出（有凸出那么第n+1行有0�Q�，而通过�W�n行到�W�n+1行�{�U�M��留了所有合法状态；同理最上面加的那行保证�W�一行没有凸出。最后第n+1行对应全1的状态就是最�l�的�l�果了。通过新加行��y妙地解决了初值和�l�倹{�?/p>

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

#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 发表评论

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

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

#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

�l�于通了�W�三章�?br>
�q�个题目我设的三�l�状态，dp[i][j][k]表示前i个歌曲放在前j个唱片中�W�j个唱片用了k分钟的最大歌曲数�?br>转移方程�Q�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
跟背包问题差不多�Q�就是加了一个唱片个数和定w��的限制。三�l�状态一�l��{�U�，旉��复杂�?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 发表评论