C++博客-y @ The Angry Teletubbies-文章分类-DP

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这条链合并，好复杂，不会表达了，直接研究代码吧。

【代码】：

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

hdoj 4301 Divide Chocolate - dp + 延长分割线

y @ The Angry Teletubbies — Fri, 20 Jul 2012 04:00:00 GMT

【题意】：给一块n*2的巧克力，问分成k块的方案数有多少种。

【题解】：多校联赛第一场的b，想了2个小时，途中出现MLE,TLE，最后还是AC了。
设状态dp[i][j][0-7]表示处理完第i列已经分成j块且第i列的分割线状态为0-7的方案数。
0：空 1：─ 2：┐ 3：┘ 4：│ 5：┤ 6：_|7：^|
转移即是延长或终止上一列的分割线或加入新的分割线，具体看代码。

【代码】：

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 const int MOD = 100000007;
26 int dp[2][2010][10];
27 int ans[1010][2010];
28 int n, m;
29
30 void init() {
31     memset(dp, 0, sizeof(dp));
32     dp[0][0][4] = 1;
33     int p3 = 0, p2 = 1;
34     for(int i = 1; i <= 1000; i++) {
35         swap(p3, p2);
36         for(int j = 0; j <= (i << 1); j++)
37             for(int k = 0; k < 8; k++)
38                 dp[p3][j][k] = 0;
39         for(int j = 0; j <= (i << 1); j++) {
40             dp[p3][j][0] = (dp[p2][j][0] + dp[p2][j][2] + dp[p2][j][3] + dp[p2][j][4] + dp[p2][j][5]) % MOD;
41             dp[p3][j][1] = (dp[p2][j][1] + dp[p2][j][2] + dp[p2][j][3] + dp[p2][j][4] + dp[p2][j][5] + dp[p2][j][6] + dp[p2][j][7]) % MOD;
42             dp[p3][j][6] = dp[p3][j][7] = (dp[p2][j][0] + dp[p2][j][2] + dp[p2][j][3] + dp[p2][j][4] + dp[p2][j][5]) % MOD;
43       //      dp[p3][j][7] = (dp[p2][j][0] + dp[p2][j][2] + dp[p2][j][3] + dp[p2][j][4] + dp[p2][j][5]) % MOD;
44             if(j >= 1) {
45                 dp[p3][j][3] = dp[p3][j][2] = (dp[p2][j-1][1] + dp[p2][j-1][2] + dp[p2][j-1][3] + dp[p2][j-1][4] + dp[p2][j-1][5] + dp[p2][j-1][6] + dp[p2][j-1][7]) % MOD;
46         //        dp[p3][j][3] = (dp[p2][j-1][1] + dp[p2][j-1][2] + dp[p2][j-1][3] + dp[p2][j-1][4] + dp[p2][j-1][5] + dp[p2][j-1][6] + dp[p2][j-1][7]) % MOD;
47                 dp[p3][j][4] = (dp[p2][j-1][0] + dp[p2][j-1][2] + dp[p2][j-1][3] + dp[p2][j-1][4] + dp[p2][j-1][5]) % MOD;
48             }
49             if(j >= 2) dp[p3][j][5] = (dp[p2][j-2][1] + dp[p2][j-2][2] + dp[p2][j-2][3] + dp[p2][j-2][4] + dp[p2][j-2][5] + dp[p2][j-2][6] + dp[p2][j-2][7]) % MOD;
50             ans[i][j] = (dp[p3][j][4] + dp[p3][j][5]) % MOD;
51         }
52     }
53 }
54
55 int main() {
56     int T;
57     init();
58     scanf("%d", &T);
59     while(T--) {
60         scanf("%d%d", &n, &m);
61         printf("%d\n", ans[n][m]);
62     }
63     return 0;
64 }
65

y @ The Angry Teletubbies 2012-07-20 12:00 发表评论

hdoj 3311 Dig The Wells - 斯坦纳树 + 两次dp

y @ The Angry Teletubbies — Wed, 18 Jul 2012 07:19:00 GMT

【题意】：给定n(n<=5)个必选点，和m(m<=1000)个辅助点，每个点都有权值表示在这个点挖井的费用。还有p条边，每条边都有费用。问使得1-n个点都有水喝的最小费用是多少。

