C++博客-y @ The Angry Teletubbies-文章分类-Number Theory && Math

hdoj 4050 wolf5x - 期望 + dp

y @ The Angry Teletubbies — Wed, 25 Jul 2012 15:46:00 GMT

【题意】：跳格子，左右脚轮流跳，不能往回跳，每次跳有个[A , B]步长范围。每个格子可能出现四种状态，可右脚进，左脚进，双脚进，不准进。每种状态都有一定概率。每次只能跳到最近可行的格子。当跳出了n个格子或者不能动时期望步数。

【题解】：期望类题目，无环，直接dp。
利用全期望公式，注意状态枚举时要乘上条件概率。然后按常规期望做法即可，倒着推。答案为dp[0][3]。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 #define pb push_back
17 #define mp make_pair
18 #define fi first
19 #define se second
20 #define sof(x) sizeof(x)
21 #define lc(x) (x << 1)
22 #define rc(x) (x << 1 | 1)
23 #define lowbit(x) (x & (-x))
24 #define ll long long
25
26 double dp[4010][4];
27 double p[4010][4];
28 int n, a, b;
29 int main() {
30     int T;
31     scanf("%d", &T);
32     while(T--) {
33         scanf("%d%d%d", &n, &a, &b);
34         memset(p, 0, sizeof(p));
35         memset(dp, 0, sizeof(dp));
36         for(int i = 1; i <= n; i++)
37             scanf("%lf%lf%lf%lf", &p[i][0], &p[i][1], &p[i][2], &p[i][3]);
38         for(int i = n + 1; i <= n + a; i++) p[i][3] = 1.0;
39         double c = 1.0;
40         for(int i = n; i >= 0; i--) {
41             for(int j = 1; j < 4; j++) {
42                 double pp = 1.0;
43                 for(int k = a; k <= b; k++) {
44                     if(j == 1) {
45                         dp[i][1] += pp * ((dp[i+k][2] + c) * p[i+k][2] + (dp[i+k][3] + c) * p[i+k][3]);
46                         pp *= (p[i+k][0] + p[i+k][1]);
47                     } else if(j == 2) {
48                         dp[i][2] += pp * ((dp[i+k][1] + c) * p[i+k][1] + (dp[i+k][3] + c) * p[i+k][3]);
49                         pp *= (p[i+k][0] + p[i+k][2]);
50                     } else if(j == 3) {
51                         dp[i][3] += pp * ((dp[i+k][1] + c) * p[i+k][1] + (dp[i+k][2] + c) * p[i+k][2] + (dp[i+k][3] + c) * p[i+k][3]);
52                         pp *= (p[i+k][0]);
53                     }
54                 }
55             }
56         }
57         printf("%.6f\n", dp[0][3]);
58     }
59     return 0;
60 }
61

y @ The Angry Teletubbies 2012-07-25 23:46 发表评论

hdoj 4219 Randomization - 树dp + 概率

y @ The Angry Teletubbies — Mon, 23 Jul 2012 08:23:00 GMT

【题意】：给定一棵树，给定边权的区间[0,L]，求最终树的最长路<=S的概率；

【题解】：武大校赛的树dp，放了好久，看着题解勉强过了。只可以说我的树dp太水了，还停留在背包的阶段。
设状态dp[i][j]表示以i为根的子树，其叶子结点到i的最长距离为j且该子树最长路径不超过s的概率。
对于u的一个子树v，先枚举u连v的长度，然后再把之前的子树和v这条链合并，好复杂，不会表达了，直接研究代码吧。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 #define maxn 70
22 #define maxs 530
23 int n, l, s;
24 double dp[maxn][maxs];
25 double son[maxs], tmp[maxs];
26 double e;
27 vector<int> vec[maxn];
28 void dfs(int u, int fa) {
29     memset(dp[u], 0, sizeof(dp[u]));
30     dp[u][0] = 1.0;
31     int size = vec[u].size();
32     for(int i = 0; i < size; i++) {
33         int v = vec[u][i];
34         if(v == fa) continue;
35         dfs(v, u);
36         memset(son, 0, sizeof(son));
37         memset(tmp, 0, sizeof(tmp));
38         for(int j = 0; j <= l; j++)
39             for(int k = 0; k <= s; k++)
40                 if(j + k <= s)
41                     son[j+k] += e * dp[v][k];
42         for(int j = 0; j <= s; j++)
43             for(int k = 0; k <= s - j; k++)
44                 tmp[max(j, k)] += son[j] * dp[u][k];
45         for(int j = 0; j <= s; j++)
46             dp[u][j] = tmp[j];
47     }
48 }
49
50 int main() {
51     int T, Case = 1;
52     scanf("%d", &T);
53     while(T--) {
54         scanf("%d%d%d", &n, &l, &s);
55         for(int i = 0; i <= n; i++) vec[i].clear();
56         e = 1.0 / (1.0 + l);
57         for(int i = 1; i < n; i++) {
58             int a, b;
59             scanf("%d%d", &a, &b);
60             vec[a].pb(b);
61             vec[b].pb(a);
62         }
63         dfs(1, -1);
64         double ans = 0.0;
65         for(int i = 0; i <= s; i++) ans += dp[1][i];
66         printf("Case %d: %.6f\n", Case++, ans);
67     }
68     return 0;
69 }
70

