C++博客-A Za, A Za, Fighting...-随笔分类-C_动态规划

PKU 3670 Eating Together

simplyzhao — Tue, 19 Oct 2010 06:30:00 GMT

问题:
http://poj.org/problem?id=3670

思路:
1.
将原问题化解为求最长不下降子序列和最长不上升子序列即可
求解LIS/LDS的nlogn算法
参考http://www.cppblog.com/Joe/archive/2010/08/14/123461.html

2.
参考: http://www.byvoid.com/blog/usaco-feb08-silver-eating-together/

代码:

1 /* LIS/LDS: nlogn */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_LEN 30001
6 int N, group[MAX_LEN];
7 int aux[MAX_LEN];
8
9 int
10 bin_search1(int *arr, int front, int rear, int target)
11 {
12     int mid;
13     while(front <= rear) {
14         mid = (front+rear)/2;
15         if(aux[mid] <= target)
16             front = mid+1;
17         else
18             rear = mid-1;
19     }
20     return front;
21 }
22
23 int
24 bin_search2(int *arr, int front, int rear, int target)
25 {
26     int mid;
27     while(front <= rear) {
28         mid = (front+rear)/2;
29         if(aux[mid] >= target)
30             front = mid+1;
31         else
32             rear = mid-1;
33     }
34     return front;
35 }
36
37 int
38 LIS() /* LUDS, maybe more accurate, meaning Longest Undecreasing Seq */
39 {
40     int i, len = 1;
41     aux[1] = group[0];
42     for(i=1; i<N; i++) {
43         if(group[i] >= aux[len]) {
44             ++len;
45             aux[len] = group[i];
46         } else {
47             aux[bin_search1(aux, 1, len, group[i])] = group[i];
48         }
49     }
50     return len;
51 }
52
53 int
54 LDS() /* LUIS */
55 {
56     int i, len=1;
57     aux[1] = group[0];
58     for(i=1; i<N; i++) {
59         if(group[i] <= aux[len]) {
60             ++len;
61             aux[len] = group[i];
62         } else {
63             aux[bin_search2(aux, 1, len, group[i])] = group[i];
64         }
65     }
66     return len;
67 }
68
69 int
70 main(int argc, char **argv)
71 {
72     int i, lis_len, lds_len;
73     while(scanf("%d", &N) != EOF) {
74         for(i=0; i<N; i++)
75             scanf("%d", group+i);
76         lis_len = LIS();
77         lds_len = LDS();
78         printf("%d\n", N-(lis_len>lds_len ? lis_len : lds_len));
79     }
80 }

simplyzhao 2010-10-19 14:30 发表评论

PEARL 硬币找零(动态规划)

simplyzhao — Wed, 29 Sep 2010 06:18:00 GMT

问题描述及代码:

  1 /*
  2  * Problem:
  3  * given you the coins, and the total amount of money to change, find a solution
  4  * for this change which minimize the number of coins needed.
  5  *
  6  * Example:
  7  * coins[] = {1, 5, 10, 21, 25};
  8  * money = 19;
  9  * solution[] = {10, 5, 1, 1, 1, 1};
10  *
11  * Points:
12  * Dynamic Programming
13  * Greey Algorithm here is usually uncorrect
14  */
15 #include<stdio.h>
16 #include<stdlib.h>
17 #include<string.h>
18 #define MAX_COINS 10
19 #define MAX_MONEY 32767
20 #define INF 0x7FFFFFFF
21 int coins_num, coins[MAX_COINS];
22 int total, changes_num[MAX_MONEY], changes[MAX_MONEY];
23
24 int
25 is_continue()
26 {
27     char ch[2];
28     while(1) {
29         printf("Are you gonna continue this game(Y if yes, or N)?\n");
30         scanf("%s", ch);
31         if(ch[0] == 'Y' || ch[0] == 'y')
32             return 1;
33         else if(ch[0] == 'N' || ch[0] == 'n')
34             return 0;
35     }
36 }
37
38 void
39 input()
40 {
41     int i;
42     printf("Enter the number of coins: ");
43     scanf("%d", &coins_num);
44     printf("Enter the amount of coins(ascending order, separated by space): \n");
45     for(i=0; i<coins_num; i++)
46         scanf("%d", coins+i);
47     printf("Enter the amount of money to change: ");
48     scanf("%d", &total);
49 }
50
51 void
52 output()
53 {
54     int i, tmp;
55     printf("Solution: \n");
56     printf("Minimum number of coins needed: %d\n", changes_num[total]);
57     printf("Coins: \n");
58     tmp = total;
59     while(tmp > 0) {
60         printf("%d ", changes[tmp]);
61         tmp -= changes[tmp];
62     }
63     printf("\n");
64 }
65
66 /*
67  * Dynamic Programming: f(m) = min (f[m-coins[i] + 1)
68  * O(N*K), N is the number of coins, K is the total amount of money to change
69  */
70 void
71 solve()
72 {
73     int i, j, k, min;
74     changes_num[0] = 0;
75     for(i=1; i<=total; i++) { /* Money: from '1' to 'total' */
76         min = INF;
77         k = -1;
78         for(j=0; j<coins_num; j++) { /* Coins: ascending, and always contains '1' */
79             if(i >= coins[j]) {
80                 if(min > changes_num[i-coins[j]]+1) {
81                     min = changes_num[i-coins[j]]+1;
82                     k = j;
83                 }
84             } else
85                 continue;
86         }
87         changes_num[i] = min;
88         changes[i] = coins[k];
89     }
90 }
91
92 int
93 main(int argc, char **argv)
94 {
95     while(is_continue()) {
96         input();
97         solve();
98         output();
99     }
100 }

simplyzhao 2010-09-29 14:18 发表评论

USACO Broken Necklace

simplyzhao — Mon, 27 Sep 2010 06:58:00 GMT

问题:
http://ace.delos.com/usacoprob2?a=sAaEFWx5xo1&S=beads

思路:
如果纯粹枚举的话，代码还是挺简单的（关键是将循环结构巧妙地用线性结构表示: s -> ss）
枚举的复杂度很容易地看出是O(n*n)，对于本题，还是没问题的

官方给出的Analysis中，提供了一种O(n)的动态规划的解法，却始终想不明白，艾...
有时间再继续思考

simplyzhao 2010-09-27 14:58 发表评论

PKU 1456 Supermarket

simplyzhao — Wed, 15 Sep 2010 08:25:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1456

思路:
这题就是个悲剧...
都说这题是贪心，还有并查集的优化，不过我对于贪心一直不敢用，因为不知道为什么可以贪心
然后，那就动态规划吧，结果，彻底受打击了，对于动态规划还是没掌握啊...

其实，用value[i][j]来表示前i件product到时刻j为止所得到的最大profit
value[i][j] = max (value[i-1][j], value[i-1][j-1]+profit[i])
跟01背包的形式是一样的，所以就可以用滚动数组进行空间优化

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_N 10001
5 #define Max(a,b) ((a)<(b)?(b):(a))
6 struct Prod {
7     int profit;
8     int deadline;
9 } prods[MAX_N];
10 int n, upper, value[MAX_N];
11
12 int
13 compare(const void *arg1, const void *arg2) /* ascend order: deadline */
14 {
15     struct Prod *a = (struct Prod *)arg1;
16     struct Prod *b = (struct Prod *)arg2;
17     return a->deadline-b->deadline;
18 }
19
20 void
21 init()
22 {
23     int i;
24     for(i=0; i<n; i++)
25         scanf("%d %d", &prods[i].profit, &prods[i].deadline);
26     qsort(prods, n, sizeof(struct Prod), compare);
27     upper = prods[n-1].deadline;
28 }
29
30 void
31 solve()
32 {
33     int i, j;
34     memset(value, 0, sizeof(value));
35     for(i=0; i<n; i++) {
36         for(j=prods[i].deadline; j>=1; j--)
37             value[j] = Max(value[j], value[j-1]+prods[i].profit);
38         for(j=prods[i].deadline+1; j<=upper; j++)
39             value[j] = Max(value[prods[i].deadline], value[j]);
40     }
41     printf("%d\n", value[upper]);
42 }
43
44 int
45 main(int argc, char **argv)
46 {
47     while(scanf("%d", &n) != EOF) {
48         init();
49         solve();
50     }
51 }

