POJ1065 Wooden Sticks 动态规划 贪心

一、简介

本题目用二分也可以解，我记得二分大概需要几百毫秒左右，但是用DP效率更高些，一般时50毫秒左右，DP的思想与上升子序列类似，但思路需要做一个变换。

二、解题思路

从题目中可以看出，每个工件有两个属性重量和宽度，如果前一个工件的重量和宽度都小于当前的工件，那么当前工件不会带来任何的消耗，本题目要求一个消耗最少的加工顺序带来的消耗，但编写出几组测试用例会发现，对于一组测试用例，往往有多组可行解。

简单的思路就是根据长度排序，然后找出每一个节点前面的重量小于它的节点，最为一个子序列，在找子序列时，为了不影响到后面节点的子序列，需要找出自己能够接受的重量最大的工件放在前面，同时标记已经选过的节点，这里用到了一点点的贪心算法，最后用DP数组记录每一个工件在子序列中的顺序。

最后只需要统计出每一个子序列中顺序为1的个数，就可以找到子序列的个数，子序列的个数就是本题目的答案。

三、代码

#include <iostream>
#include <algorithm>
using namespace std;
struct Node
{
    int l, w;
    Node(int l = 0, int w = 0) : l(l), w(w) {}
};
int dp[5007], n;
bool flag[5007];
Node nodes[5007];
bool compare(const Node &a, const Node &b)
{
    if (a.l != b.l)
    {
        return a.l < b.l;
    }
    else
    {
        return a.w < b.w;
    }
}
void flush()
{
    for (int i = 0; i <= n; i++)
    {
        dp[i] = 1;
        flag[i] = true;
    }
}
void input()
{
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &nodes[i].l, &nodes[i].w);
    }
    sort(nodes + 1, nodes + n + 1, compare);
}
void doDp()
{
    int maxIdx = -1, maxVal = -1;
    for (int i = 1; i <= n; i++)
    {
        dp[i] = 1, maxIdx = -1, maxVal = -1;
        for (int j = i - 1; j >= 1; j--)
        {
            if (flag[j] && nodes[i].w >= nodes[j].w)
            {
                if (maxVal < nodes[j].w || (maxVal == nodes[j].w && maxIdx < j))
                {
                    maxVal = nodes[j].w;
                    maxIdx = j;
                }
            }
        }
        if (maxIdx >= 1)
        {
            dp[i] = dp[maxIdx] + 1;
            flag[maxIdx] = false;
        }
    }
}
int findAns()
{
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        if (dp[i] == 1)
        {
            ans++;
        }
    }
    return ans;
}
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d", &n);
        flush();
        input();
        doDp();
        printf("%d\n", findAns());
    }
    return 0;
}