y @ The Angry Teletubbies 2012-07-23 16:23 发表评论

zoj 3582 Back to the Past - 期望 + dp

y @ The Angry Teletubbies — Thu, 19 Apr 2012 08:20:00 GMT

【题意】：略。

【题解】：设dp[i][j]表示左边有i个洞亮，右边有j个洞亮离目标状态的期望。
然后所有dp[ii][jj](ii >= i && jj >= j)都是dp[i][j]的后继状态，由期望计算公式可以算出dp[i][j]的期望。
这里转移会有个环，移项即可处理掉。
要先预处理组合数、p的幂和(1-p)的幂。
最后答案即为dp[0][0].
用记忆化搜索来写非常方便。

【代码】：

y @ The Angry Teletubbies 2012-04-19 16:20 发表评论

uva 5811 Cards - 期望 + dp

y @ The Angry Teletubbies — Thu, 19 Apr 2012 06:25:00 GMT

【题意】：略

【题解】：期望dp，如果不考虑joker就变得非常简单。但现在joker可以变成任意花色，所以如果当前翻到joker需要枚举这个joker变成什么花色，取最小的期望即可。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 int aa, bb, cc, dd;
22 double dp[16][16][16][16][5][5];
23 bool visit[16][16][16][16][5][5];
24
25 double dfs(int a, int b, int c, int d, int big, int small) {
26     double &tmp = dp[a][b][c][d][big][small];
27     if(visit[a][b][c][d][big][small]) return tmp;
28     visit[a][b][c][d][big][small] = true;
29     int now[] = {a, b, c, d};
30     if(big != 4) now[big]++;
31     if(small != 4) now[small]++;
32     if(now[0] >= aa && now[1] >= bb && now[2] >= cc && now[3] >= dd) return tmp = 0.0;
33     tmp = 1.0;
34     double sum = now[0] + now[1] + now[2] + now[3];
35     if(a < 13) tmp += dfs(a + 1, b, c, d, big, small) * (13.0 - a) / (54.0 - sum);
36     if(b < 13) tmp += dfs(a, b + 1, c, d, big, small) * (13.0 - b) / (54.0 - sum);
37     if(c < 13) tmp += dfs(a, b, c + 1, d, big, small) * (13.0 - c) / (54.0 - sum);
38     if(d < 13) tmp += dfs(a, b, c, d + 1, big, small) * (13.0 - d) / (54.0 - sum);
39     if(big == 4) {
40         double tmp1 = 1e100;
41         tmp1 = min(tmp1, dfs(a, b, c, d, 0, small) / (54.0 - sum));
42         tmp1 = min(tmp1, dfs(a, b, c, d, 1, small) / (54.0 - sum));
43         tmp1 = min(tmp1, dfs(a, b, c, d, 2, small) / (54.0 - sum));
44         tmp1 = min(tmp1, dfs(a, b, c, d, 3, small) / (54.0 - sum));
45         tmp += tmp1;
46     }
47     if(small == 4) {
48         double tmp1 = 1e100;
49         tmp1 = min(tmp1, dfs(a, b, c, d, big, 0) / (54.0 - sum));
50         tmp1 = min(tmp1, dfs(a, b, c, d, big, 1) / (54.0 - sum));
51         tmp1 = min(tmp1, dfs(a, b, c, d, big, 2) / (54.0 - sum));
52         tmp1 = min(tmp1, dfs(a, b, c, d, big, 3) / (54.0 - sum));
53         tmp += tmp1;
54     }
55     return tmp;
56 }
57
58 int main() {
59     int T, Case = 1;
60     cin >> T;
61     while(T--) {
62         cin >> aa >> bb >> cc >> dd;
63         int cnt = 0;
64         cnt += max(aa - 13, 0);
65         cnt += max(bb - 13, 0);
66         cnt += max(cc - 13, 0);
67         cnt += max(dd - 13, 0);
68         printf("Case %d: ", Case++);
69         if(cnt > 2) printf("-1.000\n");
70         else {
71             memset(visit, false, sizeof(visit));
72             printf("%.3f\n", dfs(0, 0, 0, 0, 4, 4));
73         }
74     }
75     return 0;
76 }
77

