NOJ 1163 活动安排问题 [动态规划]

Posted 2020-09-27 可达龙

活动安排问题

时间限制(普通/Java) : 3000 MS/ 9000 MS 运行内存限制 : 65536 KByte
总提交 : 202            测试通过 : 55

比赛描述

设有n个活动的集合E={1,2，……，n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si<fi。如果选择了活动i，则它在时间区间[si,fi]内占用资源。若区间[si,fi]与区间[sj,fj]不相交，则称活动i与活动j是相容的。也就是说，当si>=fj或者sj>=fi时，活动i与活动j相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

    但在现实生活中，不同的活动所带来的价值和意义是不一样的，所以我们可以为每个活动附上一个权值，现在的问题就是要在所给的活动集合中选出权值和最大的相容活动子集合。

输入

第一行输入一个正整数n（1<=n<=100000）为活动集合的大小 ，余下n行每行输入三个非负整数s，f，v分别代表活动的起始时间，结束时间和权值，(0<=s<f<=10000000 , 0<=v<=10000)。

输出

一行，权值和最大的相容活动子集合的权值和。

样例输入

3
0 5 50
6 9 49
3 7 100

样例输出

100

提示

题目来源

计算机学院/软件学院第二届ACM程序设计大赛

刚上完算法分析课程，刚看到还以为使用分支限界法求的带时限的作业排序，一看问题规模就打消了这个想法。老老实实用动态规划。

思路一：（超时代码）

首先按照时限排序。

dp[i] 表示时间为i时获得的的最大的价值，用背包的思想来考虑每一个活动。转移方程dp[i] = dp[job[k].s] + job[k].w

#include <iostream>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <string.h>
using namespace std;

struct Node
{
    int st;
    int en;
    int w;
    Node(int _st, int _en, int _w):st(_st), en(_en), w(_w) {}
};
bool cmp(Node a, Node b)
{
    return a.en < b.en;
}
vector<Node> Job;
int n,f=0;
int dp[10000010];
int read()
{
    int st,en,w;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        scanf("%d%d%d", &st, &en, &w);
        f=max(en,f);
        Job.push_back(Node(st,en,w));
    }
    sort(Job.begin(),Job.end(),cmp);
}

int main()
{
    read();
    for(int j = 0; j < n; j++)
    {
        for(int i = 0; i <= f; i++)
        {
            if(i >= Job[j].en)
                dp[i] = max(dp[i], dp[Job[j].st] + Job[j].w);
        }
    }
    cout<<dp[f]<<endl;
    return 0;
}

时间复杂度O(n f),超时

然后发现还是不能这样刻画状态，转变了下思路，dp[i]表示前i个活动中，第i个活动选所能带来的最大价值，在考虑第i+1个活动时，找到前i个活动能够满足结束时间早于第i+1个活动开始时间的最晚的活动。

状态转移方程 dp[i] = dp[j] + job[j].w // job[j].en < job[i].st

#include <iostream>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <string.h>
using namespace std;

struct Node
{
    int st;
    int en;
    int w;
    Node(int _st, int _en, int _w):st(_st), en(_en), w(_w) {}
};
bool cmp(Node a, Node b)
{
    return a.en < b.en;
}
vector<Node> Job;
int n, f = 0;
int dp[1000010];
int read()
{
    int st, en, w;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        scanf("%d%d%d", &st, &en, &w);
        f=max(en, f);
        Job.push_back(Node(st, en, w));
    }
    sort(Job.begin(), Job.end(), cmp);
}

int main()
{
    read();
    for(int i = 0; i < n; i++)
    {
        int l = 0, r = i;
        while(l <= r)
        {
            int m = (l + r) >> 1;
            if(Job[m].en <= Job[i].st) l = m + 1;
            else r = m - 1;
        }
        dp[i] = max(dp[i-1], dp[l - 1] + Job[i].w);
    }
    cout << dp[n - 1] << endl;
    return 0;
}

在考虑动态规划时候，要思考描述的状态，勤加思考，考虑更好的方式。