[kuangbin带你飞]之'基础DP1'

带飞网址 🚀

 

专题十二 基础DP1
√ HDU 1024 Max Sum Plus Plus
√ HDU 1029 Ignatius and the Princess IV
√ HDU 1069 Monkey and Banana
√ HDU 1074 Doing Homework
√ HDU 1087 Super Jumping! Jumping! Jumping!
√ HDU 1114 Piggy-Bank
√ HDU 1176 免费馅饼
√ HDU 1260 Tickets
√ HDU 1257 最少拦截系统
√ HDU 1160 FatMouse's Speed
POJ 1015 Jury Compromise
√ POJ 1458 Common Subsequence
√ POJ 1661 Help Jimmy
√ POJ 2533 Longest Ordered Subsequence
POJ 3186 Treats for the Cows
√ HDU 1078 FatMouse and Cheese
HDU 2859 Phalanx
POJ 3616 Milking Time
POJ 3666 Making the Grade

// hdu 1024 滚动数组(最大M字串和)

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-17 15:56:01
 7  * @LastEditTime: 2019-11-17 16:55:30
 8  */
 9 #include<cstdio>
10 #include<algorithm>
11 #define INF 0x3f3f3f3f
12 using namespace std;
13 const int MAXN = 1000002;
14 
15 int main() {
16     int n, m;
17     int maxn;
18     int a[MAXN], dp[MAXN];
19     int preMAX[MAXN];
20     while(scanf("%d%d", &m, &n) == 2) {
21         for(int i = 1; i <= n; ++i) {
22             scanf("%d", &a[i]);
23             dp[i] = preMAX[i] = 0;
24         }
25         dp[0] = preMAX[0] = 0;
26         for(int i = 1; i <= m; ++i) {
27             maxn = -INF;
28             for(int j = i; j <= n; ++j) {
29                 dp[j] = max(dp[j-1] + a[j], preMAX[j-1] + a[j]);
30                 preMAX[j-1] = maxn;
31                 maxn = max(maxn, dp[j]);
32             }
33         }
34         printf("%d\n", maxn);
35     }
36     return 0;
37 }
View Code

// hdu 1029

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<algorithm>
 4 using namespace std;
 5 
 6 int arr[1000000];
 7 
 8 int main()
 9 {
10     int n;
11     while(cin >> n){
12         for(int i = 0; i != n; ++i){
13             scanf("%d", &arr[i]);
14         }
15         sort(arr, arr+n);
16         cout << arr[(n+1)/2] << endl;
17     }
18     return 0;
19 }
View Code

// hdu 1069

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-21 17:35:43
 7  * @LastEditTime: 2019-11-21 18:39:37
 8  */
 9 #include<cstdio>
10 #include<algorithm>
11 using namespace std;
12 const int INF = 0x3f3f3f3f;
13 const int MAXN = 105;
14 
15 int num;
16 struct node {
17     int x, y, z;
18 } a[MAXN];
19 
20 int n, ans;
21 int dp[MAXN];
22 
23 void SWAP(int &a, int &b, int &c) {
24     if(a > b) swap(a, b);
25     if(b > c) swap(b, c);
26     if(a > b) swap(a, b);
27 }
28 
29 bool cmp(const node a, const node b) {
30     return a.x < b.x;
31 }
32 
33 int main() {
34     int qaq = 0;
35     while(scanf("%d", &n) == 1 && n) {
36         num = 0;
37         ans = -INF;
38         int x, y, z;
39         for(int i = 0; i != n; ++i) {
40             scanf("%d%d%d", &x, &y, &z);
41             SWAP(x, y, z);
42             ++num; a[num].x = x; a[num].y = y; a[num].z = z;
43             ++num; a[num].x = x; a[num].y = z; a[num].z = y;
44             ++num; a[num].x = y; a[num].y = z; a[num].z = x;
45         }
46         sort(a+1, a+1+num, cmp);
47         for(int i = 1; i <= num; ++i) dp[i] = a[i].z;
48         for(int i = 1; i <= num; ++i) {
49             for(int j = 1; j < i; ++j) {
50                 if(a[i].x > a[j].x && a[i].y > a[j].y && dp[i] < dp[j] + a[i].z) {
51                     dp[i] = dp[j] + a[i].z;
52                 }
53             }
54             ans = max(ans, dp[i]);
55         }
56         printf("Case %d: maximum height = %d\n", ++qaq, ans);
57     }
58     return 0;
59 }
View Code

