C++博客-gdgzgq-文章分类-PKU题解

表达式求值 - PKU 1460 - Firefighters

LioN.G — Fri, 07 May 2010 14:41:00 GMT

摘要: http://acm.pku.edu.cn/JudgeOnline/problem?id=1460没啥好说的，就是赤裸裸的表达式求值。先2^n枚举运算符，复杂度是O(2^n * len)，len是表达式的长度。一开始以为是只有一个问号，结果wa了一次才发现是最多有10个问号……这次想练代码，所以没用STL，但是又有点偷懒，所以就复制粘贴了一些代码，而没写成函数…... 阅读全文

LioN.G 2010-05-07 22:41 发表评论

容斥原理 - PKU 2773 Happy 2006

LioN.G — Tue, 04 May 2010 17:00:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2773

题目输入m和k，让你求从小到大排列，第k个与m互素的正整数。方法就是先求出m以内的所有素数（预处理），然后对m因式分解，m=p1^a1 * p2^a2 * ... * pt^at，然后分别记录下p1, p2, ..., pt。接着是二分k，对于每次二分，用容斥原理去求答案，比如与2不互素的有m / 2个，与3不互素的有m / 3个，与2 * 3 = 6不互素的有m / 6个，因此就是m / 2 + m / 3 - m / 6，显然，这个过程就是个DFS。

 1 #include <cstdio>
 2 #include <vector>
 3 
 4 using namespace std;
 5 
 6 const int MAX_N = 1000001;
 7 const __int64 INF = 9223372036854775807;
 8 
 9 bool isnPrime[MAX_N];
10 vector<int> prime;
11 vector<int> fac;
12 int m, k;
13 
14 void CalcPrime() {
15     prime.clear();
16     prime.push_back(2);
17     int t = 1;
18     for (int i = 3; i < MAX_N; i += 2) {
19         if (!isnPrime[i]) {
20             prime.push_back(i);
21             for (int j = i + i; j < MAX_N; j += i) isnPrime[j] = 1;
22         }
23     }
24 }
25 
26 void DFS(int now, int mul, int depth, int num, __int64 m, __int64 &cnt) {
27     if (depth == num) {
28         cnt += m / mul;
29         return;
30     }
31     for (int i = now; i < fac.size(); ++i) {
32         if (mul * fac[i] > m) break;
33         DFS(i + 1, mul * fac[i], depth + 1, num, m, cnt);
34     }
35 }
36 
37 __int64 cnt(__int64 m) {
38     __int64 cnt = m, tmp;
39     for (int i = 1; i <= fac.size(); ++i) {
40         tmp = 0;
41         DFS(0, 1, 0, i, m, tmp);
42         if (i % 2) cnt -= tmp;
43         else cnt += tmp;
44     }
45     return cnt;
46 }
47 
48 int main() {
49     CalcPrime();
50     while (scanf("%d%d", &m, &k) != EOF) {
51         fac.clear();
52         for (int i = 0; prime[i] <= m; ++i) {
53             if (m % prime[i] == 0) {
54                 while (m % prime[i] == 0) m /= prime[i];
55                 fac.push_back(prime[i]);
56             }
57         }
58         __int64 l = 1, r = INF, t, mid, ret;
59         while (l <= r) {
60             mid = l + (r - l) / 2;
61             t = cnt(mid);
62             if (t >= k) {
63                 if (t == k) ret = mid;
64                 r = mid - 1;
65             } else l = mid + 1;
66         }
67         printf("%d\n", ret);
68     }
69     return 0;
70 }
71 

LioN.G 2010-05-05 01:00 发表评论

树状数组 - PKU 2352 Stars

LioN.G — Tue, 04 May 2010 14:34:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2352

题目给出平面上N个点，对于某点p，如果有k个点的横坐标小于等于Xp，并且纵坐标小于等于Yp，那么称这个点p的level是k，问level为0~n-1的点分别有多少个。
比较直观的树状数组的题目，首先对X坐标升序排序，如果X坐标相同，则按Y坐标升序排序，然后对于每一个点，首先在树状数组里面查询前面比它的Y坐标小的点的个数，然后再把这个点插入到树状数组中即可。复杂度是O(nlgm)，n是点数，m是坐标的范围。

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 
 5 using namespace std;
 6 
 7 const int MAX_N = 15010;
 8 const int MAX_C = 32010;
 9 