y @ The Angry Teletubbies 2012-04-19 14:25 发表评论

poj 2635 The Embarrassed Cryptographer - 线性筛素数 + 分割数字求模

y @ The Angry Teletubbies — Tue, 20 Mar 2012 05:50:00 GMT

【题意】：给出一个数k(4<=k<=10¹⁰⁰)和L(L<=10⁶)，问k的最小质因数是否小于L。

【题解】：显然我们只关心质因数，所以先对L求出它的所有质因数。
然后就是判断这些质因数是否能够整除k，如果用十进制高精度去求模会TLE。
考虑到进制越大，运算的次数就越少。因此我们可以更高的进制。
我测试了两种进制，1000进制时800+MS，10000000000进制时500+MS。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 #define maxn 110
22 #define maxl 1000050
23 char s[maxn];
24 int l, cnt;
25 int prime[100000], pn;
26 ll val[maxn];
27
28 void getprime() {
29     bool isprime[maxl];
30     memset(isprime, true, sizeof(isprime));
31     pn = 0;
32     for(ll i = 2; i < maxl; i++) {
33         if(isprime[i]) {
34             prime[pn++] = i;
35             for(ll j = i * i; j < maxl; j += i) isprime[j] = false;
36         }
37     }
38 }
39
40 void work() {
41     int len = strlen(s);
42     ll res = 0;
43     cnt = 0;
44     for(int i = 0; i < len % 10; i++) {
45         res *= 10;
46         res += s[i] - '0';
47     }
48     val[cnt++] = res;
49     for(int i = len % 10; i < len; i += 10) {
50         res = 0;
51         for(int j = i; j < i + 10; j++) {
52             res *= 10;
53             res += s[j] - '0';
54         }
55         val[cnt++] = res;
56     }
57 }
58
59 int main() {
60     getprime();
61     while(~scanf("%s%d", s, &l)) {
62         if(s[0] == '0' && l == 0) break;
63         work();
64         bool flag = true;
65         int len = (strlen(s) + 9) / 10;
66         for(int i = 0; i < pn && prime[i] < l; i++) {
67             ll res = 0;
68             for(int j = 0; j < cnt; j++) {
69                 res = res * 10000000000LL + val[j];
70                 res %= prime[i];
71             }
72             if(res == 0) {
73                 printf("BAD %d\n", prime[i]);
74                 flag = false;
75                 break;
76             }
77         }
78         if(flag) printf("GOOD\n");
79     }
80     return 0;
81 }
82

y @ The Angry Teletubbies 2012-03-20 13:50 发表评论

poj 2689 Prime Distance - 线性筛素数 + 求大区间素数

y @ The Angry Teletubbies — Sun, 26 Feb 2012 15:48:00 GMT

【题意】：给出一个L和R，L和R最大差值为100W，问区间[L,R]内相邻的素数最大差值和最小差值分别为多少。(1<=L2,147,483,647)