// hdu 1074 状压DP

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<algorithm>
 4 #define INF 0x3f3f3f3f
 5 using namespace std;
 6 const int MAXN = (1<<15)+5;
 7 
 8 struct node {
 9     char name[105];
10     int limit, actual;
11 } a[20];
12 
13 int n;
14 int dp[MAXN], time[MAXN], cur[MAXN];
15 
16 void Output(int x) {
17     if(!x) return ;
18     Output(x - (1<<cur[x]));
19     printf("%s\n", a[cur[x]].name);
20 }
21 
22 int main() {
23     int QAQ;
24     scanf("%d", &QAQ);
25     while(QAQ--) {
26         memset(time, 0, sizeof(time));
27         scanf("%d", &n);
28         for(int i = 0; i != n; ++i) scanf("%s%d%d", &a[i].name, &a[i].limit, &a[i].actual);
29         int tot = 1<<n;
30         for(int i = 1; i != tot; ++i) {
31             dp[i] = INF;
32             for(int j = n-1; j >= 0; --j) {
33                 int t = 1 << j;
34                 if(!(t&i)) continue;
35                 int score = time[i-t] + a[j].actual - a[j].limit;
36                 if(score < 0) score = 0;
37                 if(dp[i] > dp[i-t] + score) {
38                     dp[i] = dp[i-t] + score;
39                     time[i] = time[i-t] + a[j].actual;
40                     cur[i] = j;
41                 }
42             }
43         }
44         printf("%d\n", dp[tot-1]);
45         Output(tot-1);
46     }
47     return 0;
48 }
View Code

// hdu 1087

 1 #include<cstdio>
 2 #include<algorithm>
 3 using namespace std;
 4 
 5 int n;
 6 int arr[1005], dp[1005];
 7 int p;
 8 
 9 bool read_input() {
10     if(scanf("%d", &n) == 1 && !n) return false;
11     for(int i = 0; i != n; ++i) {
12         scanf("%d", &arr[i]);
13         dp[i] = arr[i];
14     }
15     return true;
16 }
17 
18 int main() {
19     while(read_input()) {
20         for(int i = 0; i != n; ++i) {
21             for(int j = 0; j != i; ++j) {
22                 if(arr[j] < arr[i]) dp[i] = max(dp[i], dp[j]+arr[i]);
23             }
24         }
25         int ans = 0;
26         for(int i = 0; i != n; ++i) {
27             ans = max(dp[i], ans);
28         }
29         printf("%d\n", ans);
30     }
31     return 0;
32 }
View Code

// hdu 1114

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-22 21:09:55
 7  * @LastEditTime: 2019-11-23 12:51:25
 8  */
 9 #include<cstdio>
10 #include<algorithm>
11 #define INF 0x3f3f3f3f
12 using namespace std;
13 const int MAXN = 500+5;
14 
15 int E, F, t;
16 int n;
17 int w[MAXN], v[MAXN];
18 int dp[10005];
19 
20 int main() {
21     int QAQ;
22     scanf("%d", &QAQ);
23     while(QAQ--) {
24         scanf("%d%d", &E, &F);
25         t = F - E;
26         for(int i = 0; i <= t; ++i) dp[i] = INF;
27         dp[0] = 0;
28         scanf("%d", &n);
29         for(int i = 1; i <= n; ++i) scanf("%d%d", &v[i], &w[i]);
30         for(int i = 1; i <= n; ++i) {
31             for(int j = w[i]; j <= t; ++j) {
32                 dp[j] = min(dp[j], dp[j-w[i]] + v[i]);
33             }
34         }
35         if(dp[t] == INF) printf("This is impossible.\n");
36         else printf("The minimum amount of money in the piggy-bank is %d.\n", dp[t]);
37     }
38     return 0;
39 }
View Code

