C++博客-Residence for sdfond-随笔分类-算法 - 组合数学

一道老题

sdfond — Fri, 12 Mar 2010 05:06:00 GMT

　　学弟问我的一个题目，去年本来做过，但是做的稀里糊涂，今天拿出来重新推导了一遍，特记录于此。
　　题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2971
　　先假设a2 = t, 题目给定了递推关系：An = 2 * t * An-1 - An-2 (n > 2)，初值A1 = 1, A2 = t；题目要求Sn = An ^ 2 + An-1 ^ 2 + ... + A1 ^ 2。
　　反复应用递推关系得到：
　　
　　然后Sn-1利用相同的方式展开，把4tAn-2An-3约去，得到：
　　
　　这样就比较容易得出Sn的通项：
　　

　　当初这个题目之所以没想到这种方法，就是因为一看到递推关系，就想着用一般解方程的方法去求解通项，思维被局限了，其实用简单的方式就可以推出来的。以后对于一个问题，应该从多个方面去想，不能想当然啊。想起最近看到的一段话，以此自勉：
　　正则表达式非常强大，但是它并不能为每一个问题提供正确的解决方案。你应该学习足够多的知识，以辨别什么时候它们是合适的，什么时候它们会解决你的问题，什么时候它们产生的问题比要解决的问题还要多。
　　一些人，遇到一个问题时就想：“我知道，我将使用正则表达式。”现在他有两个问题了。——Jamie Zawinski

sdfond 2010-03-12 13:06 发表评论

polya定理再小结

sdfond — Sat, 06 Feb 2010 13:46:00 GMT

摘要: 话说ICPC的题目是越来越难，因为经典的算法大家都知道了，因此出题的方向只能是要么把模型隐藏的很深，要么就把一系列算法知识综合起来考察，这个时候分析问题的能力和灵活运用知识的能力就显得尤为重要。
　　polya定理在很久以前的ICPC题目中就已经出现过，不过那个时候大家对于置换群都了解不多，因此polya定理算是很生僻的一个东西。然而人类总是飞速的进步，现在互联网上铺天盖地的题解使得polya定理走出深闺，逐渐被广大acmer所熟知。但是魔高一尺道高一丈，出题人也逐渐把polya定理的题出得越来越难做，越来越不好想。阅读全文

sdfond 2010-02-06 21:46 发表评论

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

UVa 3295 Counting Triangles

sdfond — Thu, 15 Oct 2009 11:54:00 GMT

好久不写了啊，最近打算重新启用这个blog。就先写这个题目吧，满经典的。
【题目大意】
　　m * n的区域内，每个整数坐标都有整点，问以这些整点为端点能够形成多少个三角形。（0 < m, n <= 1000）

【题目分析】
　　这个题目乍一看挺简单的，但是想做对还是要仔细的思考下的。补集转化的思想，求出所有共线的三元组，然后用总数减掉就是答案了，关键就是如何求共线三元组。x坐标相同和y坐标相同的比较好计算，在一条斜线的就不好算了，画个图发现，即使斜率相同的线，经过的格点数可能各不相同。思路当然还是枚举y / x（不同的y / x确定了不同的矩形区域），之后如何有效的计算，我采用的方法可能有些麻烦，有点类容斥的方法。以斜率为a / b为例，(a, b) = g，那么m * n的区域内一定有(m - a + 1) * (n - b + 1)个那么大的矩形，这样的矩形经过的格点数是(g + 1)；然后因为同等斜率小一点的矩形(a - a / g, b - b / g)也是存在的，个数同样可以统计出来，但是有些大矩形包括了，要去掉；因此就采用这种思想，先求出大矩形的个数，然后依次往下减，就可以避免重复计数了。虽然这样复杂度有点高，不过极限数据还是比较快的跑出来了。
　　说的可能不太清楚，具体代码如下：