10 struct point {
11     int x, y;
12     bool operator < (const point &p) const {
13         return x < p.x || x == p.x && y < p.y;
14     }
15 }a[MAX_N];
16 
17 int c[MAX_C];
18 int cnt[MAX_N];
19 int n;
20 
21 inline int lowbit(int x) {
22     return x & (-x);
23 }
24 
25 void modify(int pos, int x) {
26     while (pos < MAX_C) {
27         c[pos] += x;
28         pos += lowbit(pos);
29     }
30 }
31 
32 int sum(int end) {
33     int sum = 0;
34     while (end) {
35         sum += c[end];
36         end -= lowbit(end);
37     }
38     return sum;
39 }
40 
41 int main() {
42     while (scanf("%d", &n) != EOF) {
43         memset(cnt, 0, sizeof(cnt));
44         memset(c, 0, sizeof(c));
45         for (int i = 0; i < n; ++i) {
46             scanf("%d%d", &a[i].x, &a[i].y);
47             ++a[i].x; ++a[i].y;
48         }
49         sort(a, a + n);
50         for (int i = 0; i < n; ++i) {
51             ++cnt[sum(a[i].y)];
52             modify(a[i].y, 1);
53         }
54         for (int i = 0; i < n; ++i) printf("%d\n", cnt[i]);
55     }
56     return 0;
57 }
58 

LioN.G 2010-05-04 22:34 发表评论

并查集 - PKU 2922 - Honeymoon Hike

LioN.G — Tue, 04 May 2010 12:31:00 GMT

摘要: http://acm.pku.edu.cn/JudgeOnline/problem?id=2922这题是说给个方阵，让你从左上角出发，通过经过相邻的点（上下左右四个方向），到达右下角，要求你经过的路径上的数值的最大值最小值之差最小。这道题我一开始是枚举最小值O(n)，然后二分最大值与最小值之差O(lgn)，最后去搜索一遍O(n^2)，一个O(n^3 * lgn)的算法，因为n的规模为100，而时限... 阅读全文

LioN.G 2010-05-04 20:31 发表评论

组合数学 - 3731 - Escape

LioN.G — Mon, 03 May 2010 17:16:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=3731

初看以为是DP，后来发现不满足无后效性的条件，不能DP。
其实这题是个计数问题，对于到达一个目标点的方法，可以按转弯次数分一下类，由于路线的方式是顺时针，这样必然导致目标点的左上右下四个方向的已走出的路径数依次增加，问题就转换为如何求每一类的方法数了。显然，这是个组合数，假设从目标点到某边界共有n个点的距离，而这n个点中已经走过了m条路径，则共有C(n, m)种方法，然后运用乘法原理和加法原理即可解决问题。
代码写得不好，那四个方向其实可以写成循环的……

 1 #include <cstdio>
 2 
 3 const int MOD = 100000007;
 4 const int MAX_N = 2001;
 5 
 6 int cas, n, m, x, y, cnt;
 7 int l, r, u, d;
 8 int c[MAX_N][MAX_N];
 9 long long tmp;
10 
11 void CalcComb() {
12     c[0][0] = c[1][0] = c[1][1] = 1;
13     for (int i = 2; i < MAX_N; ++i) {
14         c[i][0] = c[i][i] = 1;
15         for (int j = 1; j < i; ++j)
16             c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
17     }
18 }
19 
20 int main() {
21     CalcComb();
22     for (scanf("%d", &cas); cas; --cas) {
23         scanf("%d%d%d%d", &n, &m, &x, &y);
24         if (!x) {
25             puts("1");
26             continue;
27         }
28         l = r = d = u = cnt = 0;
29         while (1) {
30             ++u;
31             tmp = 1;
32             tmp = tmp * c[x - 1][l] % MOD;
33             tmp = tmp * c[n - x][r] % MOD;
34             tmp = tmp * c[y][d] % MOD;
35             tmp = tmp * c[m - y][u - 1] % MOD;
36             cnt = (cnt + tmp) % MOD;
37             if (u == m - y + 1) break;
38             ++r;
39             tmp = 1;
40             tmp = tmp * c[x - 1][l] % MOD;
41             tmp = tmp * c[n - x][r - 1] % MOD;
42             tmp = tmp * c[y][d] % MOD;
43             tmp = tmp * c[m - y][u] % MOD;
44             cnt = (cnt + tmp) % MOD;
45             if (r == n - x + 1) break;
46             ++d;
47             tmp = 1;
48             tmp = tmp * c[x - 1][l] % MOD;
49             tmp = tmp * c[n - x][r] % MOD;
50             tmp = tmp * c[y][d - 1] % MOD;
51             tmp = tmp * c[m - y][u] % MOD;
52             cnt = (cnt + tmp) % MOD;
53             if (d == y + 1) break;
54             ++l;
55             tmp = 1;
56             tmp = tmp * c[x - 1][l - 1] % MOD;
57             tmp = tmp * c[n - x][r] % MOD;
58             tmp = tmp * c[y][d] % MOD;
59             tmp = tmp * c[m - y][u] % MOD;
60             cnt = (cnt + tmp) % MOD;
61             if (l == x) break;
62         }
63         printf("%d\n", cnt);
64     }
65     return 0;
66 }
67 