【题解】：这题好经典，当年新生赛也出了这题，不过做不出，直到今天终于给我做出来了。
这题需要知道一个定理，就是对于每一个合数a，其必定存在小于等于根号a的质因子。
所以对于一个数a我们只需要检查他有没有小于等于根号a的质因子即可。
考虑到根号2,147,483,647大约是47000，所以我们先筛选出47000以内的素数，大约5000个。
然后再用这5000个素数去筛选给定区间内的素数。
最后枚举一次求答案即可。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define lc(x) (x << 1)
15 #define rc(x) (x << 1 | 1)
16 #define lowbit(x) (x & (-x))
17 #define ll long long
18 #define MAX 1000050
19 ll prime[5500], rec[MAX];
20 int tot, cnt;
21 bool isprime[MAX];
22 ll l, r;
23 void init() {
24     tot = 0;
25     memset(isprime, true, sizeof(isprime));
26     prime[tot++] = 2;
27     for(int i = 3; i < 50000; i += 2) {
28         if(isprime[i]) {
29             prime[tot++] = i;
30             if(i * i < 50000) {
31                 for(int j = i + i; j < 50000; j += i) isprime[j] = false;
32             }
33         }
34     }
35 }
36
37 int main() {
38     init();
39     while(~scanf("%lld%lld", &l, &r)) {
40         if(l < 2) l = 2;
41         cnt = 0;
42         memset(isprime, true, sizeof(isprime));
43         for(int i = 0; i < tot && prime[i] * prime[i] <= r; i++) {
44             ll tmp = l / prime[i] * prime[i];
45             if(tmp < l) tmp += prime[i];
46             if(tmp == prime[i]) tmp += prime[i];
47             for(ll j = tmp; j <= r; j += prime[i]) isprime[j-l] = false;
48         }
49         for(int i = 0; i <= r - l; i++)
50             if(isprime[i]) rec[cnt++] = i + l;
51
52         if(cnt < 2) printf("There are no adjacent primes.\n");
53         else {
54             int idx1 = 1, idx2 = 1;
55             for(int i = 1; i < cnt; i++) {
56                 if(rec[i] - rec[i-1] < rec[idx1] - rec[idx1-1]) idx1 = i;
57                 if(rec[i] - rec[i-1] > rec[idx2] - rec[idx2-1]) idx2 = i;
58             }
59             printf("%lld,%lld are closest, %lld,%lld are most distant.\n", rec[idx1-1], rec[idx1], rec[idx2-1], rec[idx2]);
60         }
61     }
62     return 0;
63 }
64

y @ The Angry Teletubbies 2012-02-26 23:48 发表评论

hdoj 3944 DP？ - 求大组合数 + Lucas定理

y @ The Angry Teletubbies — Thu, 02 Feb 2012 14:42:00 GMT

【题意】：给出一个杨辉三角，问从最左上角到第n行第k列的一条路径中，所经过的数值和最小是多少。路径需满足当前的位置只能移动到它下方的第一个数或正对角线的第一个数。

【题解】：一开始以为是个dp，发现n,k都很大，肯定是数学题了。
很容易发现杨辉三角具有对称性，所以我们只需要研究k <= n / 2的情况。
利用贪心思想，每次都往左上方转移直到去到第0列，然后最后全部往上转移直到最上方。
容易得出公式：
ans = C(n, k) + C(n-1, k-1) + …… + C(n-k+1, 1) + C(n-k, 0) + n - k
把 C(n-k, 0) 换成 C(n-k+1, 0)，由公式 C(n, k) = C(n-1, k) + C(n-1, k-1) 可以进行化简
化简后得：
ans = C(n+1, k) + n - k

推出答案我很开心，以为接下来就没了，可是我发现n很大，普通求组合数会TLE，逼于无奈，我搜了一下，发现了Lucas定理。
至于什么是Lucas定理，大家自己百度吧。
用了定理刚开始还是TLE，因为case高达10W，还要打表记下模每个素数的阶乘，最后终于过了。

【代码】：

y @ The Angry Teletubbies 2012-02-02 22:42 发表评论

hdoj 2243 考研路茫茫——单词情结 - ac自动机 + 矩阵快速幂 + 快速幂 + 二分

y @ The Angry Teletubbies — Mon, 17 Oct 2011 09:24:00 GMT

摘要: 【题意】：给定n个词根，求长度不超过L，至少包含一个词根的字符串的数目。【题解】：可以从对立角度来想，就是先求出所有字符串的数目，再减去不包含任一词根的字符串的数目。字符串总数为26^1 + 26^2 + …... 阅读全文

y @ The Angry Teletubbies 2011-10-17 17:24 发表评论

poj 2778 DNA Sequence - ac自动机 + 矩阵快速幂 + 转化为求L步长的方案数

y @ The Angry Teletubbies — Mon, 17 Oct 2011 09:04:00 GMT

【题意】：给定你m个病毒串，求长度为n的不包含任意一个病毒串的种数。

【题解】：用ac自动机构造一个DFA（既有确定性的状态转移图），然后用矩阵快速幂求解。