1 #include <cstdio>
2 #include <iostream>
3 using namespace std;
4 const int N = 1024;
5
6 bool tag[N][N];
7 long long calc(long long n)
8 {
9     if (n <= 2)
10         return 0;
11     return n * (n - 1) * (n - 2) / 6;
12 }
13 int gcd(int a, int b)
14 {
15     return b == 0 ? a : gcd(b, a % b);
16 }
17
18 int main()
19 {
20     int m, n, g, a, b, timer = 1, cnt[N], ta, tb;
21     long long ans;
22
23     while (scanf("%d %d", &m, &n) == 2)
24     {
25         memset(tag, 0, sizeof(tag));
26         if (m == 0 && n == 0)
27             break;
28         ans = calc((m + 1) * (n + 1)) - calc(m + 1) * (n + 1) - calc(n + 1) * (m + 1);
29         for (int i = m; i >= 1; i--)
30             for (int j = n; j >= 1; j--)
31             {
32                 g = gcd(i, j);
33                 a = i / g, b = j / g;
34                 if (tag[a][b])      continue;
35                 memset(cnt, 0, sizeof(cnt));
36                 tag[a][b] = 1;
37                 a = i, b = j;
38                 ta = i / g, tb = j / g;
39                 for (int k = g; k >= 2; k--)
40                 {
41                     cnt[k] += (m - a + 1) * (n - b + 1);
42                     ans -= calc(k + 1) * cnt[k] * 2;
43                     for (int t = 1; t <= k - 2; t++)
44                         cnt[k-t] -= (t + 1) * cnt[k];
45                     a -= ta, b -= tb;
46                 }
47             }
48         cout << "Case " << timer++ << ": " << ans << endl;
49     }
50
51     return 0;
52 }
53

sdfond 2009-10-15 19:54 发表评论

HOJ 2550 Beijing 2008

sdfond — Thu, 18 Jun 2009 13:48:00 GMT

　　题目大意就是N个商店，M个人，每个人进入商店这个商店就赚n * d的钱，但是多个人只算一次钱。如果每个人进入每个商店的概率相同问最后所有商店期望的赚钱数是多少。
　　做得超级艰苦，最开始是列错了式子，推了一个上午，居然还推出了答案，发现是一个算组合数的式子，因此超时了。
　　下午请教了吉大牛，发现我算概率的时候考虑的不对，实际要用到容斥原理。于是又推了一个下午。。。最后式子终于对了但是求不出来和。
　　式子的列法是这样的：以M个人恰好进入了i个不同的商店作为概率分布，那么事件P(i)的概率为(i / N) ^ M - C(i, 1) * ((i - 1) / N) ^ M + C(i, 2) * ((i - 2) / N) ^ M - ...
　　也就是一个容斥原理。然后总的期望E = sigma{C(n, i) * P(i) * i * n * d}，i = 0 ... N。
　　这个式子列出来后怎么也求不出结果。晚上imems告诉了我一个很简单的推导方法。对于一个商店来说，一个人不去的概率是(N - 1) / N，那么M个人都不去的概率是((N - 1) / N) ^ M，用1减去这个结果就是肯定至少有人去这个商店的概率。然后总的期望就乘以N个商店，再乘以赚钱数n * d就可以了。很巧妙，因为他是从商店的角度直接考虑的问题，而不考虑商店的人数，这样就不用列概率分布了。
　　但是上面的公式就不能推导出正确结果了么，后来又推了一下，发现是可以的（照着结果猜- -!）。
　　具体的推导很麻烦，但是总的来说用到了组合数学的几个公式。首先 k * C(n, k) = n * C(n - 1, k - 1)，利用这个公式把外面的i消去。然后有pascal递推式：C(n, k) = C(n - 1, k) + C(n - 1, k - 1)。我们分别考虑(i / N) ^ M前面的系数，可以发现都是两个二项式系数相乘的方式。把其中的一个利用pascal公式展开后，出现了形如C(n, 0) - C(n, 1) + C(n, 2) - ...之类的式子，结果是0，消去了。剩下的还是两个二项式系数的乘积，不过都是这种形式的：C(n, k) * C(k, r)，它等于C(n, r) * C(n - 1, k - 1)。这样变形之后有一个公共项就可以提出去了，里面还是形如(1 - 1) ^ n的形式。这样结果就是0。在计算下一项的系数的时候，第一次展开后里面恰好包含了前一项的系数，直接就是0消去了，然后继续利用上面的方法展开。中间推导的过程中还需要添加一些值为0的项便于继续的推导。
　　这个方法很麻烦，不过推导过程中还是用到了很多知识的，就当复习了- -!其实这个推导要不是知道了最后的公式也不敢推，实在太麻烦，看来还是基本功欠缺啊，而且算概率的题目还是要多练习练习。另外注意思维的灵活性，其实简单做法不难想，但是最开始被吉大牛误导了，就用了一个严格的推导方法，独立思考还是很重要的。

