HDU 1421 搬寝室(dp)

最新推荐文章于 2014-10-10 22:11:15 发布

原创最新推荐文章于 2014-10-10 22:11:15 发布 · 672 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

数据结构与算法专栏收录该内容

338 篇文章

订阅专栏

本文详细介绍了HDU1421搬寝室问题的动态规划解决方案，通过对物品按重量排序并配对的方式减少疲劳值，利用状态转移方程实现最优解的求解。

题目链接：HDU 1421 搬寝室

dp。

思路（蓝飞技术部落格）：

每对物品都应是重量最为接近的物品，也就是说对n件物品排序后，每对物品都应该是连续的。

证明大家都会，就此略过。

以动态规划的思想来思考本题：

定义数组a[i]为搬第i对物品所消耗的疲劳值；数组f[n][k]来表示在n件物品中搬k对的最佳状态，而达到这一状态的决策可能为：

第n件物品不搬，即在前n - 1件物品中搬k对，那么疲劳值仍为f[n - 1][k]；
第n件物品要搬，那么根据上面所证，第n - 1件物品也要同时搬，即在前n - 2件物品中搬k - 1对物品，再搬最后一对物品，那么疲劳值为f[n - 2][k - 1] + a[n - 1]，n - 1是因为对数必然比总物品数少1。

状态转移方程：f[n][k] = min(f[n - 1][k], f[n - 2][k - 1] + a[n - 1])

好像循环顺序无所谓的。。

#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;

const int MAX_N = 2000 + 200;
const int INF = (1 << 30);
int dp[MAX_N][MAX_N >> 1];
int value[MAX_N];
int n,k;

int solve(int i, int j)
{
    if((i << 1) > j)
        return INF;
    else if(i == 0)
        return 0;
    else
        return dp[j][i];
}
int main()
{
    while(cin >> n >> k)
    {
        for(int i = 1;i <= n;i++)
            cin >> value[i];
        sort(value + 1, value + n + 1);
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= k && (j << 1) <= i;j++)
            {
                dp[i][j] = min(solve(j,i - 1), solve(j - 1,i - 2) + (value[i] - value[i - 1]) * (value[i] - value[i - 1]));
            }
        }
        cout << dp[n][k] << endl;
    }
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;

const int MAX_N = 2000 + 200;
const int INF = (1 << 30);
int dp[MAX_N][MAX_N >> 1];
int value[MAX_N];
int n,k;

int solve(int i, int j)
{
    if((i << 1) > j)
        return INF;
    else if(i == 0)
        return 0;
    else
        return dp[j][i];
}
int main()
{
    while(cin >> n >> k)
    {
        for(int i = 1;i <= n;i++)
            cin >> value[i];
        sort(value + 1, value + n + 1);
        for(int i = 1;i <= k;i++)
        {
            for(int j = i << 1;j <= n;j++)
            {
                dp[j][i] = min(solve(i,j - 1), solve(i - 1,j - 2) + (value[j] - value[j - 1]) * (value[j] - value[j - 1]));
            }
        }
        cout << dp[n][k] << endl;
    }
    return 0;
}