【代码】：

  1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 using namespace std;
  5 #define ll long long
  6 const ll MOD = 100000;
  7 const int kind = 4;
  8 const int maxn = 500;
  9 #define MAX 105
10 int root, tot;
11 int n, m;
12 int que[maxn], head, tail;
13 bool visit[maxn];
14 struct Node {
15     int child[kind];
16     int fail;
17     int end;
18     void init() {
19         memset(child, 0, sizeof(child));
20         fail = -1, end = 0;
21     }
22 } T[maxn];
23
24 void init() {
25     root = tot = 0;
26     T[root].init();
27 }
28
29 int hash(char ch) {
30     if(ch == 'A') return 0;
31     else if(ch == 'C') return 1;
32     else if(ch == 'G') return 2;
33     else return 3;
34 }
35
36 void insert(char *s) {//插入单词
37     int p = root, index;
38     while (*s) {
39         index = hash(*s);
40         if (!T[p].child[index]) {
41             T[++tot].init();
42             T[p].child[index] = tot;
43         }
44         p = T[p].child[index];
45         s++;
46     }
47     T[p].end = 1;
48 }
49
50 void build_ac_auto() {
51     head = tail = 0;
52     que[tail++] = root;
53     while (head < tail) {
54         int u = que[head++];
55         for (int i = 0; i < kind; i++) {
56             if (T[u].child[i]) {
57                 int son = T[u].child[i];
58                 int p = T[u].fail;
59                 if (u == root) T[son].fail = root;
60                 else {
61                     T[son].fail = T[p].child[i];
62                     T[son].end |= T[T[son].fail].end;
63                 }
64                 que[tail++] = son;
65             } else {//trie图，设定虚拟节点
66                 int p = T[u].fail;
67                 if (u == root) T[u].child[i] = root;
68                 else T[u].child[i] = T[p].child[i];
69             }
70         }
71     }
72 }
73
74 struct Mat {
75     ll val[MAX][MAX];
76     void unit() {
77         zero();
78         for(int i = 0; i < MAX; i++) val[i][i] = 1;
79     }
80     void zero() {
81         memset(val, 0, sizeof(val));
82     }
83 }x;
84
85 Mat operator *(const Mat &a, const Mat &b) {
86     Mat tmp;
87     tmp.zero();
88     for(int k = 0; k <= tot; k++) {
89         for(int i = 0; i <= tot; i++) {
90             if(a.val[i][k])
91                 for(int j = 0; j <= tot; j++) {
92                     tmp.val[i][j] += a.val[i][k] * b.val[k][j];
93                     if(tmp.val[i][j] >= MOD) tmp.val[i][j] %= MOD;
94                 }
95         }
96     }
97     return tmp;
98 }
99
100 Mat operator ^(Mat x, int n) {
101     Mat tmp;
102     tmp.unit();
103     while(n) {
104         if(n & 1) tmp = tmp * x;
105         x = x * x;
106         n >>= 1;
107     }
108     return tmp;
109 }
110
111 void dfs(int u) {
112     visit[u] = true;
113     for(int i = 0; i < kind; i++) {
114         int v = T[u].child[i];
115         if(!T[v].end) {
116             x.val[u][v]++;
117             if(!visit[v]) dfs(v);
118         }
119     }
120 }
121
122 int main() {
123     char s[15];
124     while(~scanf("%d%d", &m, &n)) {
125         init();
126         for(int i = 0; i < m; i++) {
127             scanf("%s", s);
128             insert(s);
129         }
130         build_ac_auto();
131         x.zero();
132         memset(visit, false, sizeof(visit));
133         dfs(root);
134         Mat ans = x ^ n;
135         ll res = 0;
136         for(int i = 0; i <= tot; i++)
137             res += ans.val[0][i];
138         printf("%lld\n", res % MOD);
139     }
140     return 0;
141 }

y @ The Angry Teletubbies 2011-10-17 17:04 发表评论

zoj 2671 Cryptography - 矩阵乘法 + 线段树查询思想

y @ The Angry Teletubbies — Mon, 03 Oct 2011 17:31:00 GMT

【题意】：给出n个2*2的矩阵和m个区间查询[i,j]，对于每个查询输出矩阵P_i,j=A_i × A_i+1 × ... × A_j 。

