《挑战程序设计竞赛》2.3.3 动态规划-进阶 POJ1065 1631 3666 2392 2184

最新推荐文章于 2022-09-08 11:06:57 发布

梁山伯liangrx06

最新推荐文章于 2022-09-08 11:06:57 发布

阅读量886

点赞数

分类专栏：挑战程序设计竞赛文章标签： poj 动态规划挑战程序设计竞赛

本文链接：https://blog.csdn.net/thudaliangrx/article/details/50363722

版权

挑战程序设计竞赛专栏收录该内容

33 篇文章 0 订阅

订阅专栏

POJ1065

http://poj.org/problem?id=1065

题意

描述

C小加有一些木棒，它们的长度和质量都已经知道，需要一个机器处理这些木棒，机器开启的时候需要耗费一个单位的时间，如果第i+1个木棒的重量和长度都大于等于第i个处理的木棒，那么将不会耗费时间，否则需要消耗一个单位的时间。因为急着去约会，C小加想在最短的时间内把木棒处理完，你能告诉他应该怎样做吗？

输入

第一行是一个整数T，表示输入数据一共有T组。
每组测试数据的第一行是一个整数N（1<=N<=5000）,表示有N个木棒。接下来的一行分别输入N个木棒的L，W（0 < L ,W <= 10000），用一个空格隔开，分别表示木棒的长度和质量。

输出

处理这些木棒的最短时间。

样例输入

3
5
4 9 5 2 2 1 3 5 1 4
3
2 2 1 1 2 2
3
1 3 2 2 3 1

样例输出

2
1
3

思路

题目的确需要稍加思考，这道题的要求其实是将所有stick分为x个不下降子序列( Ai <= Ai+1 )，然后问题归结于求x的最小值。
x的最小值其实等于按l递增排序后stick按w最长下降子序列的长度L。证明如下：
若x < L，先从stick中取出最长下降子序列L，取走的元素留下一个大小相同的“空穴”，然后将剩下的元素和空穴分成x个不下降子序列。接着把最长下降子序列L中的L个元素放回这L个空穴里。由于x < L，所以根据鸽笼原理，必然有两个或两个以上的下降子序列L中的元素(b > a)被按顺序放到同一个不下降子序列(a <= b)，产生矛盾（两者本应该是等效的）。
问题归结于求解最长下降子序列的长度L，若定义：
dp[i] := 长度为i+1的下降子序列中末尾元素的最大值，更新时二分法查找，复杂度为O(nlogn)。
关于这个题更详尽的数学分析见博文：
poj1065–Wooden Sticks–利用Dilworth定理
 链-反链-Dilworth定理

代码

Source Code

Problem: 1065       User: liangrx06
Memory: 300K        Time: 16MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 5000;
const int INF = 0x3f3f3f3f;

struct Stick {
    int l, w;
};

bool cmp(const Stick& a, const Stick b)
{
    return (a.l != b.l) ? (a.l > b.l) : (a.w > b.w);
}

int main(void)
{
    int t, n;
    Stick s[N];
    int dp[N];

    cin >> t;
    while (t--) {
        cin >> n;
        fill(dp, dp+n, INF);
        for (int i = 0; i < n; i ++)
            scanf("%d%d", &s[i].l, &s[i].w);
        sort(s, s+n, cmp);
        for (int i = 0; i < n; i ++) {
            *lower_bound(dp, dp+n, s[i].w) = s[i].w;
        }
        printf("%d\n", lower_bound(dp, dp+n, INF) - dp);
    }

    return 0;
}

POJ1631

http://poj.org/problem?id=1631

题意

新来的实习生把路由线路搞得一团糟！如图，原本左右端口应当按顺序连接。现在只有切除部分线路，使得任何线路都不相交。希望你写一个程序计算最后剩下多少线路？
这里写图片描述

思路