simplyzhao 2010-09-15 16:25 发表评论

PKU 1260 Pearls

simplyzhao — Wed, 18 Aug 2010 01:33:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1260

思路:
简单DP，但是就是想不到...

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 101
5 #define INF 0x7FFFFFFF
6 #define min(a,b) ((a)<(b) ? (a) : (b))
7 int num[MAX_LEN], price[MAX_LEN];
8 int sum[MAX_LEN]; /* aux */
9 int table[MAX_LEN];
10 int c;
11
12 /*
13  * f[i] represent the lowest possible price needed to buy list[1..i], so:
14  *      f[i] = min (f[k] + (num[k+1]++num[i]+10)*price[i]), 0<=k15  */
16 int
17 dp()
18 {
19     int i, k, tmp;
20     sum[0] = 0;
21     for(i=1; i<=c; i++)
22         sum[i] = sum[i-1]+num[i];
23     table[0] = 0;
24     for(i=1; i<=c; i++) {
25         table[i] = INF;
26         for(k=0; k<=i-1; k++) {
27             tmp = table[k] + (sum[i]-sum[k]+10)*price[i];
28             table[i] = min(table[i], tmp);
29         }
30     }
31     return table[c];
32 }
33
34 int
35 main(int argc, char **argv)
36 {
37     int i, tests;
38     scanf("%d", &tests);
39     while(tests--) {
40         scanf("%d", &c);
41         for(i=1; i<=c; i++)
42             scanf("%d %d", num+i, price+i);
43         printf("%d\n", dp());
44     }
45 }

simplyzhao 2010-08-18 09:33 发表评论

PKU 1179 Polygon

simplyzhao — Tue, 17 Aug 2010 05:51:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1179

思路:
这题输在了对原题目的理解和分析上，没能成功地走出第一步:
将原题解析成对于表达式的求解
把缺了一条边的多边形展开成直线就是一个表达式
注意：为了求乘法，必须同时保存最大值和最小值

f[i][j]记录表达式中从顶点i到顶点j这段子表达式的值

动态规划的思想类似于矩阵连乘

参考:
http://hi.baidu.com/xiehuixb/blog/item/575ec81e221466c1a786699e.html

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 51
5 #define INF 9223372036854775807LL
6 #define maximal(a, b) ((a)>(b) ? (a) : (b))
7 #define minimal(a, b) ((a)<(b) ? (a) : (b))
8 char operand[MAX_LEN][2];
9 int operators[MAX_LEN];
10 int n, ans_len, ans[MAX_LEN];
11 long long int rt, max[MAX_LEN][MAX_LEN], min[MAX_LEN][MAX_LEN];
12
13 /*
14  * when it comes to: '+'
15  * max[i][j] = maximal(max[i][k] + max[k+1][j])
16  * min[i][j] = minimal(min[i][k] + min[k+1][j])
17  *
18  * when it comes to: '*'
19  * max[i][j] = maximal(max[i][k]*max[k+1][j], max[i][k]*min[k+1][j], min[i][k]*max[k+1][j], min[i][k]*min[k+1][j])
20  * min[i][j] = minimal(max[i][k]*max[k+1][j], max[i][k]*min[k+1][j], min[i][k]*max[k+1][j], min[i][k]*min[k+1][j])
21  *
22  * i<=k23  */
24 void
25 solve(char *opd, int *ops, int del_edge)
26 {
27     int i, j, k, len;
28     for(i=1; i<=n; i++)
29         max[i][i] = min[i][i] = ops[i];
30     for(len=2; len<=n; len++) {
31         for(i=1; i<=n-len+1; i++) {
32             j = i+len-1;
33             max[i][j] = -INF;
34             min[i][j] = INF;
35             for(k=i; k<j; k++) {
36                 if(opd[k] == 't') {
37                     max[i][j] = maximal(max[i][j], max[i][k]+max[k+1][j]);
38                     min[i][j] = minimal(min[i][j], min[i][k]+min[k+1][j]);
39                 } else { /* opd[k] == 'x' */
40                     max[i][j] = maximal(max[i][j], max[i][k]*max[k+1][j]);
41                     max[i][j] = maximal(max[i][j], max[i][k]*min[k+1][j]);
42                     max[i][j] = maximal(max[i][j], min[i][k]*max[k+1][j]);
43                     max[i][j] = maximal(max[i][j], min[i][k]*min[k+1][j]);
44
45                     min[i][j] = minimal(min[i][j], max[i][k]*max[k+1][j]);
46                     min[i][j] = minimal(min[i][j], max[i][k]*min[k+1][j]);
47                     min[i][j] = minimal(min[i][j], min[i][k]*max[k+1][j]);
48                     min[i][j] = minimal(min[i][j], min[i][k]*min[k+1][j]);
49                 }
50             }
51         }
52     }
53     if(max[1][n] >= rt) {
54         if(max[1][n] == rt)
55             ans[ans_len++] = del_edge;
56         else {
57             rt = max[1][n];
58             ans_len = 0;
59             ans[ans_len++] = del_edge;
60         }
61     }
62 }
63
64 int
65 main(int argc, char **argv)
66 {
67     int i, j, k;
68     char tmpopd[MAX_LEN];
69     int tmpops[MAX_LEN];
70     while(scanf("%d", &n) != EOF) {
71         for(i=1; i<=n; i++)
72             scanf("%s%d", operand[i], operators+i);
73         rt = -INF;
74         ans_len = 0;
75         for(i=1; i<=n; i++) {
76             for(j=i%n+1, k=1; j!=i; j=j%n+1, k++)
77                 tmpopd[k] = operand[j][0];
78             tmpopd[k] = '\0';
79             tmpops[1] = operators[i];
80             for(j=i%n+1, k=2; j!=i; j=j%n+1, k++)
81                 tmpops[k] = operators[j];
82             solve(tmpopd, tmpops, i);
83         }
84         printf("%lld\n", rt);
85         for(i=0; i<ans_len; i++)
86             printf("%d ", ans[i]);
87         printf("\n");
88     }
89 }

simplyzhao 2010-08-17 13:51 发表评论

PKU 1157 Little Shop of Flowers

simplyzhao — Sun, 15 Aug 2010 03:16:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1157

思路:
比较容易的动态规划，这里提供两种思路，其中第二种更优
另外，居然在写代码的时候将0xFFFFFFFF当作最小的int值，汗...

代码(方案1)