【题解】：普通的矩阵乘法，观察到1<=n,m<=30,000，如果用朴素的方法时间复杂度高达O(nm)，显然是不可以接受的。
这里可以用线段树的查询思想，把中间有用的值保存下来，以后就可以用O(1)的得到。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 using namespace std;
5 #define maxn 32768
6 int r, n, m;
7 struct Mat {
8     int val[2][2];
9     void zero() {
10         memset(val, 0, sizeof(val));
11     }
12 }x[(maxn<<1)+1];
13
14 int LC(int i) {return i << 1;}
15 int RC(int i) {return LC(i)^1;}
16
17 Mat operator *(const Mat &a, const Mat &b) {
18     Mat tmp;
19     tmp.zero();
20     for(int k = 0; k < 2; k++) {
21         for(int i = 0; i < 2; i++) {
22             if(a.val[i][k]) {
23                 for(int j = 0; j < 2; j++) {
24                     tmp.val[i][j] += a.val[i][k] * b.val[k][j];
25                     if(tmp.val[i][j] >= r) tmp.val[i][j] %= r;
26                 }
27             }
28         }
29     }
30     return tmp;
31 }
32
33 Mat query(int p, int left, int right, int l, int r) {//线段树的查询思想
34     if(left == l && right == r) return x[p];
35     int mid = (left + right) >> 1;
36     if(r <= mid) return query(LC(p), left, mid, l, r);
37     else if(l > mid) return query(RC(p), mid + 1, right, l, r);
38     else return query(LC(p), left, mid, l, mid) * query(RC(p), mid + 1, right, mid + 1, r);
39 }
40
41 int main() {
42     bool flag = false;
43     while(~scanf("%d%d%d", &r, &n, &m)) {
44         int st = 1;
45         while(st < n) st <<= 1;
46         for(int i = 0; i < n; i++)
47             for(int j = 0; j < 2; j++)
48                 for(int k = 0; k < 2; k++)
49                     scanf("%d", &x[st+i].val[j][k]);
50         for(int i = st - 1; i; i--) x[i] = x[LC(i)] * x[RC(i)];
51         while(m--) {
52             if(flag) printf("\n");
53             else flag = true;
54             int le, ri;
55             scanf("%d%d", &le, &ri);
56             Mat ans = query(1, 1, st, le, ri);
57             printf("%d %d\n%d %d\n", ans.val[0][0], ans.val[0][1], ans.val[1][0], ans.val[1][1]);
58         }
59     }
60     return 0;
61 }

y @ The Angry Teletubbies 2011-10-04 01:31 发表评论

poj 3735 Training little cats - 矩阵快速幂

y @ The Angry Teletubbies — Sat, 01 Oct 2011 04:00:00 GMT

【题意】：有n只猫咪，开始时每只猫咪有花生0颗，现有一组操作，由下面三个中的k个操作组成：
               1. g i 给i只猫咪一颗花生米
               2. e i 让第i只猫咪吃掉它拥有的所有花生米
               3. s i j 将猫咪i与猫咪j的拥有的花生米交换

现将上述一组操作做m次后，问每只猫咪有多少颗花生？

【题解】：m达到10^9，显然不能直接算。
              因为k个操作给出之后就是固定的，所以想到用矩阵，矩阵快速幂可以把时间复杂度降到O（logm）。问题转化为如何构造转置矩阵？
              说下我的思路，观察以上三种操作，发现第二，三种操作比较容易处理，重点落在第一种操作上。
              有一个很好的办法就是添加一个辅助，使初始矩阵变为一个n+1元组，编号为0到n，下面以3个猫为例：
              定义初始矩阵A = [1 0 0 0]，0号元素固定为1，1~n分别为对应的猫所拥有的花生数。
              对于第一种操作g i，我们在单位矩阵基础上使Mat[0][i]变为1，例如g 1：
              1 1 0 0
              0 1 0 0
              0 0 1 0
              0 0 0 1，显然[1 0 0 0]*Mat = [1 1 0 0]
              对于第二种操作e i，我们在单位矩阵基础使Mat[i][i] = 0,例如e 2：
              1 0 0 0
              0 1 0 0
              0 0 0 0
              0 0 0 1, 显然[1 2 3 4]*Mat = [1 2 0 4]
              对于第三种操作s i j，我们在单位矩阵基础上使第i列与第j互换，例如s 1 2：
              1 0 0 0
              0 0 0 1
              0 0 1 0
              0 1 0 0，显然[1 2 0 4]*Mat = [1 4 0 2]
              现在，对于每一个操作我们都可以得到一个转置矩阵，把k个操作的矩阵相乘我们可以得到一个新的转置矩阵T。
              A * T 表示我们经过一组操作，类似我们可以得到经过m组操作的矩阵为 A * T ^ m,最终矩阵的[0][1~n]即为答案。

              上述的做法比较直观，但是实现过于麻烦，因为要构造k个不同矩阵。

              有没有别的方法可以直接构造转置矩阵T？答案是肯定的。
              我们还是以单位矩阵为基础：
              对于第一种操作g i，我们使Mat[0][i] = Mat[0][i] + 1；
              对于第二种操作e i，我们使矩阵的第i列清零；
              对于第三种操作s i j，我们使第i列与第j列互换。
              这样实现的话，我们始终在处理一个矩阵，免去构造k个矩阵的麻烦。

              至此，构造转置矩阵T就完成了，接下来只需用矩阵快速幂求出 A * T ^ m即可，还有一个注意的地方，该题需要用到long long。
              具体实现可以看下面的代码。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 using namespace std;
