洛谷P1103 书本整理

题面：

解题：

1. 创建book类、myCompare类，将书本按高度排序（不多解释，详见代码）

2. dp

为排序后的书标号，为1~n号

用f[ i ][ j ]记录第i号书和第j号书的宽度差（限制i>j）

dp[ i ][ j ]记录从i号书与其前面的任意j-1本书的最小不整齐度，其构成一个长度为j的组……

易知：i>=j

计算样例中dp的数据：

样例（高度排序后）：
n=4 k=1
1 2
2 4
3 1
5 3

dp[1][1]=0 dp[2][1]=0 dp[3][1]=0 dp[4][1]=0…………j=1时，只有第i本书它本身，值为0

dp[2]：

dp[2][2]=f[1][2]=2

dp[3]：

dp[3][2]=min（dp[1][1]+f[1][3]，dp[2][1]+f[2][3]）

dp[3][3]=dp[2][2]+f[2][3]

dp[4]：

dp[4][2]=min（dp[1][1]+f[1][4]，dp[2][1]+f[2][4]，dp[3][1]+f[3][4]）

dp[4][3]=min（dp[2][2]+f[2][4]，dp[3][2]+f[3][4]）

dp[4][4]=dp[3][3]+f[3][4]

可见，除了i、j的循环外，我们还需要一个内层循环l，不断更新dp[ i ][ j ]的最小值；

最后，从n-k~n的每本书都有可能作为那个结尾的书，因此答案应在dp[ i ][n-k]中取最小值：

    int ans = dp[n][n - k];
    for (int i = n - k; i <= n-1; i++)ans = min(ans, dp[i][n - k]);

AC代码奉上

#include<iostream>
#include<algorithm>
#include<vector>
#define MAXN 300
using namespace std;

class book
{
public:
    int h, w;
};

class myCompare
{
public:
    bool operator()(book b1, book b2)
    {
        return b1.h < b2.h;   //降序排列
    }
};

int n, k;
int f[MAXN][MAXN] = { 0 };  //存储任意两本书间的不整齐度
int dp[MAXN][MAXN] = { 0 };
vector<book>v;

void printDp()
{
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= min(n - k,i); j++)
            cout << "dp[" << i << "][" << j << "]=" << dp[i][j] << endl;
}

int main()
{
    v.push_back(book());
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
    {
        book b1;
        cin >> b1.h >> b1.w;
        v.push_back(b1);
    }
    sort(v.begin(), v.end(), myCompare()); //高度排序

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            f[i][j] = abs(v[i].w - v[j].w);
            dp[i][j] = 999999999;//初始化为无穷大
        }
        dp[i][1] = 0; //只有自己的话，dp为0
    }
    dp[2][2] = f[1][2];//初始化dp[2][2]

    for (int i = 2; i <= n; i++)//第i本书
        for (int j = 2; j <= i; j++)//与前面的j-1本相邻(队列长度为j)
            for (int l = j - 1; l <= i - 1; l++)
                dp[i][j] = min(dp[i][j], dp[l][j - 1] + f[l][i]);

    int ans = dp[n][n - k];
    for (int i = n - k; i <= n-1; i++)ans = min(ans, dp[i][n - k]);
    cout << ans << endl;
    return 0;
}