题目代码：

1 #include <cstdio>
2 #include <cmath>
3
4 int main()
5 {
6     double N, M, n, d;
7
8     while (scanf("%lf %lf %lf %lf", &N, &M, &n, &d) == 4)
9         printf("%.3lf\n", n * d * N * (1.0 - pow(1.0 - 1.0 / N, M)));
10
11     return 0;
12 }
13

sdfond 2009-06-18 21:48 发表评论

POJ 1792 Hexagonal Routes

sdfond — Tue, 16 Jun 2009 14:12:00 GMT

【题目大意】
　　题目的大意是给定一个由许多六面形边挨着边组成的图形，从中心处开始标号为1，按照一个螺旋的方向标号依次增加。问从一个点到另一个点的最短路径的长度和数目。

【算法分析】
　　感觉满恶心的一个题目，需要疯狂的找规律。首先容易看出路径数是一个组合数，并且每一层都是模六循环的。但是怎样找到层数（也就是最短路径长度）呢？最开始想建立坐标系然后利用几何方法算出来，但是如何无论是笛卡尔坐标系还是极坐标系的建立都是困难的；然后想存图广搜，发现空间不够。后来发现，把图顺时针转90度，出现了一个很有意思的规律。以原点（数字为1）为中心建立坐标系，不过坐标的选取需要一些技巧。可以看出数字是一层层分布的，取x左边的点坐标为（-2，0），以后每往左增加一层，横坐标就变化2。其实和原点纵坐标相同且位于其左边的点恰好是每一层数字最大的结点！这样只要确定了这个点，可以按照逆时针的顺序依次给这一层的所有点的坐标推出来。这样，给定一个数字，我们可以根据每一层最大的数字推出这个数的坐标。
　　现在有了坐标（可以看成是曼哈顿坐标），就可以推测路径了。把两个数字的坐标求差，就可以看成是一个在原点了。坐标和路径的关系不是很好找，写了4、5行发现了一个很诡异的规律。先把坐标化成正的，然后发现x >= y的时候就是C( (x + y) / 2, y)，否则是C( y, (y - x) / 2)。之后就是高精度了。

题目代码：

  1 import java.util.*;
  2 import java.math.*;
  3
  4 class point
  5 {
  6     int x, y;
  7     public point(int x, int y)
  8     {
  9         this.x = x;
10         this.y = y;
11     }
12 }
13 class Main
14 {
15     public static void main(String[] args)
16     {
17         Scanner in = new Scanner(System.in);
18         int a, b, len;
19         BigInteger ans;
20         point pa, pb;
21
22         while (in.hasNext())
23         {
24             a = in.nextInt();
25             b = in.nextInt();
26             if (a == 0 && b == 0)
27                 break;
28             pa = GetCoordinate(a);
29             pb = GetCoordinate(b);
30             pa.x = pb.x - pa.x;
31             pa.y = pb.y - pa.y;
32             pa.x = pa.x < 0 ? -pa.x : pa.x;
33             pa.y = pa.y < 0 ? -pa.y : pa.y;
34             if (pa.x >= pa.y)
35             {
36                 len = (pa.x + pa.y) / 2;
37                 ans = C(len, pa.y);
38             }
39             else
40             {
41                 len = pa.y;
42                 ans = C(len, (pa.y - pa.x) / 2);
43             }
44             System.out.print("There ");
45             if (ans.compareTo(BigInteger.ONE) == 0)
46                 System.out.print("is 1 route");
47             else
48                 System.out.print("are " + ans + " routes");
49             System.out.println(" of the shortest length " + len + ".");
50         }
51     }
52     static BigInteger C(int n, int k)
53     {
54         BigInteger ret = BigInteger.ONE;
55         if (k > n - k)
56             k = n - k;
57         for (int i = 1; i <= k; i++)
58         {
59             ret = ret.multiply(new BigInteger(new String(n - i + 1 + "")));
60             ret = ret.divide(new BigInteger(new String(i + "")));
61         }
62         return ret;
63     }
64     static point GetCoordinate(int n)
65     {
66         int[][] dir = new int[][]{{1, -1}, {2, 0}, {1, 1}, {-1, 1}, {-2, 0}, {-1, -1}};
67         int i = 0, j = 0, k = 0, tx, ty, cnt = 0, delta;
68         point p = new point(0, 0);
69
70         if (n == 1)
71             return p;
72         for (i = 2; i <= 1000; i++)
73             if ((3 * i * i - 3 * i + 1) >= n)
74                 break;
75         delta = 3 * i * i - 3 * i + 1 - n;
76         i--;
77         tx = -2 * i;
78         ty = 0;
79         boolean flag = false;
80         for (j = 0; j < 6; j++)
81         {
82             for (k = 0; k < i; k++)
83             {
84                 if (cnt == delta)
85                 {
86                     flag = true;
87                     break;
88                 }
89                 cnt++;
90                 tx += dir[j][0];
91                 ty += dir[j][1];
92             }
93             if (flag)
94                 break;
95         }
96         p.x = tx;
97         p.y = ty;
98
99         return p;
100     }
101 }
102