【题解】：显然最后求出来的解可能是一个森林。
设状态dp[i][j]表示在 i 挖井且连通了 j 这些点的最小费用。
状态minn[i]表示 i 这些点都有水喝的最小费用。
我的思路是用斯坦纳树求出所有dp[i][j]的值，然后再dp一次，求出minn[i]的值。ans = min[(1<
看到还有一种解法，就是加入一个虚拟结点，然后每个点都向虚拟结点连边，费用是每个结点挖井的费用。这样处理后就没有点权只有边权了，而且1-n号点最后一定是连通的，然后求一次斯坦纳树就可以了。

【代码】：

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 #define maxn 1050
26 const int inf = 1 << 29;
27 struct Edge {
28     int v, w;
29     Edge(){}
30     Edge(int _v, int _w) {
31         v = _v, w = _w;
32     }
33 };
34 int n, m, p;
35 int dp[maxn][1<<5], minn[1<<5];
36 int val[maxn], hash[maxn];
37 bool visit[maxn][1<<5];
38 vector vec[maxn];
39 queue<int> que;
40 void update(int cost, int v, int nst) {
41     if(cost < dp[v][nst]) {
42         dp[v][nst] = cost;
43         if(!visit[v][nst]) {
44             que.push(v + (nst << 10));
45             visit[v][nst] = true;
46         }
47     }
48 }
49
50 void solve() {
51     while(!que.empty()) que.pop();
52     memset(hash, 0, sizeof(hash));
53     memset(visit, false, sizeof(visit));
54     int nn = 1 << n;
55     for(int i = 0; i <= n + m; i++)
56         for(int j = 0; j < nn; j++)
57             dp[i][j] = inf;
58     for(int i = 1; i <= n; i++) {
59         hash[i] = 1 << (i - 1);
60         update(val[i], i, hash[i]);
61     }
62     while(!que.empty()) {
63         int now = que.front();
64         que.pop();
65         int u = now % (1 << 10), st = now >> 10;
66         visit[u][st] = false;
67         int size = vec[u].size();
68         for(int i = 0; i < size; i++) {
69             int v = vec[u][i].v, w = vec[u][i].w;
70             update(dp[u][st] + w - val[u] + val[v], v, st | hash[v]);
71         }
72         int t = nn - 1 - st;
73         for(int i = t; i; i = (i - 1) & t) {
74             update(dp[u][st] + dp[u][i|hash[u]] - val[u], u, st | i);
75         }
76     }
77     for(int i = 0; i < nn; i++) {
78         minn[i] = inf;
79         for(int j = 0; j <= n + m; j++)
80             minn[i] = min(minn[i], dp[j][i]);
81     }
82     for(int i = 0; i < nn; i++)
83         for(int j = i; j; j = (j - 1) & i)
84             minn[i] = min(minn[i], minn[i-j] + minn[j]);
85     printf("%d\n", minn[nn-1]);
86 }
87
88 int main() {
89     while(~scanf("%d%d%d", &n, &m, &p)) {
90         for(int i = 0; i < maxn; i++) vec[i].clear();
91         for(int i = 1; i <= n + m; i++) scanf("%d", &val[i]);
92         for(int i = 0; i < p; i++) {
93             int u, v, w;
94             scanf("%d%d%d", &u, &v, &w);
95             vec[u].pb(Edge(v, w));
96             vec[v].pb(Edge(u, w));
97         }
98         solve();
99     }
100     return 0;
101 }
102

y @ The Angry Teletubbies 2012-07-18 15:19 发表评论

poj 1185 炮兵阵地 - 状态压缩dp + 预处理

y @ The Angry Teletubbies — Sat, 02 Jun 2012 04:48:00 GMT

【题意】：司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示：

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。
现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。

【题解】：经典的状态压缩dp。
因为每行最多只有10个格子，考虑使用状态压缩。
无效的状态有很多，需要先预处理出所有合法状态，最多只有60种，存放在st[]。
设dp[i][j][k]表示当前第i行的状态为st[j]且第i-1行的状态为st[k]能够摆放部队的最大值。

转移方程：
dp[i][j][k] = max(cnt[j] + dp[i-1][k][kk])

最后的ans = max(dp[n-1][i][j]).

【代码】：

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 const int inf = 1 << 25;
26 int n, m;
27 char maz[110][15];
28 int row[110];
29 int dp[110][70][70];
30 int st[70], tot, cnt[70];
31
32 void init() {
33     tot = 0;
34     memset(cnt, 0, sof(cnt));
35     int nn = 1 << m;
36     for(int i = 0; i < nn; i++) {
37         bool flag = true;
38         int tmp = 0;
39         for(int j = m - 1; j >= 0; j--) {
40             if(i & (1 << j)) {
41                 tmp++;
42                 if((j >= 1) && (i & (1 << (j-1)))) {
43                     flag = false;
44                     break;
45                 }
46                 if((j >= 2) && (i & (1 << (j-2)))) {
47                     flag = false;
48                     break;
49                 }
50             }
51         }
52         if(flag) {
53             st[tot] = i, cnt[tot++] = tmp;
54         }
55     }
56 }
57
58 void solve() {
59     init();
60     for(int i = 0; i < n; i++)
61         for(int j = 0; j < tot; j++)
62             for(int k = 0; k < tot; k++)
63                 dp[i][j][k] = -inf;
64
65     for(int i = 0; i < tot; i++) {
66         if(!(st[i] & row[0])) dp[0][i][0] = cnt[i];
67         else dp[0][i][0] = -inf;
68         for(int j = 1; j < tot; j++) dp[0][i][j] = -inf;
69     }
70
71     for(int i = 1; i < n; i++)
72         for(int j = 0; j < tot; j++)
73             if(!(row[i] & st[j]))
74                 for(int k = 0; k < tot; k++)
75                     if(!(st[j] & st[k]))
76                         for(int kk = 0; kk < tot; kk++)
77                             if(!(st[j] & st[kk]))
78                                 dp[i][j][k] = max(dp[i][j][k], cnt[j] + dp[i-1][k][kk]);
79
80     int ans = 0;
81     for(int i = 0; i < tot; i++)
82         for(int j = 0; j < tot; j++)
83             ans = max(ans, dp[n-1][i][j]);
84     printf("%d\n", ans);
85 }
86
87 int main() {
88     while(~scanf("%d%d", &n, &m)) {
89         memset(row, 0, sof(row));
90         for(int i = 0; i < n; i++) {
91             scanf("%s", maz[i]);
92             for(int j = m - 1; j >= 0; j--) {
93                 row[i] <<= 1;
94                 if(maz[i][j] == 'H') row[i] |= 1;
95             }
96         }
97         solve();
98     }
99     return 0;
100 }
101

y @ The Angry Teletubbies 2012-06-02 12:48 发表评论

zoj 3505 Yet Another Set of Numbers - dp + 数位统计 + 逼近

y @ The Angry Teletubbies — Wed, 16 May 2012 15:49:00 GMT

【题意】：略

【题解】：比较经典的DP加计数问题模型，可以算这类问题里比较简单的一个例子。只要实现str2id和id2str两个函数就好了。DP只是简单的sum{3^i}，而计数部分，也就是str2id和id2str这两个函数，也和最经典的那种求第k个C(n, m)组合的算法一样。PS: 题目所描述的集合其实是相当于是给一个深度为n的三叉树的每个节点进行遍历标号。

【代码】：

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 #define maxn 25
26 ll dp[maxn];
27
28 ll id(int n, char c, char *s) {
29     if(*s == 0) return 0;
30     ll tmp = 1;
31     for(char i = '0'; i < *s; i++) {
32         if(i == c) continue;
33         tmp += dp[n-1];
34     }
35     tmp += id(n - 1, *s, s + 1);
36     return tmp;
37 }
38
39 void dfs(int n, ll k, char c, char *s) {
40     if(k == 0) {
41         *s = '\0';
42     } else {
43         k--;
44         for(*s = '0'; ; (*s)++) {//++*s
45             if(*s == c) continue;
46             if(k < dp[n-1]) {
47                 dfs(n - 1, k, *s, s + 1);
48                 break;
49             } else k -= dp[n-1];
50         }
51     }
52 }
53
54 int main() {
55     int n;
56     ll k;
57     char s[maxn];
58     dp[0] = 1;
59     for(int i = 1; i < maxn; i++) dp[i] = dp[i-1] * 3;
60     for(int i = 1; i < maxn; i++) dp[i] += dp[i-1];
61     while(~scanf("%d%lld%s", &n, &k, s)) {
62         k = id(n, '0', s) - k;
63         dfs(n, k, '0', s);
64         puts(s);
65     }
66     return 0;
67 }
68

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

UESTC 1649 D hours - dp + 巧妙转换

y @ The Angry Teletubbies — Wed, 09 May 2012 02:15:00 GMT

【题解】：

【代码】：

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 #define MAX 110
26 const int inf = 1 << 29;
27 int dp[MAX][MAX][3];
28 int sum[MAX][MAX];
29 int n, m;
30 void solve() {
31     memset(dp, 0, sof(dp));
32     int ans = 0;
33     for(int i = 1; i <= n; i++) {
34         for(int j = 1; j <= m; j++) {
35             for(int k = 1; k <= j; k++) {
36                 if(k & 1) {
37                     dp[i][j][1] = max(dp[i][j][1], dp[i-1][j-k][0] + sum[i][k]);
38                     dp[i][j][1] = max(dp[i][j][1], dp[i-1][j-k][1] + sum[i][k]);
39                 } else {
40                     dp[i][j][0] = max(dp[i][j][0], dp[i-1][j-k][0] + sum[i][k]);
41                     dp[i][j][2] = max(dp[i][j][2], dp[i-1][j-k][1] + sum[i][k]);
42                     dp[i][j][2] = max(dp[i][j][2], dp[i-1][j-k][2] + sum[i][k]);
43                 }
44             }
45         }
46         ans = max(ans, max(dp[i][m][0], max(dp[i][m][1], dp[i][m][2])));
47     }
48     cout << ans << endl;
49 }
50
51 int main() {
52     int T, Case = 1;
53     cin >> T;
54     int a, b;
55     while(T--) {
56         cin >> n >> m;
57         for(int i = 1; i <= n; i++) {
58             cin >> a >> b;
59             for(int j = 1; j <= m; j++) {
60                 sum[i][j] = a * j - j * (j - 1) * b / 2;
61             }
62         }
63         printf("Case #%d: ", Case++);
64         solve();
65     }
66     return 0;
67 }
68

y @ The Angry Teletubbies 2012-05-09 10:15 发表评论

zoj 3502 Contest - 状态压缩dp + 期望 + 求最小字典序的方案

y @ The Angry Teletubbies — Sun, 06 May 2012 07:37:00 GMT

【题意】：略

【题解】：最多只有10道题目，很容易想到状态压缩，对于每种状态枚举当前在尝试哪道题目，然后期望的转移比较容易。
注意本题会卡精度，还要输出最小的字典序方案。
复杂度是O(2^n*n*n)，用string记录方案很方便。

【代码】：

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 #define eps 1e-10
26 int n;
27 double p[11][11];
28 double dp[1<<11];
29 string s[1<<11];
30
31 void solve() {
32     int nn = 1 << n;
33     dp[0] = 0.0;
34     s[0] = "";
35     for(int i = 1; i < nn; i++) {
36         dp[i] = -1.0;
37         for(int j = 0; j < n; j++) {
38             if(i & (1 << j)) {
39                 double pp = 0.0;
40                 for(int k = 0; k < n; k++) {
41                     if(i & (1 << k)) pp = max(pp, p[k][j]);
42                 }
43                 int m = i - (1 << j);
44                 double tmp = dp[m] + pp;
45                 if(dp[i] + eps < tmp || (dp[i] - eps < tmp && s[i] > s[m])) {//watashi判精度的方法，妙~
46                     dp[i] = tmp;
47                     char ch = j + 'A';
48                     s[i] = s[m] + ch;
49                 }
50             }
51         }
52     }
53     printf("%.2f\n", dp[nn-1]);
54     cout << s[nn-1] << endl;
55 }
56
57 int main() {
58     int T;
59     cin >> T;
60     while(T--) {
61         cin >> n;
62         for(int i = 0; i < n; i++) {
63             for(int j = 0; j < n; j++) {
64                 cin >> p[i][j];
65                 p[i][j] /= 100.0;
66             }
67         }
68         solve();
69     }
70     return 0;
71 }
72

y @ The Angry Teletubbies 2012-05-06 15:37 发表评论

zoj 3506 Cut the Tree - 树dp + 分组背包

y @ The Angry Teletubbies — Sat, 05 May 2012 06:18:00 GMT

【题意】：给出一棵树，每个节点有一个权值，要你对这棵树cut k次，每cut一次在两棵树中选择任意一棵继续操作，问cut完k次后，求最后得到的树的最小/最大权值和。

【题解】：很明显的树dp。刚开始状态没设好，把问题搞得好复杂。
设状态dp[i][j]表示以i为根的这棵子树cut j次的最小/最大权值和（包括i这个节点）。
那么对于i的每棵子树都有两种选择，就是保留这棵子树或者丢弃这棵子树。
这里的转移就是一个简单的背包。
关键是最后统计答案，如果答案包括根，那么就是dp[root][k]；否则，就需要枚举各个节点的情况，取最优值。

【代码】：

y @ The Angry Teletubbies 2012-05-05 14:18 发表评论

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

CF 161D - 树dp

y @ The Angry Teletubbies — Tue, 17 Apr 2012 03:04:00 GMT

【题意】：给出一棵树，每条边的长度为1，问树上有多少点对的距离恰好为k。

【题解】：用树的分治可解，但是写起来比较麻烦。
设状态dp[i][j]表示以i为根的子树的节点到i的距离恰为j的个数。
然后利用乘法原理求出答案，再把儿子的信息传给父亲。

【代码】：

y @ The Angry Teletubbies 2012-04-17 11:04 发表评论

CF 152E - 状态压缩dp + 斯坦纳树 + 记录方案

y @ The Angry Teletubbies — Tue, 17 Apr 2012 02:50:00 GMT

【题意】：最基础的斯坦纳树。

【题解】：只需要用spfa dp一次即可，要记录状态的前驱状态保存方案。

【代码】：

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 const int inf = 1 << 29;
22 int dp[210][1<<7], pre[210][1<<7];
23 int n, m, k, nn, mm;
24 int hash[210];
25 int maz[110][110];
26 char g[110][110];
27 bool visit[210][1<<7];
28 int dx[] = {0, 0, -1, 1};
29 int dy[] = {-1, 1, 0, 0};
30
31 struct Node {
32     int u, st;
33     Node(){}
34     Node(int _u, int _st) {
35         u = _u, st = _st;
36     }
37 };
38 queue que;
39
40 bool check(int x, int y) {
41     if(x >= 0 && x < n && y >= 0 && y < m) return true;
42     return false;
43 }
44
45 void update(int u, int st, int w, int fa) {
46     if(dp[u][st] > w) {
47         dp[u][st] = w;
48         pre[u][st] = fa;
49         if(!visit[u][st]) {
50             que.push(Node(u, st));
51             visit[u][st] = true;
52         }
53     }
54 }
55
56 void dfs(int u, int st) {
57     int x = u / m, y = u % m;
58     g[x][y] = 'X';
59     if(pre[u][st] == -1) return;
60     else {
61         int v = pre[u][st] / 1000, stt = pre[u][st] % 1000;
62         dfs(v, stt);
63         if(stt - st) dfs(v, st - stt);//牛叉的记录，拆分当前状态
64     }
65 }
66
67 void solve() {
68     while(!que.empty()) {
69         Node now = que.front();
70         que.pop();
71         int u = now.u, x = now.u / m, y = now.u % m, st = now.st;
72         visit[u][st] = false;
73         for(int i = 0; i < 4; i++) {
74             int xx = x + dx[i], yy = y + dy[i];
75             if(!check(xx, yy)) continue;
76             int v = xx * m + yy;
77             update(v, st, dp[u][st] + maz[xx][yy], u * 1000 + st);
78         }
79         int t = mm - 1 - st;
80         for(int i = t; i; i = (i-1) & t) {
81             update(u, i | st, dp[u][i] + dp[u][st] - maz[x][y], u * 1000 + st);
82         }
83     }
84     int ans = inf, u;
85     for(int i = 0; i < nn; i++) {
86         if(ans > dp[i][mm-1]) {
87             ans = dp[i][mm-1];
88             u = i;
89         }
90     }
91     dfs(u, mm - 1);
92     cout << ans << endl;
93     for(int i = 0; i < n; i++) {
94         for(int j = 0; j < m; j++)
95             cout << g[i][j];
96         cout << endl;
97     }
98 }
99
100 int main() {
101     while(cin >> n >> m >> k) {
102         while(!que.empty()) que.pop();
103         for(int i = 0; i < n; i++) {
104             for(int j = 0; j < m; j++) {
105                 cin >> maz[i][j];
106                 g[i][j] = '.';
107             }
108         }
109         nn = n * m, mm = 1 << k;
110         memset(hash, 0, sizeof(hash));
111         memset(visit, false, sizeof(visit));
112         for(int i = 0; i < nn; i++)
113             for(int j = 0; j < mm; j++)
114                 dp[i][j] = inf;
115         for(int i = 0, a, b; i < k; i++) {
116             cin >> a >> b;
117             a--, b--;
118             int u = a * m + b;
119             hash[u] = 1 << i;
120             update(u, hash[u], maz[a][b], -1);
121         }
122         solve();
123     }
124     return 0;
125 }
126

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

hdoj 4085 Peach Blossom Spring - 状态压缩dp + 斯坦纳树

y @ The Angry Teletubbies — Sun, 15 Apr 2012 11:40:00 GMT

【题意】：n(n<=50)个点，m(m<=1000)条无向边，求前k个点(house)和末k个点(broken house)互相“连通”的最小代价。这里的连通是指，对于任意一个house必须和一个broken house 连通，且任意一个house只能对应一个broken house 作为连通的对象。（抄3X的题意）

【题解】：斯坦纳树。
要做两次dp，第一次求出所有状态的最小费用，第二次合并状态求出最优值即为答案。
合并状态时必须是合法状态才能够转移，既居民点个数 == 避难所个数。

【代码】：

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 55
22 #define maxm 2500
23 const int inf = 1 << 20;
24 int eh[maxn], tot;
25 int n, m, k;
26 struct Edge {
27     int u, v, w, next;
28 }et[maxm];
29 int dp[maxn][1<<10];
30 bool visit[maxn][1<<10];
31 int hash[maxn];
32 int minn[1<<10];
33 void init() {
34     tot = 0;
35     memset(eh, -1, sizeof(eh));
36 }
37
38 void addedge(int u, int v, int w) {
39     Edge e = {u, v, w, eh[u]};
40     et[tot] = e;
41     eh[u] = tot++;
42 }
43
44 bool check(int mask) {//判断合法状态
45     int a = 0, b = 0;
46     for(int i = 0; i < k; i++)
47         if(mask & (1< 48     for(int i = k; i < 2 * k; i++)
49         if(mask & (1< 50     return a == b;
51 }
52
53 void solve() {
54
55     memset(visit, false, sizeof(visit));
56     int base = 10000, nn = 1<<(2*k);
57     queue<int> que;
58
59     for(int i = 0; i <= n; i++) {
60         hash[i] = 0;
61         for(int j = 0; j < nn; j++)
62             dp[i][j] = inf;
63     }
64
65     for(int i = 1; i <= k; i++) {
66         hash[i] = 1<<(i-1);
67         dp[i][hash[i]] = 0;
68         que.push(i * base + hash[i]);
69         visit[i][hash[i]] = true;
70     }
71
72     for(int i = 0; i < k; i++) {
73         hash[n-i] = 1<<(k+i);
74         dp[n-i][hash[n-i]] = 0;
75         que.push((n-i) * base + hash[n-i]);
76         visit[n-i][hash[n-i]] = true;
77     }
78
79     while(!que.empty()) {
80         int u = que.front();
81         que.pop();
82         int mask = u % base;
83         u /= base;
84         visit[u][mask] = false;
85         for(int now = eh[u]; now != -1; now = et[now].next) {
86             int v = et[now].v, w = et[now].w;
87             int nmask = mask | hash[v];
88             if(dp[v][nmask] > dp[u][mask] + w) {
89                 dp[v][nmask] = dp[u][mask] + w;
90                 if(!visit[v][nmask]) {
91                     que.push(v * base + nmask);
92                     visit[v][nmask] = true;
93                 }
94             }
95         }
96         int t = nn - 1 - mask;
97         for(int i = t; i; i = (i-1) & t) {
98             int nmask = mask | i;
99             if(dp[u][nmask] > dp[u][mask] + dp[u][i|hash[u]]) {
100                 dp[u][nmask] = dp[u][mask] + dp[u][i|hash[u]];
101                 if(!visit[u][nmask]) {
102                     que.push(u * base + nmask);
103                     visit[u][nmask] = true;
104                 }
105             }
106         }
107     }
108
109     for(int i = 0; i < nn; i++)
110         minn[i] = inf;
111
112     for(int i = 1; i <= n; i++)
113         for(int j = 0; j < nn; j++)
114             minn[j] = min(minn[j], dp[i][j]);
115
116     for(int i = 1; i < nn; i++)
117         if(check(i))
118             for(int j = i; j; j = (j-1) & i)
119                 if(check(j)) minn[i] = min(minn[i], minn[j] + minn[i-j]);
120
121     int ans = minn[nn-1];
122     if(ans == inf) cout << "No solution" << endl;
123     else cout << ans << endl;
124 }
125
126 int main() {
127     int T;
128     scanf("%d", &T);
129     while(T--) {
130         scanf("%d%d%d", &n, &m, &k);
131         init();
132         for(int i = 0; i < m; i++) {
133             int u, v, w;
134             scanf("%d%d%d", &u, &v, &w);
135             addedge(u, v, w);
136             addedge(v, u, w);
137         }
138         solve();
139     }
140     return 0;
141 }
142

y @ The Angry Teletubbies 2012-04-15 19:40 发表评论

FZU 月赛 E题 - 树dp + 树最小支配集变形

y @ The Angry Teletubbies — Sun, 15 Apr 2012 08:06:00 GMT

【题意】：shadow酷爱探险，这次shadow来到了一个洞穴中，他发现这个幽深的洞穴由一些房间（相对较为宽敞的区域）和连接这些房间的通道构成，它们形成了一个树形结构。当shadow探索完整个洞穴出来后，他觉得这里可以作为一个旅游景点来开发，但首先他必须解决这个洞穴中的照明问题。由于这个洞穴中的通道都较为笔直，因而在洞穴中的任意房间建立照明设施都可以照亮与其直接相连的所有房间，但在每个房间建立照明设施所需的费用又因地形不同而不同，所以shadow想知道要照亮整个洞穴所需的最少费用是多少。

【题解】：与poj 3659类似，只是每个点有一个权值而已。

【代码】：

y @ The Angry Teletubbies 2012-04-15 16:06 发表评论

poj 3659 Cell Phone Network - 树dp + 树最小支配集

y @ The Angry Teletubbies — Sun, 15 Apr 2012 07:55:00 GMT

【题意】：求树的最小支配集

【题解】：经典树dp题目，求树最小支配集。
设dp[u][0]表示选择u这个点，且以u为根的子树完全被覆盖的最小个数。
设dp[u][1]表示u这个点被其儿子覆盖，且以u为根的子树完全被覆盖的最小个数。
设dp[u][2]表示u这个点被其父亲覆盖，且以u为根的子树完全被覆盖的最小个数。

然后转移就好明显了。

【代码】：

y @ The Angry Teletubbies 2012-04-15 15:55 发表评论

hdoj 3001 Travelling - 状态压缩dp + 三进制

y @ The Angry Teletubbies — Tue, 10 Apr 2012 15:53:00 GMT

【题意】：每个节点可以最多访问两次，求访问完所有点的最小费用。

【题解】：求哈密顿路，只是多了点条件，果断状态压缩dp+三进制。
通过这题瞬间领会了k进制的操作，好！

【代码】：

y @ The Angry Teletubbies 2012-04-10 23:53 发表评论

hdoj 3586 Information Disturbing - 二分 + 树dp

y @ The Angry Teletubbies — Thu, 05 Apr 2012 06:10:00 GMT

【题意】：给出一棵树，根节点为1，每条边有一个代价。要求切去其所有的叶子节点，且总代价不能超过m，问切去的边中的最大的边最小是多少。

【题解】：最大值最小问题，基本上就是二分答案+判定。
这题的判定需要用到树dp。
设状态dp[u]为以u为根的子树切去其下方叶子节点的最少代价。
非叶子节点：
dp[u] += min(dp[v], w(u, v)), v 为 u 儿子。
叶子节点：
dp[u] = inf;
最后判断dp[1]与m的关系就可以了。

【代码】：

y @ The Angry Teletubbies 2012-04-05 14:10 发表评论

poj 3398 Perfect Service - 树dp

y @ The Angry Teletubbies — Mon, 26 Mar 2012 10:32:00 GMT

【题意】：给出一棵树，每个节点代表一台电脑，现在需要选择一些电脑作为服务器。如果一台电脑被选作服务器，那么它和和它相邻的电脑都会被激活，非服务器的电脑不能同时被多台服务器激活。问最少要选多少台电脑作为服务器使得所有电脑被激活。

【题解】：树dp，树的最小支配集变形。
设状态
dp[u][0] 以u为根且u为服务器且整棵子树都被激活的最小代价。
dp[u][1] 以u为根且u被某个儿子结点激活且整棵子树都被激活的最小代价。
dp[u][2] 以u为根且u被父亲结点激活且整棵子树都被激活的最小代价。

转移 (v 为 u 的儿子)
dp[u][0] = ∑min(dp[v][0], dp[v][2]) + 1;
dp[u][1] = min(sum - dp[v][1] + dp[v][0]), sum = ∑dp[v][1];
dp[u][2] = ∑dp[v][1];

任取一个结点为root进行树dp, ans = min(dp[root][0], dp[root][1]).

【代码】：

y @ The Angry Teletubbies 2012-03-26 18:32 发表评论

hdoj 3660 Alice and Bob's Trip - 树dp

y @ The Angry Teletubbies — Sat, 24 Mar 2012 18:26:00 GMT

【题意】：给出一棵n个结点的有向树，两个人一起走，轮流决策，Alice的目的是使最后的距离最小，Bob的目的是使最后的距离最大。问最后的距离能否满足在区间[L,R]。需要走到不能走的地方才能停。

【题解】：这题要注意的是，可能还没有走到叶子结点就停止了。
然后就是一个树形dp。
对于一棵给定的树，每个结点轮到谁决策是确定的。
根据当前不同的人，选择满足当前区间[L',R']最大值或者最小值。

【代码】：

y @ The Angry Teletubbies 2012-03-25 02:26 发表评论

hdoj 3538 A sample Hamilton path - 状态压缩dp + 哈密顿路

y @ The Angry Teletubbies — Sat, 24 Mar 2012 18:11:00 GMT

【题意】：给出一个有向图，n个城市(n<=21)，还有m个限制a b，表示要访问城市b要先访问城市a。求从0号城市出发的最短哈密顿路。

【题解】：经典的状态压缩dp。

【代码】：

y @ The Angry Teletubbies 2012-03-25 02:11 发表评论

poj 1797 Heavy Transportation - 最短路 + dp

y @ The Angry Teletubbies — Thu, 08 Mar 2012 08:46:00 GMT

【题意】：求城市1到城市n可行路径上最小值的最大值。

【题解】：最短路变形，加上一点dp思想。
把dist[]数组存储的东西改一下即可。

【代码】：

y @ The Angry Teletubbies 2012-03-08 16:46 发表评论

poj 1947 Rebuilding Roads - 树dp + 01背包 + 分组背包

y @ The Angry Teletubbies — Sun, 26 Feb 2012 08:36:00 GMT

【题意】：给出一颗有n个节点的树，问你最少切割多少条边可以得出一棵子树刚好包含p个节点。

【题解】：明显的树dp。
做完这题突然发现我对树dp+背包的理解又加深了。
设dp[u][i]表示以u为根的子树，得到包含i个节点的树的最少代价。
dp[u][i] = min(dp[u][i] + 1, dp[u][i-j] + dp[v][j]),其中 1 <= j <= i，v 为 u 的儿子。
枚举的时候注意要逆序，要不就开三维数组。

【代码】：

y @ The Angry Teletubbies 2012-02-26 16:36 发表评论

CF 150A - 博弈 + 记忆化搜索

y @ The Angry Teletubbies — Sat, 18 Feb 2012 16:32:00 GMT

【题意】：给出一个当前值q(q <= 10^13)，两个人轮流写出一个当前值的非平凡因子来取代当前值，谁不能写谁胜出。一个数的非平凡因子是指除1和本身之外的因子。两个人都采取最优决策，问最后谁胜出。

【题解】：博弈，直接记忆化搜索即可，只要搜到第一个必败态就可以跳出。
利用map来处理可以把代码写得很短。

【代码】：

y @ The Angry Teletubbies 2012-02-19 00:32 发表评论

hdoj 4159 Indomie - 概率dp

y @ The Angry Teletubbies — Sat, 18 Feb 2012 12:45:00 GMT

【题意】：有a,b,c三种物品，a和b有无限多件，c只有s件，现在Amjad想拿c这个物品，但是他前面有n个人。现在每人轮流拿一个物品，前n个人是随机拿，而Amjad是有目的性去拿，问Amjad取得c的概率是多少。

【题解】：概率dp。
设dp[i][j]表示前 i 个人取完还有 j 个 C的概率。
转移：dp[i][j] = dp[i-1][j] * 2 / 3 + dp[i-1][j+1] / 3;
最后ans = ( ∑dp[n][i], 1 <= i <= s ) / ( ∑dp[n][i], 0 <= i <= s)。
实现时使用了滚动数组。

【代码】：

y @ The Angry Teletubbies 2012-02-18 20:45 发表评论

hdoj 4003 Find Metal Mineral - 树dp + 分组背包

y @ The Angry Teletubbies — Mon, 13 Feb 2012 07:42:00 GMT

【题意】：给出一棵树，每条边上有一个权值，表示通过这条边的代价。现在有k个机器人在节点s，问用k个机器人访问完整棵树的节点的最少代价是多少。

【题解】：又是树dp+背包的题目。
设状态dp[u][k]表示以u为根节点的子树排了k个机器人下去访问完该子树的节点的最小代价。
如果k == 0，表示排了一个机器人下去访问完之后机器人又返回到节点u。
注意k == 0的时候必定是只有一个机器人下去然后返回，不会有多于一个机器人下去，因为这样肯定不是最优。
然后就是一个01背包 +分组背包，枚举容量时要逆序，因为用了滚动数组。

【代码】：

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

CF 149D - 区间dp

y @ The Angry Teletubbies — Mon, 13 Feb 2012 06:55:00 GMT

【题意】：给出一个长度为n的括号序列，括号满足两两匹配。
给出三个条件：
1.每个括号可以不染色，染蓝色或者染红色；
2.匹配的括号对有且仅有一个染色；
3.相邻的括号不能染相同的颜色。
问，满足以上三个条件的染色方案有多少种。

【题解】：好明显的dp题，因为一般这种求方案数的题目如果用纯数学知识来解是解不出的，而且限制条件一大堆。
设状态dp[l][r][c1][c2]表示[l,r]之间且l染成c1,r染成c2的合法方案数。
然后转移要分两种情况讨论：1.l与r匹配；2.l与r不匹配
转移就是运用乘法原理，要先预处理括号的匹配情况。

【代码】：

y @ The Angry Teletubbies 2012-02-13 14:55 发表评论

zoj 1039 Number Game - 博弈 + 状态压缩 + 记忆化搜索

y @ The Angry Teletubbies — Sat, 11 Feb 2012 06:21:00 GMT

【题意】：两个人在玩数字游戏，规则如下：有2~20这19个数，每个回合每个人轮流取走一个数k，k取走后k的所有倍数都不可以再取，并且任意两个不可取的数的和也不可以取。给出当前的合法局面，问先手是否必胜，若必胜输出最优操作。

【题解】：考虑到一共只有19个数字，可以用状态压缩。然后在博弈树上记忆化搜索即可，找到第一个必胜局面就可以跳出了。

【代码】：

y @ The Angry Teletubbies 2012-02-11 14:21 发表评论

hdoj 3507 Print Article - dp + 单调队列优化

y @ The Angry Teletubbies — Tue, 07 Feb 2012 16:16:00 GMT

【题意】：要打印一篇文章包含n个单词，每个单词打印需要一定的代价Ci。把连续k个单词打印在同一行需要花费(∑Ci)^2 + M，问打印完整篇文章最少代价是多少。

【题解】：一个分组问题，dp解决。
设dp[i]表示把前i个单词打印完的最少代价。
dp[i] = min(dp[j] + (sum[i] - sum[j]) ^ 2 + M),1 <= j <= i - 1.
朴素dp是O(n*n)，而n<=500000，显然需要优化。
这题满足决策的单调性，所以只需要用一个单调队列维护一个下凸线，这样可以把转移降为O(1)。

【代码】：

y @ The Angry Teletubbies 2012-02-08 00:16 发表评论

poj 2094 The Mailboxes Manufacturers Problem - dp + 枚举最优测试点

y @ The Angry Teletubbies — Mon, 06 Feb 2012 18:08:00 GMT

【题意】：给出k个邮筒，邮筒理论承受爆炸能力为m，实际上是[1,m]的某一个值。问，最坏情况下，至少要用多少炸药才能测试出邮筒的承受爆炸能力。
有几点要注意：
1.如果邮筒可以承受x单位炸药，必定可以承受1到x-1单位的炸药。
2.除非邮筒某次测试中被炸毁，否则仍然当它是完好无缺的，可以继续用于下一次测试。

【题解】：dp。
对于只有一个邮筒，我们只能由1,2,3,……,m-1,m测试，所以最坏情况就是(1+m) * m / 2。
设状态dp[i][l][r] 表示当前还有 i 个邮筒，且承受能力在[l,r]内测试出承受爆炸能力所用的最少炸药。

显然：
i == 1时，dp[1][l][r] = (l + r) * (r - l + 1) / 2.
i >= 2时，我们就不需要从头开始枚举了，我们应该选择一个最优的分界点去测试。
所以有 dp[i][l][r] = min(dp[i][l][r], s + max(dp[i][s+1][r], dp[i-1][l][s-1])), l <= s <= r;
这里说明一下，因为测试完点s之后，题目要求是最坏情况，所以只能选较大那个。
而外层的min是指，在这么多分界点之中，我们选取最优的分界点，这样才能保证用最少炸药。

【代码】：

y @ The Angry Teletubbies 2012-02-07 02:08 发表评论