5 #define ll long long
6 #define maxn 105
7 int n, m, k;
8 struct Mat {
9     ll val[maxn][maxn];
10     void zero() {
11         memset(val, 0, sizeof(val));
12     }
13     void unit() {
14         zero();
15         for(int i = 0; i < maxn; i++) val[i][i] = 1;
16     }
17 }A, T;//A = 初始矩阵 ,T = 转置矩阵
18
19 Mat operator *(const Mat &a, const Mat &b) {
20     Mat tmp;
21     tmp.zero();
22     for(int k = 0; k <= n; k++) {
23         for(int i = 0; i <= n; i++) {
24             if(a.val[i][k])
25                 for(int j = 0; j <= n; j++)
26                     tmp.val[i][j] += a.val[i][k] * b.val[k][j];
27         }
28     }
29     return tmp;
30 }
31
32 Mat operator ^(Mat x, int n) {
33     Mat tmp;
34     tmp.unit();
35     while(n) {
36         if(n & 1) tmp = tmp * x;
37         x = x * x;
38         n >>= 1;
39     }
40     return tmp;
41 }
42
43 void init() {
44     A.zero();
45     A.val[0][0] = 1;
46     T.unit();
47 }
48
49 int main() {
50     char s[5];
51     int a, b;
52     while(~scanf("%d%d%d", &n, &m, &k)) {
53         if(!n && !m && !k) break;
54         init();
55         for(int i = 0; i < k; i++) {
56             scanf("%s", s);
57             if(s[0] == 'g') {
58                 scanf("%d", &a);
59                 T.val[0][a]++;
60             } else if(s[0] == 'e') {
61                 scanf("%d", &a);
62                 for(int i = 0; i <= n; i++) T.val[i][a] = 0;
63             } else {
64                 scanf("%d%d", &a, &b);
65                 for(int i = 0; i <= n; i++) swap(T.val[i][a], T.val[i][b]);
66             }
67         }
68         Mat ans = A * (T ^ m);
69         for(int i = 1; i <= n; i++) printf("%lld ", ans.val[0][i]);
70         printf("\n");
71     }
72     return 0;
73 }

y @ The Angry Teletubbies 2011-10-01 12:00 发表评论

poj 3233 Matrix Power Series - 矩阵快速幂 + 二分

y @ The Angry Teletubbies — Sun, 25 Sep 2011 14:42:00 GMT

【题意】：给出一个n * n矩阵A和一个正整数k,求 S = A + A² + A³ + … + A^k【题解】：以下是matrix67的题解：

这道题两次二分，相当经典。首先我们知道，A^i可以二分求出。然后我们需要对整个题目的数据规模k进行二分。比如，当k=6时，有：
A + A^2 + A^3 + A^4 + A^5 + A^6 =(A + A^2 + A^3) + A^3*(A + A^2 + A^3)
应用这个式子后，规模k减小了一半。我们二分求出A^3后再递归地计算A + A^2 + A^3，即可得到原问题的答案。

【代码】：