sdfond 2009-06-16 22:12 发表评论

抽屉原理 - PKU 3370 & PKU 2356

sdfond — Fri, 12 Jun 2009 01:09:00 GMT

　　一个经典的问题：给定n个数，求其中的任意一个子集满足集合中的每个元素值加和正好是n的倍数。刚开始怎么也没有思路，因为n很大，直接搜索显然是不行的。后来在组合数学书上找到了这个例题（晕，之前白看了，居然把这个经典的题目都给忘了），是抽屉原理的典型应用。
　　假定n个数为a1，a2，...，an，前n项和分别是S1、S2、...、Sn，那么如果有一个Si模n是0，就是答案，否则，n个数模n的余数只能在1到n - 1之间，把余数作为抽屉，显然n个数放到n - 1个抽屉里面，肯定有两个数余数相等，这样取它们的差就得到了结果，算法复杂度是O(n)的。
　　抽屉原理的应用都十分巧妙。还有一个例子，一个屋子里面有n个人，他们的最大年龄不超过k岁，问是否肯定存在2组人（两组没有重复的人），使得这两组人的年龄和相等。n个人的组合一共有2 ^ n种方法，注意到最大情况n的人的年龄和是n * k，这样如果2 ^ n > n * k，根据抽屉原理，一定存在两种组合他们的年龄和相等，而且没有重复的人（如果重复，把那个人删去就行了）。所以O(1)的时间就判断出了结果。
　　不过在最开始做题目（PKU 2356）的时候，虽然代码很短，但是错了好多次。首先是数组开小了，然后发现输出的时候题目要求的是输出数但是我给输出下标了。最后的问题出在一个很关键的地方，在取模为零的时候，我本应该直接就记录产生了解，但是我以为取模为零的时候下次肯定会产生重复的标记，就没有特殊处理。其实如果第一个数取模就是0的话，就有可能后面不产生重复的标记，这样我的程序就错了，还有就是最后一个是取模为零的时候也会出问题。想了很久才想到这个问题，改正之后终于过了。以后写程序要仔细，不能想当然啊。
附PKU 2356代码：

#include <cstdio>
const int N = 10010;

int main()
{
    int a[N], n, mod[N] = {0}, tmp = 0, len = 0, pos;

    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        if (len)    continue;
        tmp = (tmp + a[i]) % n;
        if (tmp == 0)
        {
            len = i;
            pos = 1;
        }
        if (mod[tmp])
        {
            len = i - mod[tmp];
            pos = mod[tmp] + 1;
        }
        else
            mod[tmp] = i;
    }
    printf("%d\n", len);
    for (int i = 0; i < len; i++)
        printf("%d\n", a[pos+i]);

    return 0;
}

sdfond 2009-06-12 09:09 发表评论

球装盒问题的进一步分析

sdfond — Thu, 04 Jun 2009 08:13:00 GMT