LioN.G 2010-05-04 01:16 发表评论

计算几何 - PKU 2957 - Planet Hunting

LioN.G — Mon, 03 May 2010 16:59:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2957

水题，但不知为何过的人很少……
其实就是通过周期算出旋转角度，把三个点移到同一个时间点上，这时问题就转化成已知三点求圆心了，贴模板水过

 1 #include <cstdio>
 2 #include <cmath>
 3 
 4 struct point {
 5     double x, y;
 6 }p[3], c, O = {0, 0};
 7 
 8 struct line {
 9     double a, b, c;
10 };
11 
12 const double EPS = 1e-8;
13 const double PI = 3.1415926535897932384626433832795;
14 
15 int t, k1, k2;
16 
17 point add(point p1, point p2) {
18     point v = {p1.x + p2.x, p1.y + p2.y};
19     return v;
20 }
21 
22 point mul(point p, double a) {
23     point v = {p.x * a, p.y * a};
24     return v;
25 }
26 
27 point rotate(point p, double th) {
28     point t = {p.x * cos(th) - p.y * sin(th), p.x * sin(th) + p.y * cos(th)};
29     return t;
30 }
31 
32 int sign(double x) {
33     return x < -EPS ? -1 : x > EPS;
34 }
35 
36 line getLine(point p, point v) {
37     line l = {v.y, -v.x, v.x * p.y - v.y * p.x};
38     return l;
39 }
40 
41 int lineCross(line l1, line l2, point &p) {
42     double x = l1.b * l2.c - l1.c * l2.b;
43     double y = l1.a * l2.c - l1.c * l2.a;
44     double z = l1.a * l2.b - l1.b * l2.a;
45     if (!sign(z))
46         if (sign(x)) return 0;
47         else return -1;
48     else {
49         p.x = x / z; p.y = -y / z;
50         return 1;
51     }
52 }
53 
54 point centre(point a, point b, point &c) {
55     point p = {b.y - a.y, a.x - b.x};
56     line l1 = getLine(mul(add(a, b), 0.5), p);
57     p.x = c.y - b.y, p.y = b.x - c.x;
58     line l2 = getLine(mul(add(b, c), 0.5), p);
59     lineCross(l1, l2, p);
60     return p;
61 }
62 
63 double sqr(double x) {
64     return x * x;
65 }
66 
67 double dist(point &a, point &b) {
68     return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
69 }
70 
71 int main() {
72     while (scanf("%d%d%d", &t, &k1, &k2), t || k1 || k2) {
73         for (int i = 0; i < 3; ++i) scanf("%lf%lf", &p[i].x, &p[i].y);
74         p[0] = rotate(p[0], 2 * PI * (k1 + k2) / t);
75         p[1] = rotate(p[1], 2 * PI * k2 / t);
76         c = centre(p[0], p[1], p[2]);
77         printf("%lld\n", (long long)(dist(O, c) + 0.5));
78     }
79     return 0;
80 }
81 
82 

LioN.G 2010-05-04 00:59 发表评论

模拟 - PKU 3290 - WFF 'N PROOF

LioN.G — Mon, 03 May 2010 12:24:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=3290

用STL水过了~

 1 #include <cstdio>
 2 #include <vector>
 3 #include <deque>
 4 
 5 using namespace std;
 6 
 7 const int MAX_N = 110;
 8 
 9 char st[MAX_N];
10 int n;
11 vector<char> num, op;
12 deque<char> ret;
13 
14 int main() {
15     while (scanf("%s", st), st[0] != '0') {
16         num.clear(); op.clear(); n = 0;
17         for (int i = 0; st[i]; ++i) {
18             if (st[i] >= 'a') num.push_back(st[i]);
19             else if (st[i] == 'N') ++n;
20             else op.push_back(st[i]);
21         }
22         if (num.empty()) {
23             puts("no WFF possible");
24             continue;
25         }
26         ret.clear();
27         ret.push_front(num[0]);
28         while (n--)    ret.push_front('N');
29         for (int i = 1, j = 0; i < num.size() && j < op.size(); ) {
30             ret.push_front(num[i++]);
31             ret.push_front(op[j++]);
32         }
33         for (int i = 0; i < ret.size(); ++i) putchar(ret[i]);
34         puts("");
35     }
36     return 0;
37 }
38 

LioN.G 2010-05-03 20:24 发表评论