HDU 1074（dp46）（状态压缩dp）

最新推荐文章于 2019-01-29 09:31:01 发布

原创最新推荐文章于 2019-01-29 09:31:01 发布 · 355 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dp #dp46 #HDU #状态压缩dp #动态规划

ACM_HDU 同时被 2 个专栏收录

64 篇文章

订阅专栏

dp46

24 篇文章

订阅专栏

本文介绍了一个基于动态规划的任务调度算法，该算法通过计算最优路径来决定完成一系列具有截止日期和成本的任务的最佳顺序。通过使用栈来追踪并输出所选任务，算法能够有效地找到使总分数最小化的任务组合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<iostream> 
#include<cstdio>
#include<cstring>
#include<algorithm> 
#include<stack>
using namespace std;

const int INF=0x3f3f3f3f;

struct node1
{
    string name;
    int deadline;
    int cost;
}homework[20];

struct node2
{
    int now;
    int pre;
    int time;
    int score;
}dp[1<<15];

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(dp,0,sizeof(dp));
        int i,j,k;
        int n;
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
            cin>>homework[i].name>>homework[i].deadline>>homework[i].cost;
        }
        int end=1<<n;
        for(i=0;i<=end-1;i++)
        {
            dp[i].score=INF;
            dp[0].score=0;
            for(j=n-1;j>=0;j--)
            {
                int tmp=1<<j;
                if(tmp&i)
                {
                    int past=i-tmp;
                    int temp=dp[past].time+homework[j].cost-homework[j].deadline;
                    if(temp<0)
                    {
                        temp=0;
                    }
                    if(temp+dp[past].score<dp[i].score)
                    {
                        dp[i].now=j;
                        dp[i].pre=past;
                        dp[i].time=dp[past].time+homework[j].cost;
                        dp[i].score=temp+dp[past].score;
                    }
                }
            }
        }
        stack<int> S;
        end-=1;
        cout<<dp[end].score<<endl;
        while(end)
        {
            S.push(dp[end].now);
            end=dp[end].pre;
        }
        while(!S.empty())
        {
            cout<<homework[S.top()].name<<endl;
            S.pop();
        }
    }
    return 0;
}