1 /* 63MS */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_F 101
6 #define MAX_V 101
7 #define INF 0xF0000000
8 int values[MAX_F][MAX_V];
9 int table[MAX_F][MAX_V];
10 int f, v;
11
12 /*
13  * f[i][j] represent the maximum aesthetic values for putting the first [1..i]
14  * bunches in the first [1..j] vases, so:
15  *      f[i][j] = max (f[i-1][k] + tmp), i-1<=k16  */
17 dp()
18 {
19     int i, j, k, p, t, up, tmp, max;
20     table[1][1] = values[1][1];
21     for(j=2; j<=v-f+1; j++) /* i = 1 */
22         table[1][j] = values[1][j]>table[1][j-1] ? values[1][j] : table[1][j-1];
23     for(i=2; i<=f; i++) {
24         up = v-f+i;
25         for(j=i; j<=up; j++) {
26             max = INF;
27             for(k=i-1; k<j; k++) {
28                 t = values[i][k+1];
29                 for(p=k+2; p<j; p++)
30                     t = values[i][p] > t ? values[i][p] : t;
31                 tmp = table[i-1][k] + t;
32                 max = tmp > max ? tmp : max;
33             }
34             table[i][j] = max;
35         }
36     }
37     return table[f][v];
38 }
39
40 int
41 main(int argc, char **argv)
42 {
43     int i, j;
44     while(scanf("%d %d", &f, &v)!=EOF) {
45         for(i=1; i<=f; i++)
46             for(j=1; j<=v; j++)
47                 scanf("%d", values[i]+j);
48         printf("%d\n", dp());
49     }
50 }

代码(方案2)

1 /* 32MS */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_F 101
6 #define MAX_V 101
7 #define INF 0xF0000000
8 int values[MAX_F][MAX_V];
9 int table[MAX_F][MAX_V];
10 int f, v;
11
12 /*
13  * f[i][j] represent the maximum aesthetic values for putting the i(th) bunch
14  * in the j(th) vases(total i bunches), so:
15  *      f[i][j] = max(f[i-1][k])+values[i][j], i-1<=k16  */
17 dp()
18 {
19     int i, j, k, up, max, rt;
20     for(j=1; j<=v-f+1; j++)
21         table[1][j] = values[1][j];
22     for(i=2; i<=f; i++) {
23         up = v-f+i;
24         for(j=i; j<=up; j++) {
25             max = INF;
26             for(k=i-1; k<j; k++)
27                 max = table[i-1][k] > max ? table[i-1][k] : max;
28             table[i][j] = max+values[i][j];
29         }
30     }
31     rt = INF;
32     for(j=f; j<=v; j++)
33         rt = table[f][j]>rt ? table[f][j] : rt;
34     return rt;
35 }
36
37 int
38 main(int argc, char **argv)
39 {
40     int i, j;
41     while(scanf("%d %d", &f, &v)!=EOF) {
42         for(i=1; i<=f; i++)
43             for(j=1; j<=v; j++)
44                 scanf("%d", values[i]+j);
45         printf("%d\n", dp());
46     }
47 }

simplyzhao 2010-08-15 11:16 发表评论

[最长上升子序列 nlogn] PKU 1631 Bridging signals

simplyzhao — Sat, 14 Aug 2010 13:09:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1631

思路:
题意理解清楚，其实就是找出最长上升子序列
这里采用O(nlogn)的算法，类似于贪心的原理，关键是要理解辅助数组aux[]的含义，aux[len]所代表的是组成长度为len的最长上升子序列的尾元素的最小值

下面的内容转自: http://blog.csdn.net/ottoCho/archive/2009/12/02/4927262.aspx
O(n*log n)算法分析如下：

设 A[t]表示序列中的第t个数，F[t]表示从1到t这一段中以t结尾的最长上升子序列的长度，初始时设F [t] = 0(t = 1, 2, ..., len(A))。则有动态规划方程：F[t] = max{1, F[j] + 1} (j = 1, 2, ..., t - 1, 且A[j] < A[t])。