// hdu 1176 数塔

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-16 20:48:34
 7  * @LastEditTime: 2019-11-17 11:18:50
 8  */
 9 #include<cstdio>
10 #include<cstring>
11 #include<algorithm>
12 using namespace std;
13 const int MAXN = 100005;
14 
15 int n;
16 int dp[MAXN][15];
17 
18 int main() {
19     while(scanf("%d", &n) == 1 && n) {
20         int x, t, T = 0;
21         memset(dp, 0, sizeof(dp));
22         while(n--) {
23             scanf("%d%d", &x, &t);
24             T = max(T, t);
25             ++dp[t][++x];
26         }
27         for(int i = T-1; i >= 0; --i) {
28             for(int j = 1; j <= 11; ++j) {
29                 dp[i][j] += max(dp[i+1][j-1], max(dp[i+1][j], dp[i+1][j+1]));
30             }
31         }
32         printf("%d\n", dp[0][6]);
33     }
34     return 0;
35 }
View Code

// hdu 1260

 1 #include<cstdio>
 2 #include<algorithm>
 3 using namespace std;
 4 const int MAXN = 2000+5;
 5 
 6 int n;
 7 int a[MAXN], b[MAXN];
 8 int dp[MAXN];
 9 
10 int main() {
11     int QAQ;
12     scanf("%d", &QAQ);
13     while(QAQ--) {
14         scanf("%d", &n);
15         for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
16         for(int i = 1; i <= n-1; ++i) scanf("%d", &b[i]);
17         dp[1] = a[1];
18         for(int i = 2; i <= n; ++i) dp[i] = min(dp[i-1]+a[i], dp[i-2]+b[i-1]);
19         int sum = dp[n];
20         int h = sum/3600;
21         sum -= h*3600;
22         h += 8;
23         int m = sum/60;
24         sum -= m*60;
25         int s = sum;
26         if(h <= 12) printf("%02d:%02d:%02d am\n", h, m, s);
27         else printf("%02d:%02d:%02d pm\n", h-12, m, s);
28     }
29     return 0;
30 }
View Code

// hdu 1257 最长上升子序列

 1 #include<cstdio>
 2 #include<algorithm>
 3 using namespace std;
 4 const int MAXN = 1000000;
 5 
 6 int n;
 7 int a[MAXN];
 8 int dp[MAXN];
 9 
10 int solve() {
11     int ans = 1;
12     for(int i = 1; i <= n; ++i) {
13         dp[i] = 1;
14         for(int j = 1; j < i; ++j) {
15             if(a[j] < a[i] && dp[j] + 1 > dp[i]) {
16                 dp[i] = dp[j] + 1;
17             }
18         }
19         ans = max(ans, dp[i]);
20     }
21     return ans;
22 }
23 
24 int main() {
25     while(scanf("%d", &n) == 1) {
26         for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
27         printf("%d\n", solve());
28     }
29     return 0;
30 }
View Code