　　假设现在有p个球放入k个盒子中，对于球和盒子的属性分别做限制，然后询问方法数。这里的属性限制分别包括：球是不是相同的，盒子是不是相同的，盒子是否为空。
　　首先看最简单的情况：盒子可以为空，球和盒子都是不同的。那么一共有k ^ p种放法。如果规定盒子是非空的，那么就需要利用容斥原理，设第i个盒子是空的为一种属性，那么分别计算一个盒子为空的方法数，两个盒子为空。。。然后利用容斥原理就行了。
　　现在规定球是不同的，盒子是相同的且盒子不能为空。这是第二类stirling数，S(p, k) = k * S(p - 1, k) + S(p - 1, k - 1)。如果规定盒子可以为空，那么就是第p个Bell数，也就是对第二类stirling数k从0到k求和。
　　如果盒子相同，球也相同，这时候盒子空不空都无所谓了，就是一个整数划分问题，非空的话先给每个盒子装一个球再算就行了。
　　最后一种情况是盒子不同，球相同，如果盒子可以为空，那么问题就变成了经典的x1 + x2 + ... + xk = p，x取值范围0到p的解的个数。这是经典的组合数学问题，利用隔板法求得答案是C(k + p - 1, p)。如果盒子非空，那么就是把x的取值范围变成1到p就行了，答案是C(p - 1, p - k)。

sdfond 2009-06-04 16:13 发表评论

HOJ 2645 WNim

sdfond — Tue, 02 Jun 2009 08:01:00 GMT

　　lord wu给去年省赛出的一个题目，今天终于给搞出来了。
　　一开始完全想错了方向，总是觉得很复杂。后来发现计算SG值的时候，对于限制的状态只能走到0，也就是必胜态，这样就是一个裸的SG分解的题目了。接下来就很简单了，利用容斥原理算出SG值，结论同Nim。
　　感觉博弈的题目做起来还是很困难的，一方面SG值的计算不容易，很多时候只能通过规约成一个经典模型来计算；另一方面博弈的题目变化多端，很难有什么规律可言。不过SG分解还是王道，用这个武器解决简单的博弈问题还是绰绰有余的。
附2645代码：

1 #include <cstdio>
2 const int N = 12;
3
4 int p[N], ans;
5 long long gcd(long long a, long long b)
6 {
7     return b == 0 ? a : gcd(b, a % b);
8 }
9 void calc_sg(long long tol, int m, int dep, long long v, bool mark)
10 {
11     if (dep == m)
12     {
13         if (mark)   ans -= tol / v;
14         else        ans += tol / v;
15         return;
16     }
17     calc_sg(tol, m, dep + 1, v, mark);
18     if (v <= tol)
19         calc_sg(tol, m, dep + 1, v / gcd(v, p[dep]) * p[dep], mark ^ 1);
20 }
21
22 int main()
23 {
24     int T, m, n, a, g;
25
26     scanf("%d", &T);
27     while (T--)
28     {
29         g = 0;
30         bool mark = 1;
31         scanf("%d %d", &m, &n);
32         for (int i = 0; i < m; i++)
33             scanf("%d", &p[i]);
34         for (int i = 0; i < n; i++)
35         {
36             scanf("%d", &a);
37             if (!mark)  continue;
38             ans = 0;
39             calc_sg(a, m, 0, 1, 0);
40             g ^= ans;
41             for (int j = 0; j < m; j++)
42                 if (a % p[j] == 0)
43                 {
44                     mark = 0;
45                     break;
46                 }
47         }
48         if (!mark)  puts("Xiao Hong");
49         else    printf("%s\n", g ? "Xiao Hong" : "Xiao Gang");
50     }
51
52     return 0;
53 }
54

sdfond 2009-06-02 16:01 发表评论

polya定理小结

sdfond — Tue, 12 May 2009 03:20:00 GMT

　　polya定理是组合数学中比较难的一部分。首先需要对置换群、集合论有一定的了解，这样有助于理解burnside引理的证明。其次，polya定理只是对于在环上存在旋转、反射等等价的变换的一种计数方法，实际的题目中很多需要其他的知识来进行辅助。
　　环上的计数主要就是处理置换 -> 着色这种情况。很关键的一点是同一循环内着色相同。因此很多题目就在置换和着色上下文章。
　　最最简单的polya定理题目是置换数目很少，每种颜色不限，这种情况下只需手工数出所有的置换就可以了，一般就是一个公式。
　　难一点的要么是颜色数有限，需要用排列组合的知识或动态规划来帮助计数；要么是置换非常多，需要利用数论的知识来优化。当然还有其他的题型，比如对于相邻着色的限制，这样的题目就很困难了。