典型的最长不下降子序列LIS。有O(n^2)的做法，也有O(nlogn)的做法，这里我用了O(nlogn)的，基本思路是：tot=1（因为最长不下降子序列最坏的情况下都会有1个数据），然后每读一个数据x，就在数组a[]中二分查找，找到最小的比x大的a[i]，替换a[i] = x；如果找不到，则把x插入到a[]的最后，即tot++。最后的tot即为所求。
算法的时间复杂度是：二分查找O(logn)，一共有n个数据，因此是O(n * logn)。
利用STL中的lower_bound函数可以替代手写二分查找，并能够省去计数变量。

代码

Source Code

Problem: 1631       User: liangrx06
Memory: 552K        Time: 125MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 40000;
const int INF = 0x3f3f3f3f;

int main(void)
{
    int t, n;
    int a[N];
    int dp[N];

    cin >> t;
    while (t--) {
        cin >> n;
        fill(dp, dp+n, INF);
        for (int i = 0; i < n; i ++) {
            scanf("%d", &a[i]);
            *lower_bound(dp, dp+n, a[i]) = a[i];
        }
        printf("%d\n", lower_bound(dp, dp+n, INF) - dp);
    }

    return 0;
}

POJ3666

http://poj.org/problem?id=3666

题意

农夫约翰想修一条尽量平缓的路（高度非增或非减的），路的每一段海拔是A_i，修理后是B_i，花费|A_i – B_i|，求最小花费。

思路