现在，我们仔细考虑计算F[t]时的情况。假设有两个元素A[x]和A[y]，满足
(1)x < y < t (这里应该错了，如果x=F[x]+1，不可能有(3)成立，这里应该是y
(2)A[x] < A[y] < A[t]
(3)F[x] = F[y]
此时，选择F[x]和选择F[y]都可以得到同样的F[t]值，那么，在最长上升子序列的这个位置中，应该选择A[x]还是应该选择A[y]呢？
很明显，选择A[x]比选择A[y]要好。因为由于条件(2)，在A[x+1] ... A[t-1]这一段中，如果存在A[z]，A[x] < A[z] < a[y]，则与选择A[y]相比，将会得到更长的上升子序列。
再根据条件(3)，我们会得到一个启示：根据F[]的值进行分类。对于F[]的每一个取值k，我们只需要保留满足F[t] = k的所有A[t]中的最小值。设D[k]记录这个值，即D[k] = min{A[t]} (F[t] = k)。

注意到D[]的两个特点：
(1)　D[k]的值是在整个计算过程中是单调不上升的。
(2)　D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。

利用D[]，我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断A[t]与D[len]。若A [t] > D[len]，则将A[t]接在D[len]后将得到一个更长的上升子序列，len = len + 1， D[len] = A [t]；否则，在D[1]..D[len]中，找到最大的j，满足D[j] < A[t]。令k = j + 1，则有A [t] <= D[k]，将A[t]接在D[j]后将得到一个更长的上升子序列，更新D[k] = A[t]。最后，len即为所要求的最长上升子序列的长度。

在上述算法中，若使用朴素的顺序查找在D[1]..D[len]查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来的算法相比没有任何进步。但是由于D[]的特点(2)，我们在D[]中查找时，可以使用二分查找高效地完成，则整个算法的时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D[]在算法结束后记录的并不是一个符合题意的最长上升子序列！

代码:
1 /* O(nlogn) algorithm: the longest increasing sub-sequence [LIS] */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_LEN 40001
6 int num[MAX_LEN];
7 int aux[MAX_LEN];
8 int size, rt_len;
9
10 int
11 dp()
12 {
13     int i, left, right, mid;
14     rt_len = 1;
15     aux[rt_len] = num[0];
16     for(i=1; i<size; i++) {
17         if(num[i] > aux[rt_len]) {
18             ++rt_len;
19             aux[rt_len] = num[i];
20         } else {
21             /* binary search: O(logn) */
22             left = 1;
23             right = rt_len;
24             while(left <= right) {
25                 mid = (left+right)/2;
26                 if(num[i]>aux[mid])
27                     left = mid+1;
28                 else
29                     right = mid-1;
30             }
31             aux[left] = num[i];
32         }
33     }
34     return rt_len;
35 }
36
37 int
38 main(int argc, char **argv)
39 {
40     int i, tests;
41     scanf("%d", &tests);
42     while(tests--) {
43         scanf("%d", &size);
44         for(i=0; i<size; i++)
45             scanf("%d", num+i);
46         printf("%d\n", dp());
47     }
48 }

simplyzhao 2010-08-14 21:09 发表评论

[最长上升子序列 n^2]PKU 1887 Testing the CATCHER / PKU 2533 Longest Ordered Subsequence

simplyzhao — Sat, 14 Aug 2010 03:04:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1887
http://acm.pku.edu.cn/JudgeOnline/problem?id=2533

思路:
典型而简单的动态规划，类似于最大子段和的思想:

   f[i]表示以num[i]结尾的最长下降(上升)子序列，那么:
   f[i] = max (f[j]+1, if num[j]>num[i] && 0<=j原本挺简单的代码，一会就写完了，结果却因为一个临时变量的初始化错误而WA了好多次，要细心...
上述是O(n^2)的算法，另外还有O(nlgn)的算法，下回尝试。

代码(pku 1887):
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 32767
5 int num[MAX_LEN];
6 int max[MAX_LEN];
7 int len;
8
9 /*
10  * f[i] represent the longest descent sequence ended with num[i], so:
11  *      f[i] = max ( f[j]+1, if num[j]>num[i], 0<=j12  */
13 int
14 dp()
15 {
16     int i, j, t, rt;
17     max[0] = rt = 1;
18     for(i=1; i<len; i++) {
19         t = 1; /* WA twice here, for t=-1 */
20         for(j=0; j<i; j++) {
21             if(num[j] > num[i])
22                 t = max[j]+1>t ? max[j]+1 : t;
23         }
24         max[i] = t;
25         rt = max[i]>rt ? max[i] : rt;
26     }
27     return rt;
28 }
29
30 int
31 main(int argc, char **argv)
32 {
33     int i, tmp, cnt = 0;
34     while(scanf("%d", &tmp)!=EOF && tmp!=-1) {
35         num[0] = tmp;
36         len = 1;
37         while(scanf("%d", num+len)!=EOF && num[len]!=-1)
38             ++len;
39         printf("Test #%d:\n  maximum possible interceptions: %d\n\n", ++cnt, dp());
40     }
41 }

simplyzhao 2010-08-14 11:04 发表评论

PKU 2192 Zipper

simplyzhao — Fri, 13 Aug 2010 14:33:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2192

思路:
原本以为是类似于PKU 1936的简单题，结果Sample测试不过，发现对于像cat, tree这样包含相同字母(这里是t)的例子需要回溯，于是DFS，这样结果虽然正确了，但是却TLE...
准确的做法是动态规划，艾，今天三题没有一个是自己想出来的...悲剧...
详细的状态转化方程见代码注释

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 201
5 char first[MAX_LEN+1], second[MAX_LEN+1];
6 char final[MAX_LEN*2];
7 int flen, slen, tlen;
8 int table[MAX_LEN][MAX_LEN];
9
10 /*
11  * f[i][j] represent whether final[1..i+j] could be formed from first[1..i] and second[1..j]
12  * f[i][j] is true if:
13  *         a. final[i+j]==first[i] && f[i-1][j] is true, or
14  *         b. final[i+j]==second[j] && f[i][j-1] is true
15  */
16 int
17 dp()
18 {
19     int i, j, mark;
20     mark = 1;
21     for(i=1; i<=flen; i++) {
22         if(first[i]==final[i] && mark)
23             table[i][0] = 1;
24         else {
25             table[i][0] = 0;
26             mark = 0;
27         }
28     }
29     mark = 1;
30     for(j=1; j<=slen; j++) {
31         if(second[j]==final[j] && mark)
32             table[0][j] = 1;
33         else {
34             table[0][j] = 0;
35             mark = 0;
36         }
37     }
38     for(i=1; i<=flen; i++) {
39         for(j=1; j<=slen; j++) {
40             if((final[i+j]==first[i]&&table[i-1][j]) || (final[i+j]==second[j]&&table[i][j-1]))
41                 table[i][j] = 1;
42             else
43                 table[i][j] = 0;
44         }
45     }
46     return table[flen][slen];
47 }
48
49 int
50 main(int argc, char **argv)
51 {
52     int tests, cnt=0;
53     scanf("%d", &tests);
54     while(tests--) {
55         scanf("%s %s %s", first+1, second+1, final+1);
56         flen = strlen(first+1);
57         slen = strlen(second+1);
58         tlen = strlen(final+1);
59         printf("Data set %d: %s\n", ++cnt, dp()?"yes":"no");
60     }
61 }

simplyzhao 2010-08-13 22:33 发表评论

PKU 1080 Human Gene Functions

simplyzhao — Fri, 13 Aug 2010 06:07:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1080

思路:
想法与最长公共子序列类似
用f[i][j]表示str_a[1..i]与str_b[1..j]的相似度，而所求即f[len_a][len_b]，需要注意初始化部分的代码
状态转移方程见代码注释

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 101
5 #define INF 'I'
6 #define Score(ch_a, ch_b) (score[map[ch_a-'A']][map[ch_b-'A']])
7 int len_a, len_b;
8 char str_a[MAX_LEN+1], str_b[MAX_LEN+1];
9 int table[MAX_LEN][MAX_LEN];
10 const int score[][5] = {{5,-1,-2,-1,-3}, {-1,5,-3,-2,-4}, {-2,-3,5,-2,-2}, {-1,-2,-2,5,-1}, {-3,-4,-2,-1,-65535}};
11    /* A    C          G    I                               T */
12 const int map[] = {0,-1,1,-1,-1,-1,2,-1,4,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,3};
13
14 /*
15  * f[i][j] represent the similarity of str_a[1..i] and str_b[1..j], so:
16  *    f[i][j] = max { f[i-1][j-1]+Score(str_a[i], str_b[j]),
17  *                    f[i-1][j] + Score(str_a[i], '-'),
18  *                    f[i][j-1] + Score('-', str_b[j]) }
19  */
20 int
21 dp()
22 {
23     int i, j, a, b, c, max;
24     /* Attention: Initialization */
25     table[0][0] = 0;
26     for(i=1; i<=len_a; i++)
27         table[i][0] = table[i-1][0] + Score(str_a[i], INF);
28     for(j=1; j<=len_b; j++)
29         table[0][j] = table[0][j-1] + Score(str_b[j], INF);
30
31     for(i=1; i<=len_a; i++) {
32         for(j=1; j<=len_b; j++) {
33             a = table[i-1][j-1] + Score(str_a[i], str_b[j]);
34             b = table[i-1][j] + Score(str_a[i], INF);
35             c = table[i][j-1] + Score(INF, str_b[j]);
36             max = a > b ? a : b;
37             max = c > max ? c : max;
38             table[i][j] = max;
39         }
40     }
41     return table[len_a][len_b];
42 }
43
44 int
45 main(int argc, char **argv)
46 {
47     int tests;
48     scanf("%d", &tests);
49     while(tests--) {
50         scanf("%d %s", &len_a, str_a+1);
51         scanf("%d %s", &len_b, str_b+1);
52         printf("%d\n", dp());
53     }
54 }

simplyzhao 2010-08-13 14:07 发表评论

PKU 1160 Post Office

simplyzhao — Fri, 13 Aug 2010 04:45:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1160

思路:
事先知道这是动态规划的题，于是就拼命往这方面想，想啊想啊想啊想，终于灵感一现:
   可以用f[i][j]表示到第i个村镇为止，建造j个邮局所需要的最小距离
心中窃喜，感觉应该挺靠谱，于是继续深入，直觉告诉我f[i][j]与f[i-1][j], f[i-1][j-1]应该有关系，貌似成了第i个村镇建不建邮局的子问题，继续苦思冥想，结果却还是想不出来。

无奈，还是看别人的思路吧:
   用f[i][j]表示前i个邮局建在前j个村镇所需要的最小距离(貌似，跟我之前想的刚好相反)
   f[i][j] = min( f[i-1][k] + cost[k+1][j], i-1<=k<=j-1)，cost[i][j]表示在村镇i与j之间建造一个post office的最小距离(人家说显然在中点)

艾，差之毫厘，谬以千里，如何有效地表示和分析最优子结构是关键：一个问题的解，如何通过其子问题来表示和求解

代码:
1 /* 752K 79MS */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_V 301
6 #define MAX_P 31
7 #define INF 0x7FFFFFFF
8 int v, p;
9 int pos[MAX_V];
10 int cost[MAX_V][MAX_V];
11 int table[MAX_P][MAX_V];
12
13 void
14 init()
15 {
16     int i, j, k, mid, diff;
17     for(i=1; i<=v; i++) {
18         for(j=i; j<=v; j++) {
19             diff = 0;
20             mid = (i+j)/2;
21             for(k=i; k<=j; k++)
22                 diff += ((pos[k]>pos[mid])?(pos[k]-pos[mid]):(pos[mid]-pos[k]));
23             cost[i][j] = cost[j][i] = diff;
24         }
25     }
26 }
27
28 int
29 dp()
30 {
31     int i, j, k, min, tmp;
32     memset(table, 0, sizeof(table));
33     for(j=1; j<=v; j++)
34         table[1][j] = cost[1][j];
35     for(i=2; i<=p; i++) {
36         for(j=i+1; j<=v; j++) {
37             min = INF;
38             for(k=i-1; k<=j-1; k++) {
39                 tmp = table[i-1][k] + cost[k+1][j];
40                 min = tmp<min ? tmp : min;
41             }
42             table[i][j] = min;
43         }
44     }
45     return table[p][v];
46 }
47
48 int
49 main(int argc, char **argv)
50 {
51     int i;
52     while(scanf("%d %d", &v, &p)!=EOF) {
53         for(i=1; i<=v; i++)
54             scanf("%d", pos+i);
55         init();
56         printf("%d\n", dp());
57     }
58 }

simplyzhao 2010-08-13 12:45 发表评论

PKU 1159 Palindrome

simplyzhao — Thu, 12 Aug 2010 11:47:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1159

思路:
看完题目，完全不知道该怎么做
参考discuss，发现原来DP这么这么地强大，自己那是相当菜
设ch[1]..ch[n]表示字符串1至n位，i为左游标，j为右游标，则i从n递减，j从i开始递增。 min[i][j]表示i和j之间至少需要插入多少个字符才能对称,初始置全0 ,我们最终需要得到的值是min[1][n]. 则 if(ch[i]==ch[j]) //如果两个游标所指字符相同，向中间缩小范围 min[i][j]=min[i+1][j-1]; else min[i][j] = 1 +（min[i+1][j]和min[i][j-1]中的较小值）; //如果不同，典型的状态转换方程
额，状态方程看明白了，结果发现代码居然不知道怎么写...那个汗哪...
原因是没有发现当i>j时，min[i][j] = 0

代码(记忆化搜索):
1 /* Time: 1594MS */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_LEN 5001
6 char str[MAX_LEN+1];
7 int len;
8 short memory[MAX_LEN][MAX_LEN];
9
10 /*
11  * f[i][j] represent the minimal insert for str[i..j]
12  *
13  * f[i][j] = f[i+1][j-1], if str[i]==str[j], otherwise
14  * f[i][j] = min(f[i+1][j], f[i][j-1]) + 1
15  */
16 int
17 func(int i, int j)
18 {
19     int a, b;
20     if(i >= j)
21         return 0;
22     if(memory[i][j])
23         return memory[i][j];
24     if(str[i] == str[j])
25         memory[i][j] = func(i+1, j-1);
26     else {
27         a = func(i+1, j);
28         b = func(i, j-1);
29         memory[i][j] = a<b ? a+1 : b+1;
30     }
31     return memory[i][j];
32 }
33
34 int
35 main(int argc, char **argv)
36 {
37     while(scanf("%d", &len) != EOF) {
38         memset(memory, 0, sizeof(memory));
39         scanf("%s", str+1);
40         printf("%d\n", func(1, len));
41     }
42 }

代码(dp):
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 5001
5 char str[MAX_LEN];
6 int len;
7 short table[MAX_LEN][MAX_LEN];
8
9 short
10 dp()
11 {
12     int i, j;
13     /* if i>j, then table[i][j] = 0 */
14     for(i=len-1; i>=1; i--) {
15         for(j=i; j<=len; j++) {
16             if(str[i] == str[j])
17                 table[i][j] = table[i+1][j-1];
18             else
19                 table[i][j] = table[i+1][j]<table[i][j-1] ? table[i+1][j]+1 : table[i][j-1]+1;
20         }
21     }
22     return table[1][len];
23 }
24
25 int
26 main(int argc, char **argv)
27 {
28     while(scanf("%d", &len) != EOF) {
29         memset(table, 0, sizeof(table));
30         scanf("%s", str+1);
31         printf("%d\n", dp());
32     }
33 }

simplyzhao 2010-08-12 19:47 发表评论

PKU 2250 Compromise

simplyzhao — Thu, 12 Aug 2010 07:32:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2250

思路:
以单词为单位的LCS，另外需要记录路径信息

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_NUM 101
5 #define MAX_LEN 31
6 char first[MAX_NUM][MAX_LEN];
7 char second[MAX_NUM][MAX_LEN];
8 int fcnt, scnt;
9 int table[MAX_NUM][MAX_NUM];
10 char path[MAX_NUM][MAX_NUM];
11
12 void
13 output(int i, int j)
14 {
15     if(i==0 || j==0)
16         return;
17     if(path[i][j] == 'u')
18         output(i-1, j);
19     else if(path[i][j] == 'l')
20         output(i, j-1);
21     else {
22         output(i-1, j-1);
23         printf("%s ", first[i-1]);
24     }
25 }
26
27 void
28 lcs()
29 {
30     int i, j;
31     for(i=0; i<=fcnt; i++)
32         table[i][0] = 0;
33     for(j=0; j<=scnt; j++)
34         table[0][j] = 0;
35     for(i=1; i<=fcnt; i++) {
36         for(j=1; j<=scnt; j++) {
37             if(strcmp(first[i-1], second[j-1]) == 0) {
38                 table[i][j] = table[i-1][j-1] + 1;
39                 path[i][j] = 'y';
40             } else if(table[i-1][j] > table[i][j-1]) {
41                 table[i][j] = table[i-1][j];
42                 path[i][j] = 'u';
43             } else {
44                 table[i][j] = table[i][j-1];
45                 path[i][j] = 'l';
46             }
47         }
48     }
49 }
50
51 int
52 main(int argc, char **argv)
53 {
54     while(1) {
55         fcnt = scnt = 0;
56         memset(table, 0, sizeof(table));
57         memset(path, 0, sizeof(path));
58         if(scanf("%s", first[fcnt++]) == EOF)
59             break;
60         while(scanf("%s", first[fcnt]) && first[fcnt][0]!='#')
61             ++fcnt;
62         while(scanf("%s", second[scnt]) && second[scnt][0]!='#')
63             ++scnt;
64         lcs();
65         output(fcnt, scnt);
66         printf("\n");
67     }
68 }

simplyzhao 2010-08-12 15:32 发表评论

PKU 1953 World Cup Noise

simplyzhao — Thu, 12 Aug 2010 04:57:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1953

思路:
如果想通了，其实就是道挺简单的动规题
zero_end[i]记录第i位以0结尾的合法排列
one_end[i]记录第i位以1结尾的合法排列
状态方程即:
   zero_end[i+1] = zero_end[i] + one_end[i]
   one_end[i+1] = zero_end[i]
以深度搜索的递归树即可观察得出以上结论(*^__^*) 嘻嘻……

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 45
5 int zero_end[MAX_LEN+1];
6 int one_end[MAX_LEN+1];
7
8 int
9 build_table()
10 {
11     int i;
12     zero_end[1] = 1;
13     one_end[1] = 1;
14     for(i=2; i<=45; i++) {
15         zero_end[i] = zero_end[i-1] + one_end[i-1];
16         one_end[i] = zero_end[i-1];
17     }
18 }
19
20 int
21 main(int argc, char **argv)
22 {
23     int i, n, tests;
24     build_table();
25     scanf("%d", &tests);
26     for(i=1; i<=tests; i++) {
27         scanf("%d", &n);
28         printf("Scenario #%d:\n%d\n\n", i, zero_end[n]+one_end[n]);
29     }
30 }

simplyzhao 2010-08-12 12:57 发表评论

PKU 1163 The Triangle

simplyzhao — Thu, 12 Aug 2010 03:06:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1163

思路:
比较基础、容易的动态规划
table[i][j]记录从根节点到第i行第j个元素的最大和
状态转移方程:
   table[i][j] = max(table[i][j-1], table[i][j]) + num[i][j]

为了节省空间，对于三角形的保存，采用了一维数组

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_N 101
5 #define MAX_LEN 5051 /* 1+2+3++100 */
6 int rows, num[MAX_LEN];
7 int table[MAX_N][MAX_N];
8
9 /* table[i][j] = max(table[i-1][j-1]+num[i][j], table[i-1][j]+num[i][j] */
10 int
11 dp()
12 {
13     int i, j, k, tmp, max, rt;
14     table[0][0] = num[0];
15     for(i=1; i<rows; i++) {
16         tmp = i*(i+1)/2;
17         for(j=0; j<=i; j++) {
18             max = 0;
19             for(k=1; k>=0; k--)
20                 if(j-k>=0 && j-k<=i-1) /* parent index: [i-1][j-k] */
21                     max = table[i-1][j-k]+num[tmp+j]>max ? table[i-1][j-k]+num[tmp+j] : max;
22             table[i][j] = max;
23         }
24     }
25     rt = 0;
26     for(j=0; j<rows; j++)
27         if(table[rows-1][j] > rt)
28             rt = table[rows-1][j];
29     return rt;
30 }
31
32 int
33 main(int argc, char **argv)
34 {
35     int i, j, tmp;
36     while(scanf("%d", &rows) != EOF) {
37         for(i=0; i<rows; i++) {
38             tmp = i*(i+1)/2;
39             for(j=0; j<=i; j++)
40                 scanf("%d", num+(tmp+j));
41         }
42         memset(table, 0, sizeof(table));
43         printf("%d\n", dp());
44     }
45 }

simplyzhao 2010-08-12 11:06 发表评论

[多重背包]PKU 1276 Cash Machine

simplyzhao — Wed, 11 Aug 2010 14:03:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1276

思路:
典型的多重背包问题，参考背包九讲，一次AC
深刻理解：01背包、完全背包、多重背包

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_VOLUMN 100001
5 #define MAX_N 11
6 #define max(a,b) ((a)>(b) ? (a) : (b))
7 int vol, n;
8 int cv[MAX_N], num[MAX_N], f[MAX_VOLUMN];
9
10 /* f[i][v] = max(f[i-1][v], f[i-1][v-cost[i]]+value[i]) */
11 void
12 ZeroOnePack(int cost, int value)
13 {
14     int v;
15     for(v=vol; v>=cost; v--)
16         f[v] = max(f[v], f[v-cost]+value);
17 }
18
19 /* f[i][v] = max(f[i-1][v], f[i][v-cost[i]]+value[i]) */
20 void
21 CompletePack(int cost, int value)
22 {
23     int v;
24     for(v=cost; v<=vol; v++)
25         f[v] = max(f[v], f[v-cost]+value);
26 }
27
28 void
29 MultiplePack(int cost, int value, int amount)
30 {
31     int k = 1;
32     if(cost*amount >= vol)
33         CompletePack(cost, value);
34     else {
35         while((amount-k) >= 0) {
36             ZeroOnePack(cost*k, value*k);
37             amount -= k;
38             k = k*2;
39         }
40         ZeroOnePack(cost*amount, value*amount);
41     }
42 }
43
44 void
45 dp()
46 {
47     int i;
48     for(i=1; i<=n; i++)
49         MultiplePack(cv[i], cv[i], num[i]);
50 }
51
52 int
53 main(int argc, char **argv)
54 {
55     int i;
56     while(scanf("%d %d", &vol, &n)!=EOF) {
57         memset(f, 0, sizeof(f));
58         for(i=1; i<=n; i++)
59             scanf("%d %d", num+i, cv+i);
60         dp();
61         printf("%d\n", f[vol]);
62     }
63 }

simplyzhao 2010-08-11 22:03 发表评论

[0-1背包]PKU 3624 Charm Bracelet

simplyzhao — Wed, 11 Aug 2010 02:57:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=3624

思路:
典型的01背包问题，动态规划，参考背包九讲
注意需要使用滚动数组，否则MLE

代码:
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_N 3403
5 #define MAX_M 12881
6 #define max(a,b) ((a)>(b) ? (a) : (b))
7 int n, m;
8 /* MLE: int table[MAX_N][MAX_M]; */
9 int table[MAX_M];
10 int weight[MAX_N], rate[MAX_N];
11
12 void
13 dp()
14 {
15     int i, j;
16     memset(table, 0, sizeof(table));
17     for(i=1; i<=n; i++)
18         for(j=m; j>=weight[i]; j--) /* Attention: descent order */
19             table[j] = max(table[j], table[j-weight[i]]+rate[i]);
20 }
21
22 int
23 main(int argc, char **argv)
24 {
25     int i;
26     while(scanf("%d %d", &n, &m)!=EOF) {
27         for(i=1; i<=n; i++)
28             scanf("%d %d", weight+i, rate+i);
29         dp();
30         printf("%d\n", table[m]);
31     }
32 }

simplyzhao 2010-08-11 10:57 发表评论

PKU 1015 Jury Compromise

simplyzhao — Sun, 04 Jul 2010 01:34:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1015

思路:
最小差最大和问题

这题...一点想法都没有，就是不会写，只好上网搜索人家的思路，总结如下
动态规划状态方程:
   f(j, k) = f(j-1, x), x+(di-pi) = k
这里，f(j, k)表示选择了j个人，其最小差为k且满足最大和的解
另外，还需要记录已选择了哪些人，因为在状态迁移的过程中，只能选择之前未被选择过的人

1     int base = m*MAX_GRADE; /* 防止出现负数 */
2     memset(f, -1, sizeof(f));
3     memset(sum, -1, sizeof(sum));
4     /* initialize */
5     for(i=1; i<=n; i++)
6         if(sum[1][minus[i]+base] < plus[i]) {
7             f[1][minus[i]+base] = i;
8             sum[1][minus[i]+base] = plus[i];
9         }
10     for(j=2; j<=m; j++) {
11         for(k=0; k<=2*m*MAX_GRADE; k++) {
12             if(f[j-1][k] != -1) {
13                 for(i=1; i<=n; i++) {
14                     /* see if i has been used */
15                     q = k;
16                     for(p=j-1; p>=1; p--) {
17                         if(f[p][q] == i)
18                             break;
19                         q -= minus[f[p][q]];
20                     }
21                     if(p<1) {
22                         if(sum[j][k+minus[i]] < sum[j-1][k]+plus[i]) {
23                             f[j][k+minus[i]] = i;
24                             sum[j][k+minus[i]] = sum[j-1][k]+plus[i];
25                         }
26                     }
27                 }
28             }
29         }
30     }



simplyzhao 2010-07-04 09:34 发表评论

PKU 1088 滑雪

simplyzhao — Tue, 29 Jun 2010 15:56:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1088

思路1:
这题是前段时间微软笔试的最后一道大题，当时没想太多，直接简单DFS，没想到会超时，结果嘛直接被BS了...太菜啊
我们从最优解开始分析:
   设p[1]--p[2]--p[3]...--p[n]即为最长的一条路径L, p[i]=(xi, yi)
   对于该路径L中的一个点p[i], 可以这样来理解: 到达点p[i]的最长路径是到达点p[i-1]的最长路径加1，并且height(p[i-1])大于height(p[i])
   因此，我们可以先将输入地图按照高度从高到低排序，然后从头开始依次求出最长路径
需要注意的一点：
下面代码的第8行需要设置max为1，而不是0，因为该点可能是最高点(peek)
1 int
2 dp()
3 {
4     int total = row*col;
5     int i, j, x, y, sx, sy, td, max, longest=1;
6     distance[points[0].x][points[0].y] = 1; //highest point
7     for(i=1; i<total; i++) {
8         max = 1; //max should be set 1, in case points[i] is a peek
9         x = points[i].x;
10         y = points[i].y;
11         for(j=0; j<4; j++) { //four directions
12             sx = x+dx[j];
13             sy = y+dy[j];
14             //points[sx*col+sy] is a higher point around points[i]
15             if(can_go(sx, sy) && points[i].height<height[sx*col+sy]) { //distance[sx][sy]>0 indicates (sx, sy) a higher point
16                 td = distance[sx][sy]+1;
17                 max = max > td ? max : td;
18             }
19         }
20         distance[x][y] = max;
21         longest = longest > max ? longest : max;
22     }
23     return longest;
24 }

思路2:
备忘录方法
这里我们换一种看待该问题的方式
该题有一个很自然的想法，那就是依次枚举每个点，计算从每个点出发的最长路径，最后求这些最长路径的最大值即可
从一个点p[i]出发的最长路径是: 从其上下左右四个点出发的最长路径的最大值加1

备忘录方法真的非常好用，而且理解起来也较动态规划简单呵呵，原本超时的代码只要稍加修改就可以AC了
1 int
2 dp_memory(int x, int y)
3 {
4     if(opt[x][y] != 0) //memory, simple but powerful
5         return opt[x][y];
6
7     int max = 0;
8     int i, sx, sy, tmp;
9     for(i=0; i<4; i++) { // four directions
10         sx = x + dx[i];
11         sy = y + dy[i];
12         if(sx>=0 && sx<=row-1 && sy>=0 && sy<=col-1 && map[sx][sy]<map[x][y]) {
13             tmp = dp_memory(sx, sy);
14             max = max > tmp ? max : tmp;
15         }
16     }
17     opt[x][y] = max+1;
18     return opt[x][y];
19 }
1 for(i=0; i<row; i++)
2         for(j=0; j<col; j++) {
3             tmp = dp_memory(i, j);
4             max = max > tmp ? max : tmp;
5         }
6

simplyzhao 2010-06-29 23:56 发表评论

PKU 1579 Function Run Fun

simplyzhao — Tue, 29 Jun 2010 14:52:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1579

思路:
根据题意的描述，采用递归是显然易见的
不过，该题的另一个突出的特点是重复子问题，如何既可以获得递归的简洁，又同时可以避免重复子问题的多次计算呢？
这时，就可以采用备忘录方法

1 #define MAX 21
2 long table[MAX][MAX][MAX];
3
4 long
5 function_run_fun(int a, int b, int c)
6 {
7     if(a<=0 || b<=0 || c<=0)
8         return 1;
9     if(a>20 || b>20 || c>20)
10         return (table[20][20][20] = function_run_fun(20, 20, 20));
11
12     if(table[a][b][c] != 0) //memory search
13         return table[a][b][c];
14
15     else if(a<b && b<c)
16         table[a][b][c] = function_run_fun(a, b, c-1) + function_run_fun(a, b-1, c-1) - function_run_fun(a, b-1, c);
17     else
18         table[a][b][c] = function_run_fun(a-1, b, c) + function_run_fun(a-1, b-1, c) + function_run_fun(a-1, b, c-1) - function_run_fun(a-1, b-1, c-1);
19     return table[a][b][c];
20 }

simplyzhao 2010-06-29 22:52 发表评论

PKU 3356 AGTC

simplyzhao — Tue, 29 Jun 2010 14:39:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=3356

思路:
与最长公共子序列挺相似的一道动态规划
   if(first[i] == second[j])
   f(i, j) = min(f(i-1, j-1)[nothing], f(i-1, j)+1[deletion], f(i, j-1)+1[insertion])
   else
   f(i, j) = min(f(i-1, j-1)+1[change], f(i-1, j)+1[deletion], f(i, j-1)+1[insertion])

其中，f(i, j)表示使first[0..i]转化成second[0..j]所需要的最小操作数

一个需要注意的问题是table的初始化，一开始想当然地将table[i][0], table[0][j]初始化为无穷大，导致出错
这可以说是一个普遍化的问题，就是要注意动态规划时的初始化

1 int
2 dfs()
3 {
4     int i, j;
5     /* Attention: initialize */
6     /* set table[i][0] and table[0][j] to INT_MAX, which caused WA */
7     for(i=0; i<=m; i++)
8         table[i][0] = i;
9     for(j=0; j<=n; j++)
10         table[0][j] = j;
11     for(i=1; i<=m; i++) {
12         for(j=1; j<=n; j++) {
13             if(x[i-1] == y[j-1])
14                 table[i][j] = min(table[i-1][j-1], table[i-1][j]+1, table[i][j-1]+1);
15             else
16                 table[i][j] = min(table[i-1][j-1], table[i-1][j], table[i][j-1]) + 1;
17         }
18     }
19     return table[m][n];
20 }

simplyzhao 2010-06-29 22:39 发表评论

PKU 1458 Common Subsequence

simplyzhao — Tue, 29 Jun 2010 14:06:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1458

思路:
额...最长公共子序列(LCS), 经典动态规划(详情见CLRS)
   if(first[i] == second[j])
   f(i, j) = f(i-1, j-1) + 1
   else
   f(i, j) = max(f(i-1, j), f(i, j-1))

1 int
2 dp_lcs()
3 {
4     int i, j;
5     for(i=0; i<=m; i++)
6         table[i][0] = 0;
7     for(j=0; j<=n; j++)
8         table[0][j] = 0;
9
10     for(i=1; i<=m; i++) {
11         for(j=1; j<=n; j++) {
12             if(fst[i-1] == snd[j-1])
13                 table[i][j] = table[i-1][j-1] + 1;
14             else
15                 table[i][j] = max(table[i-1][j], table[i][j-1]);
16         }
17     }
18     return table[m][n];
19 }

simplyzhao 2010-06-29 22:06 发表评论

PKU 2479 Maximum sum/2593 Max Sequence/1050 To the Max

simplyzhao — Tue, 29 Jun 2010 08:48:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2479
http://acm.pku.edu.cn/JudgeOnline/problem?id=2593
http://acm.pku.edu.cn/JudgeOnline/problem?id=1050

思路:
基础: 最大子段和问题
给定N个整数(可能为负)组成的序列a1, a2, a3, ..., aN，求子段ai, a(i+1), ... , aj的和的最大值
非常典型的动态规划，状态迁移方程:
   f(i) = max(ai, f[i-1]+ai), f(i)表示以ai结尾的最大子段和
据此我们可以得到O(n)的求解算法

PKU 2479与2593这两题其实是同一个问题(买一送一)，都是上述最大子段和问题的变形
一样非常自然的想法是枚举所有可能的"分开点", 然后分别计算前后两个子数组的最大子段和，不过如果依次枚举的话是会超时的
这时候就需要利用对于上述f(i)表达式的理解了, 我们可以依次从头到尾、从尾到头扫描两次原数组，并把相应的最大子段和分别保存起来，称为hd[i]和tl[i], 这里注意f(i)并非是最大子段和
假设现在枚举到分开点t, 那么a[0..t]的最大子段和可以通过hd[i]获得，a[t+1...len]的最大子段和则可以通过tl[i]获得
1 /*
2  * hd[i] stores the maximum sub-segment from arr[0..i]
3  * tl[i] stores the maximum sub_segment from arr[i+1..n-1]
4  */
5 long *hd, *tl;
6
7 long
8 max_subsum(int *arr, long N)
9 {
10     long i, temp, max;
11     /* hd */
12     hd[0] = max = arr[0];
13     for(i=1; i<N; i++) {
14         temp = hd[i-1] + arr[i];
15         hd[i] = temp>arr[i] ? temp : arr[i];
16     }
17     for(i=1; i<N; i++) {
18         hd[i] = hd[i] > max ? hd[i] : max;
19         max = hd[i];
20     }
21     /* tl */
22     tl[N-1] = max = arr[N-1];
23     for(i=N-2; i>=0; i--) {
24         temp = tl[i+1] + arr[i];
25         tl[i] = temp>arr[i] ? temp : arr[i];
26     }
27     for(i=N-2; i>=0; i--) {
28         tl[i] = tl[i] > max ? tl[i] : max;
29         max = tl[i];
30     }
31 }
32
33 long
34 enumerate()
35 {
36     long i, temp, max = hd[0] + tl[1];
37     for(i=1; i<n-1; i++) {
38         temp = hd[i] + tl[i+1];
39         max = max>temp ? max : temp;
40     }
41     return max;
42 }

PKU 1050是一道"隐藏"地比较深的最大子段和问题，之所以说它隐藏的比较深，是因为题目要求的是求最大子矩阵问题
上网搜了别人的思路，才发现这题是可以转化成求最大子段和问题的：只要将矩阵的行或者列合并即可
不得不感叹这思路的精妙啊呵呵
1 int
2 max_subsum(int *arr, int N)
3 {
4     int i, t, max;
5     max = t = arr[0];
6     for(i=1; i<N; i++) {
7         t = t+arr[i]>arr[i] ? t+arr[i] : arr[i];
8         max = max>t ? max : t;
9     }
10     return max;
11 }
12
13 int
14 enumerate()
15 {
16     int t, max = 0;
17     int i, j, k, len, temp[col];
18     memset(temp, 0, sizeof(int)*col);
19     for(len=1; len<=row; len++) {
20         for(i=0; i<row; i++) {
21             for(j=i; j<len; j++) {
22                 for(k=0; k<col; k++) {
23                     temp[k] += arr[j][k];
24                 }
25             }
26             t = max_subsum(temp, col);
27             max = max>t ? max : t;
28             memset(temp, 0, sizeof(int)*col);
29         }
30     }
31     return max;
32 }

simplyzhao 2010-06-29 16:48 发表评论

PKU 1014 Dividing

simplyzhao — Mon, 28 Jun 2010 15:30:00 GMT
问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1014

思路:
1. 深度搜索
看到该题的第一个想法就是DFS，很快就写出了代码:
1 void
2 dfs(int *values, int index, long cur_value_sum)
3 {
4     if(cur_value_sum >= value_half) {
5         if(cur_value_sum == value_half)
6             flag = 1;
7         return;
8     }
9     if(index < 1)
10         return;
11     int i;
12     for(i=values[index]; i>=0 && (!flag); i--) {
13         cur_value_sum += (i*index);
14         dfs(values, index-1, cur_value_sum);
15         cur_value_sum -= (i*index);
16     }
17 }
额...结果TLE...
仔细看题，发现maximum total number will be 20000, 所以超时几乎是肯定的
其实，discuss里有人用DFS+Cut通过的，只是自己太菜，还不会减枝

2. 动态规划
2.1 from: http://www.cppblog.com/AClayton/archive/2007/09/14/32185.html
声明数组can_reach[60005]
can_reach[i]=1, 表示存在一个人获得价值为 i ,另一个人获得价值为value_sum-i的方案
我们的目标就是要确定can_reach[value_sum>>1]是否等于1
1 int
2 dp()
3 {
4     int i, j, k, temp, cur_max = 0;
5     can_reach[0] = 1;
6     for(i=1; i<=VALUE_MAX; i++) {
7         if(num[i] > 0) {
8             for(j=cur_max; j>=0; j--) { /* tricky, pay attention */
9                 if(can_reach[j]) {
10                     for(k=1; k<=num[i]; k++) {
11                         temp = i*k+j;
12                         if(temp == value_half)
13                             return 1;
14                         if(temp>value_half) /*  initial: if(temp>value_half || can_reach[temp]) break; */
15                             break;
16                         can_reach[temp] = 1;
17                     }
18                 }
19             }
20         }
21         cur_max += (i*num[i]);
22         if(cur_max>value_half)
23             cur_max = value_half;
24     }
25 }
注意: 上述代码的第14行，原文中存在减枝，但没有看懂，所以没有放进去，还好，该代码还是AC了

2.2 from: http://blog.sina.com.cn/s/blog_5c95cb070100cvt8.html
该问题可以转化成一个0-1背包模型(见：背包九讲)
关键是下面的数论知识:
对于任意一个正整数 n, 它可以表示成:
   n = 1 + 1<<1 + 1<<2 + ... + 1<我们可以得到：对于1<=i<=n的任意正整数 i, 它肯定可以表示成: 1, 1<<1, 1<<2, ... 1<因此，对于该题，我们可以对输入做预处理:
1 len = 0;
2 memset(value_weight, 0, sizeof(value_weight));
3 for(i=1; i<=VALUE; i++) {
4     if(num[i] != 0) {
5    j = 0;
6      while((1<<(j+1)) <= (num[i]+1)) {
7    value_weight[len++] = i*(1<<j);
8    ++j;
9    }
10    if((num[i]+1-(1<<j))>0)
11    value_weight[len++] = i*(num[i]+1-(1<<j));
12    }
13 }
接下来，原问题就转化成:
背包容量value_half(value_sum/2)，每件物品的cost与value都是value_weight[i]，考虑是否存在一种方案，使得总价值等于value_half
0-1背包的典型DP状态方程:
   f[i][j] = max(f[i-1][j], f[i-1][j-c[i]]+v[i]), f[i][j]表示前i件物品放入容量为j的背包而可以获得的最大价值
1 int
2 knapsack()
3 {
4     int i, w, pre, cur;
5     memset(table, 0, sizeof(table));
6     for(w=value_weight[0]; w<=value_half; w++) {
7         table[0][w] = value_weight[0];
8         if(table[0][w] == value_half)
9             return 1;
10     }
11     for(i=1; i<len; i++) {
12         cur = i%2;
13         pre = (i+1)%2;
14         for(w=0; w<=value_half; w++) {
15             if(w>=value_weight[i])
16                 table[cur][w] = max(table[pre][w], table[pre][w-value_weight[i]]+value_weight[i]);
17             else
18                 table[cur][w] = table[pre][w];
19             if(table[cur][w] == value_half)
20                 return 1;
21         }
22     }
23     return 0;
24 }
AC [ Memory: 836K, Time: 16MS]

simplyzhao 2010-06-28 23:30 发表评论