polya题目：
HOJ 2084 The Colored Cubes
HOJ 2647 Megaminx
POJ 1286 Necklace of Beads
POJ 2409 Let it Bead
TOJ 2795 The Queen's New Necklaces
HDU 1812 Count the Tetris
UVa 11255 Necklace
POJ 2154 Color
POJ 2888 Magic Bracelet
UVa 10601 Cubes
NUAA 1110

sdfond 2009-05-12 11:20 发表评论

n阶常系数线性递推方程矩阵解法

sdfond — Fri, 08 May 2009 14:08:00 GMT

n阶常系数线性齐次递推关系的解法有很多，特征方程法、生成函数法，但是对于编程最实用的是矩阵解法。
我们定义所要求的f(n) = Ak-1 * f(n - 1) + Ak-2 * f(n - 2) + ... + A0 * f(n-k)，其中f(0)...f(k-1)的初值已经给好。
构造k * k的矩阵M：

其中A =(Ak-1 Ak-2 ... A1)，I是单位矩阵。
然后构造一个k * 1列向量b：

这样，M * b之后b0的值就是f(k)，以此类推，M ^ n * b之后b0的值就是f(k-1+n)，算法复杂度O(k ^ 3 * logn)。

sdfond 2009-05-08 22:08 发表评论

组合数学小结

sdfond — Mon, 04 May 2009 01:17:00 GMT

主要分成以下几个部分：
　　排列组合与容斥原理
　　二项式定理
　　递推关系与生成函数
　　polya定理

1.排列组合与容斥原理
排列组合里面的4个重要的基本原理：加法原理、乘法原理、减法原理、除法原理
前面两个最为基本，后面两个是根据前两个派生出来的。乘法原理有的时候的应用很巧妙，可以作为一种打开思路的办法。
基本的排列组合之后，接下来引出了多重集。多重集的排列组合是一个很经典的问题，总结如下：
多重集的排列：
　　全排列的话只需应用除法原理就可以了。n个元素的多重集的r排列需要利用指数生成函数来做。
多重集的组合：
　　n个元素的多重集的r组合，如果r小于等于任何一个元素可选的个数，那么就归结为经典的不定方程的解数问题，可以利用“隔板法”来做。结果就是一个组合数。如果r大于某些元素的可选个数，那么一种方法是利用容斥原理，一种方法还是要依靠生成函数（编程序的时候可以用动归做）。
如果是一个环形的排列组合，那么问题就困难许多，要利用置换群和polya定理。
　　单纯的依靠四项基本原理来计数，有的时候会显得力不从心，这个时候就需要容斥原理的帮助。容斥原理特别适合解决若干限制条件的交、并问题，也是打开思路的一种方法。
　　利用容斥原理解决的经典问题有：错排问题，带禁止位置的排列。禁位排列总觉得用容斥原理解决的不够优美，不知道有没有可以编程的数学方法。还有一个困惑的问题就是容斥原理和mobius反演的关系，那个地方好晦涩。。
　　跟排列组合相关的还有就是生成排列和组合。生成排列利用那个什么字典序法好像足够了，编程好实现。生成组合方法类似。

2.二项式定理
有很多公式，用的时候可以现查。终于知道了三角形数原来跟排列组合有关，而且是一个很简洁的公式。
很多公式的推导用的思想很妙。有一个很好的思想就是把(1 + x) ^ n利用二项式定理展开，然后求导、求积分，居然可以导出很多不可思议的公式。
还有一个很重要的定理就是pascal定理，pascal递推式很有用（展开后有两种形式，一种是上下限均不定，一种是下限不定），可以解决很多组合数的求和问题。
另外一个重要的定理就是牛顿二项式定理，在生成函数中应用广泛，可就是推导起来有点繁。

3.递推关系和生成函数
　　求解线性递推关系的特征方程的方法还是有一定价值的，但是编程不适用。n解线性齐次递推方程有矩阵解法。稍微复杂点的递推关系（非线性），特征方程就不够用了，必须祭出生成函数这个有力的武器。感觉生成函数实在是太优美、太强大了。生成函数的关键就是要把多项式拆分成(1-rx)^n这种形式，这样就可以利用牛顿二项式定理展开了。
　　在特殊计数序列里面提到了盒装球问题。将p个不同的球放入k个相同的盒子（每个盒子非空）的方法数是第二类Stirling数S(p, k)；将p个相同的球放入k个相同的盒子（每个盒子非空）的方法数是分拆数，可以归结为整数划分问题，用动态规划求解；将p个不同的盒子放入不同的k个盒子并且每个非空的方法数为k! * S(p, k)。
　　有几个很经典的递推关系：斐波那契数列、Catalan数（几种经典的形式：三角剖分数、二叉生成树个数、+1-1序列、加括号序列等等）、Stirling数（两种，第二种比较常用）、汉诺塔、n个圆切割平面数、n条直线k个交点切割平面数等等。此外，格路径中提到的平移、反射和一一对应这三种分析问题的方法也很值得借鉴。