1 #include "iostream"
2 #include "cstring"
3 #include "cstdio"
4 using namespace std;
5 #define maxn 35
6 int n, k, m;
7 struct Mat {
8     int val[maxn][maxn];
9     void unit() {//单位矩阵
10         for(int i = 0; i < maxn; i++) val[i][i] = 1;
11     }
12     void zero() {//零矩阵
13         memset(val, 0, sizeof(val));
14     }
15 }x;
16
17 Mat operator *(const Mat &a, const Mat &b) {//矩阵乘法
18     Mat tmp;
19     tmp.zero();
20     for(int k = 1; k <= n; k++) {
21         for(int i = 1; i <= n; i++)
22             if(a.val[i][k])
23                 for(int j = 1; j <= n; j++) {
24                     tmp.val[i][j] += a.val[i][k] * b.val[k][j];
25                     if(tmp.val[i][j] >= m) tmp.val[i][j] %= m;
26                 }
27     }
28     return tmp;
29 }
30
31 Mat operator ^(Mat x, int n) {//矩阵快速幂
32     Mat tmp;
33     tmp.zero();
34     tmp.unit();
35     while(n) {
36         if(n & 1) tmp = tmp * x;
37         x = x * x;
38         n >>= 1;
39     }
40     return tmp;
41 }
42
43 Mat operator +(const Mat &a, const Mat &b) {//矩阵加法
44     Mat tmp;
45     for(int i = 1; i <= n; i++)
46         for(int j = 1; j <= n; j++)
47             tmp.val[i][j] = (a.val[i][j] + b.val[i][j]) % m;
48     return tmp;
49 }
50
51 Mat sum(int k) {
52     if(k == 1) return x;
53     else {
54         Mat tmp = sum(k >> 1);
55         if(k & 1) {
56             Mat tmp2 = x ^ ((k >> 1) + 1);
57             return tmp + tmp2 + tmp * tmp2;
58         } else {
59             Mat tmp2 = x ^ (k >> 1);
60             return tmp + tmp * tmp2;
61         }
62     }
63 }
64
65 int main() {
66     while(~scanf("%d%d%d", &n, &k, &m)) {
67         for(int i = 1; i <= n; i++) {
68             for(int j = 1; j <= n; j++) {
69                 scanf("%d", &x.val[i][j]);
70                 x.val[i][j] %= m;
71             }
72         }
73         Mat ans = sum(k);
74         for(int i = 1; i <= n; i++) {
75             for(int j = 1; j < n; j++)
76                 printf("%d ", ans.val[i][j]);
77             printf("%d\n", ans.val[i][n]);
78         }
79         break;
80     }
81     return 0;
82 }

y @ The Angry Teletubbies 2011-09-25 22:42 发表评论

poj 3070 Fibonacci - 矩阵快速幂求Fibonacci数

y @ The Angry Teletubbies — Sun, 25 Sep 2011 14:25:00 GMT

【题意】：求Fibonacci数列中的第n项的最后4个数字，不包含前导0。

【题解】：Fibonacci满足以下公式：

构造矩阵，利用矩阵快速幂求解。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 using namespace std;
5 #define MAX 3
6 const int MOD = 10000;
7 struct Mat {
8     int val[MAX][MAX];
9     void unit() {
10         for(int i = 0; i < MAX; i++) val[i][i] = 1;
11     }
12     void zero() {
13         memset(val, 0, sizeof(val));
14     }
15 };
16
17 Mat operator *(const Mat &a, const Mat &b) {
18     Mat tmp;
19     tmp.zero();
20     for(int k = 1; k < MAX; k++) {
21         for(int i = 1; i < MAX; i++) {
22             if(a.val[i][k])
23                 for(int j = 1; j < MAX; j++) {
24                     tmp.val[i][j] += a.val[i][k] * b.val[k][j];
25                     if(tmp.val[i][j] >= MOD) tmp.val[i][j] %= MOD;
26                 }
27         }
28     }
29     return tmp;
30 }
31
32 Mat operator ^(Mat x, int n) {
33     Mat tmp;
34     tmp.zero(), tmp.unit();
35     while(n) {
36         if(n & 1) tmp = tmp * x;
37         x = x * x;
38         n >>= 1;
39     }
40     return tmp;
41 }
42
43 int main() {
44     Mat x;
45     int n;
46     x.val[1][1] = x.val[1][2] = x.val[2][1] = 1, x.val[2][2] = 0;
47     while(~scanf("%d", &n)) {
48         if(n == -1) break;
49         Mat ans = x ^ n;
50         printf("%d\n", ans.val[1][2]);
51     }
52     return 0;
53 }
54

y @ The Angry Teletubbies 2011-09-25 22:25 发表评论