这个题非增和非减两种情况是类似的，所以我们这里只考虑非减的情况。
首先我们会发现，最终修改后，B_i或者和前一个数字一样，或者和后一个数字一样，这样才能修改量最小。因此B_i的来源只能是原数列中的数。
我们先根据原数列排序，确定元素的大小关系，对应编号为b[i]。
DP数组的具体表示为：
dp[i][j] 表示考虑前i个元素，最后元素为序列中第j小元素的最优解
dp[i][j] = MIN(dp[i-1][k]) + abs(a[i]-a[p[j]]), (0

代码

Source Code

Problem: 3666       User: liangrx06
Memory: 292K        Time: 47MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 2000;
const int INF = INT_MAX/2;

int n;
int a[N], b[N];
int dp[2][N+1];

int main(void)
{
    cin >> n;
    for (int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    memcpy(b, a, sizeof(a));
    sort(b, b+n);

    fill(dp[0], dp[0]+1+n, INF);
    dp[0][0] = 0;
    for (int i = 1; i <= n; i++) {
        int preMinCost = dp[(i-1)&1][0];
        for (int j = 0; j < n; j++) {
            preMinCost = min(preMinCost, dp[(i-1)&1][j]);
            dp[i&1][j] = preMinCost + abs(b[j] - a[i-1]);
        }
    }
    cout << *min_element(dp[n&1], dp[n&1]+n) << endl;

    return 0;
}

POJ2392

http://poj.org/problem?id=2392

题意

有k种石头，高为hi，在不超过ai的高度下，这种石头可以放置，有ci种这个石头，求这些石头所能放置的最高高度。

思路

有限制条件的多重背包。
首先需要对限制条件进行排序处理，将石头按ai大小进行排序。然后就是一个标准的多重背包了。
之后这个题的解法与《挑战》书中P62-63的多重部分和问题就基本上一样了，另外可以参考我的另一篇博客：
《挑战程序设计竞赛》2.3.2 动态规划-优化递推 POJ1742 3046 3181
中的POJ1742题详解。

代码

Source Code

Problem: 2392       User: liangrx06
Memory: 404K        Time: 63MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int K = 400;
const int A = 40000;

struct Block {
    int h, a, c;
};

bool cmp(Block x, Block y)
{
    return x.a < y.a;
}

int main(void)
{
    int k;
    Block b[K];
    int dp[A+1];
    cin >> k;
    for (int i = 0; i < k; i ++)
        scanf("%d%d%d", &b[i].h, &b[i].a, &b[i].c);
    sort(b, b+k, cmp);

    memset(dp, -1, sizeof(dp));
    dp[0] = 0;
    for (int i = 0; i < k; i ++) {
        for (int j = 0; j <= b[i].a; j ++) {
            if (dp[j] >= 0)
                dp[j] = b[i].c;
            else if (j < b[i].h || dp[j-b[i].h] <= 0)
                dp[j] = -1;
            else
                dp[j] = dp[j-b[i].h] - 1;
        }
    }
    int m;
    for (m = b[k-1].a; m >= 0; m --) {
        if (dp[m] >= 0) break;
    }
    printf("%d\n", m);

    return 0;
}

POJ2184

http://poj.org/problem?id=2184

题意

有一些奶牛，他们有一定的s值和f值，这些值有正有负，最后让保证s的和为非负且f的和为非负的情况下，s+f的最大值。

思路

一看就是01背包，但题目的限制条件让人似乎又不好处理。
这道题的关键有两点：一是将smartness看作花费、将funness看作价值，从而转化为01背包；二是对负值的处理，引入一个shift来表示“0”，这里的shift一定要大于每一个smartness的绝对值，另外在遍历cost[]的时候如果cost[i]>0，显然时从开的数组的最大值maxm 开始往下减，如果cost[i]<0，则是从0（是0，不是shift）开始往上增加。大于0的情况容易想到，小于0的情况比较费解，需要仔细思考。
考虑只有一只牛，它的smartness为-x(x>0)，funness为y(y>0),由于将dp[shift]赋初值为0，其它的dp[]赋初值为负无穷，所以有dp[shift-(-x)]+y>dp[shift],即dp[x]会被赋为dp[shift-(-x)]+y即y（ dp[x]=max(dp[shift-(-x)]+y,dp[shift]) ），由于x小于shift，所以在最后遍历最大值的时候，这个值根本不会被遍历。
再考虑前面已经有一些牛，此时dp[shift+x]=y(x>0,y>0)现在出现了一只为-a b(a>0,b>0)的牛，那么dp[shift+X-a]会被赋为dp[shift+x-a-(-a)]+b=dp[shift+x]+b=y+b;最终遍历的时候，如果取最后一只牛，和为x-a+y+b,如果不取，和为x+y,所以最大值究竟是谁取决于b-a的正负。
综上所述，这是一种满足题目要求的方法，所以在cost[i]<0的时候时从0开始往上增加。

另外我在做的过程中
memcpy(crt, nxt, sizeof(nxt));
并没有达到应有的数组复制效果。找了很长的时间才发现是这句话出了问题。然后上网查memset的用法，也没有发现问题。看来以后要慎用memcpy函数。
关于本题，其它的分析可参考博客：poj2184 Cow Exhibition 01背包变形

代码

Source Code

Problem: 2184       User: liangrx06
Memory: 1804K       Time: 266MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 100;
const int M = 1000;
const int MAX = M*N;
const int INF = 2*MAX+1;

int n;
int s[N+1], f[N+1];
int dp[2][MAX*2+1];

int main(void)
{
    cin >> n;
    for (int i = 0; i < n; i++)
        scanf("%d%d", &s[i], &f[i]);

    int *crt = dp[0], *nxt = dp[1];
    fill(nxt, nxt+MAX*2+1, -INF);
    nxt[MAX] = 0;
    for (int i = 0; i < n; i ++) {
        //memcpy(crt, nxt, sizeof(nxt));
        for (int j = 0; j <= 2*MAX; j ++)
            crt[j] = nxt[j];
        for (int j = 0; j <= 2*MAX; j ++) {
            int j0 = j-s[i];
            if (j0 >= 0 && j0 <= 2*MAX && crt[j0] != -INF) {
                nxt[j] = max(nxt[j], crt[j0]+f[i]);
            }
        }
    }
    int ans = 0;
    for (int j = 2*MAX; j >= MAX; j --) {
        if (nxt[j] >= 0)
            ans = max(ans, nxt[j]+j-MAX);
    }
    printf("%d\n", ans);

    return 0;
}