4.polya定理

比较复杂，过一阵子好好总结下。

sdfond 2009-05-04 09:17 发表评论

Dilworth定理

sdfond — Thu, 30 Apr 2009 01:12:00 GMT

偏序集的两个定理：
定理1 令（X,≤）是一个有限偏序集，并令r是其最大链的大小。则X可以被划分成r个但不能再少的反链。
其对偶定理称为Dilworth定理：
定理2 令（X,≤）是一个有限偏序集，并令m是反链的最大的大小。则X可以被划分成m个但不能再少的链。
说白了就是链的最少划分数=反链的最长长度
相关的题目有pku 1065，pku 3636，pku 1548。
这三个题目可以归结为：
　　给定n个二元组(x, y)，问存在最少多少个划分使得每个划分里面的二元组都满足x1 <= x2并且y1 <= y2。
　　如果定义x1 <= x2 && y1 <= y2为偏序关系的话，那么问题就转化成求这个集合的链的最少划分数。可以通过找最长反链长度来解决，这里的反链关系是x1 > x2 || y1 > y2。如果把n个二元组按照x递增排序，相同的x按照y递增排序，那么我们只需对y找到一个最长递减子序列就是所求的答案，复杂度O(nlogn)。对于相同的x之所以按照y递增排序是因为这里偏序关系带等号，这样相同的x其实可以划分到一起，把y按照递增排序就可以使得相同的x最多只选择一个y。
　　还有的题目要求满足x1 < x2 && y1 < y2，这就需要把偏序关系相应修改。修改之后对于相同的x，每一个都会被划分到不同的集合（因为相等是不满足偏序关系的），所以这里的排序关系要改一下，x相同的y要按照降序排列，这样求一个最长不递增子序列就是答案，y递减保证可能会有多个x相同的二元组选入到结果中。
　　可惜对于贪心做法的正确性依然想不出来>.<

sdfond 2009-04-30 09:12 发表评论

PKU 3270

sdfond — Fri, 17 Apr 2009 01:05:00 GMT

　　做得很郁闷的一道题。我开始已经想到是要用置换来算，但是提交后总是WA。查代码查了N久也没有发现错误，感觉算法又没有问题。后来找到往年的解题报告，才发现我的基本思路没错，但是少考虑了一种情况。我之前认为最小代价等于一个置换内所有元素和 +（元素个数-2）* 置换内最小元素。但是解题报告说还有一种可能是这个置换内的最小元素和整个数列的最小元素交换，然后利用那个最小元素进行交换。这的确会产生更优的解，我原来怎么想不到呢！
题目代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 10010;

struct Node
{
    int v, id;
};
Node arr[N];

bool cmp(const Node &n1, const Node &n2)
{
    return n1.v < n2.v;
}
int main()
{
    int n, mine, cnt, pos, tol, ans, tmp, mini;
    bool tag[N];

    while (scanf("%d", &n) == 1)
    {
        mini = 0x3fffffff;
        memset(tag, 0, sizeof(tag));
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i].v);
            mini  arr[i].v;
            arr[i].id = i;
        }
        sort(arr, arr + n, cmp);
        ans = 0;
        for (int i = 0; i < n; i++)
        {
            if (tag[i])
                continue;
            if (i == arr[i].id)
                continue;
            pos = i;
            mine = arr[i].v;
            cnt = 0;
            tol = mine;
            while (arr[pos].id != i)
            {
                cnt++;
                pos = arr[pos].id;
                tag[pos] = 1;
                tol += arr[pos].v;
                mine  arr[pos].v;
            }
            tmp = tol + (cnt - 1) * mine;
            tmp  tol + mine + (cnt + 2) * mini;
            ans += tmp;
        }
        printf("%d\n", ans);
    }

    return 0;
}

sdfond 2009-04-17 09:05 发表评论