// hdu 1160

 1 #include<cstdio>
 2 #include<algorithm>
 3 #include<map>
 4 using namespace std;
 5 typedef pair<int,int> Pair;
 6 const int MAXN = 10002+5;
 7 
 8 int n;
 9 struct node {
10     int w, s;
11 } a[MAXN];
12 int cnt;
13 map<Pair, int> id;
14 
15 int ans, t;
16 int dp[MAXN];
17 int pre[MAXN];
18 
19 bool cmp(const node a, const node b) {
20     return a.w > b.w;
21 }
22 
23 int main() {
24     int w, s;
25     while(scanf("%d%d", &w, &s) == 2) {
26         ++n;
27         a[n].w = w; a[n].s = s;
28         id[make_pair(w, s)] = ++cnt;
29         dp[n] = 1; pre[n] = 0;
30     }
31     sort(a+1, a+1+n, cmp);
32     ans = 0; t = 1;
33     for(int i = 1; i <= n; ++i) {
34         for(int j = 1; j < i; ++j) {
35             if(a[i].w < a[j].w && a[i].s > a[j].s && dp[j] + 1 > dp[i]) {
36                 dp[i] = dp[j] + 1;
37                 pre[i] = j;
38             }
39         }
40         if(dp[i] > ans) {
41             ans = dp[i];
42             t = i;
43         }
44     }
45     printf("%d\n", ans);
46     for(int i = t; i != 0; i = pre[i]) printf("%d\n", id[make_pair(a[i].w, a[i].s)]);
47     return 0;
48 }
View Code

// hdu 1015
// hdu 1458 最大公共子序列

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-23 17:58:42
 7  * @LastEditTime: 2019-11-23 18:12:52
 8  */
 9 #include<cstdio>
10 #include<cstring>
11 #include<algorithm>
12 using namespace std;
13 
14 int len1, len2;
15 char a[1002], b[1002];
16 int dp[1002][1002];
17 
18 int main() {
19     while(scanf("%s", a) == 1) {
20         scanf("%s", b);
21         len1 = strlen(a);
22         len2 = strlen(b);
23         memset(dp, 0, sizeof(dp));
24 
25         for(int i = 1; i <= len1; ++i) {
26             for(int j = 1; j <= len2; ++j) {
27                 if(a[i-1] == b[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
28                 else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
29             }
30         }
31         printf("%d\n", dp[len1][len2]);
32     }
33     return 0;
34 }
View Code

// poj 1661

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-23 18:23:35
 7  * @LastEditTime: 2019-11-24 00:16:57
 8  */
 9 #include<cstdio>
10 #include<cstring>
11 #include<algorithm>
12 #define INF 0x3f3f3f3f
13 using namespace std;
14 const int MAXN = 1002+5;
15 
16 struct node {
17     int l, r, h;
18 } edge[MAXN];
19 
20 bool cmp(const node a, const node b) {
21     return a.h > b.h;
22 }
23 
24 int n, X, Y, MAX;
25 bool go[MAXN][MAXN][3];
26 int dp[MAXN][3];
27 
28 void input() {
29     scanf("%d%d%d%d", &n, &X, &Y, &MAX);
30     for(int i = 1; i <= n; ++i) {
31         scanf("%d%d%d", &edge[i].l, &edge[i].r, &edge[i].h);
32     }
33     edge[0].l = edge[0].r = X;
34     edge[0].h = Y;
35     ++n;
36     edge[n].l = -INF; edge[n].r = INF;
37     edge[n].h = 0;
38 }
39 
40 void init() {
41     memset(go, false, sizeof(go));
42     sort(edge, edge+n, cmp);
43     for(int i = 0; i <= n; ++i) {
44         for(int j = i+1; j <= n; ++j) {
45             if(edge[i].h - edge[j].h > MAX) break;
46             bool flag1 = true, flag2 = true;
47             for(int k = i+1; k < j; ++k) {
48                 if(go[i][k][1]) {
49                     flag1 = false;
50                     break;
51                 }
52             }
53             for(int k = i+1; k < j; ++k) {
54                 if(go[i][k][2]) {
55                     flag2 = false;
56                     break;
57                 }
58             }
59             if(flag1 && edge[i].l >= edge[j].l && edge[i].l <= edge[j].r) go[i][j][1] = true;
60             if(flag2 && edge[i].r >= edge[j].l && edge[i].r <= edge[j].r) go[i][j][2] = true;
61         }
62     }
63 }
64 
65 int main() {
66     int QAQ;
67     scanf("%d", &QAQ);
68     while(QAQ--) {
69         input();
70         init();
71         memset(dp, INF, sizeof(dp));
72         dp[0][1] = dp[0][2] = 0;
73         for(int i = 1; i < n; ++i) {
74             for(int j = 0; j < i; ++j) {
75                 int h = edge[j].h-edge[i].h;
76                 if(go[j][i][1]) {
77                     dp[i][1] = min(dp[i][1], dp[j][1]+h+edge[j].l-edge[i].l);
78                     dp[i][2] = min(dp[i][2], dp[j][1]+h+edge[i].r-edge[j].l);
79                 }
80                 if(go[j][i][2]) {
81                     dp[i][1] = min(dp[i][1], dp[j][2]+h+edge[j].r-edge[i].l);
82                     dp[i][2] = min(dp[i][2], dp[j][2]+h+edge[i].r-edge[j].r);
83                 }
84             }
85         }
86         int ans = INF;
87         for(int i = 0; i < n; ++i) {
88             if(go[i][n][1]) ans = min(ans, dp[i][1]+edge[i].h);
89             if(go[i][n][2]) ans = min(ans, dp[i][2]+edge[i].h);
90         }
91         printf("%d\n", ans);
92     }
93     return 0;
94 }
View Code

// poj 2533

 1 /*
 2  * @Promlem: 
 3  * @Time Limit: ms
 4  * @Memory Limit: k
 5  * @Author: pupil-XJ
 6  * @Date: 2019-11-24 00:22:24
 7  * @LastEditTime: 2019-11-24 00:30:11
 8  */
 9 #include<cstdio>
10 #include<cstring>
11 #include<algorithm>
12 using namespace std;
13 const int INF = 0x3f3f3f3f;
14 const int MAXN = 1002+5;
15 
16 int n, ans;
17 int a[MAXN];
18 int dp[MAXN];
19 
20 int main() {
21     while(scanf("%d", &n) == 1) {
22         for(int i = 1; i <= n; ++i) scanf("%d", &a[i]), dp[i] = 1;
23         ans = 1;
24         for(int i = 1; i <= n; ++i) {
25             for(int j = 1; j < i; ++j) {
26                 if(a[i] > a[j] && dp[j] + 1 > dp[i]) {
27                     dp[i] = dp[j] + 1;        
28                 }
29             }
30             ans = max(ans, dp[i]);
31         }
32         printf("%d\n", ans);
33     }
34     return 0;
35 }
View Code

// poj 3186
// hdu 1078

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<cmath>
 4 #include<algorithm>
 5 using namespace std;
 6 
 7 const int dx[] = {-1, 1, 0, 0};
 8 const int dy[] = { 0, 0,-1, 1};
 9 
10 int n, k;
11 int G[1005][1005];
12 int dp[1005][1005];
13 
14 int dfs(int x, int y) {
15     if(dp[x][y]) return dp[x][y];
16     int ans = 0;
17     for(int i = 0; i != 4; ++i) {
18         for(int j = 1; j <= k; ++j) {
19             int nx = x+dx[i]*j;
20             int ny = y+dy[i]*j;
21             if(nx >= 0 && nx < n && ny >= 0 && ny < n && G[x][y] < G[nx][ny]) {
22                 ans = max(ans, dfs(nx, ny));
23             }
24         }
25     }
26     return dp[x][y] = ans + G[x][y];
27 }
28 
29 int main() {
30     while(scanf("%d%d", &n, &k) == 2 && n > 0) {
31         for(int i = 0; i != n; ++i) {
32             for(int j = 0; j != n; ++j) {
33                 scanf("%d", &G[i][j]);
34             }
35         }
36         memset(dp, 0, sizeof(dp));
37         printf("%d\n", dfs(0, 0));
38     }
39     return 0;
40 }
View Code

// hdu 2859
// poj 3616
// poj 3666

posted @ 2019-11-16 13:45  pupil337  阅读(173)  评论(0)  编辑  收藏  举报