[线性DP]尼克的任务

题目描述

尼克每天上班之前都连接上英特网，接收他的上司发来的邮件，这些邮件包含了尼克主管的部门当天要完成的全部任务，每个任务由一个开始时刻与一个持续时间构成。 尼克的一个工作日为N分钟，从第一分钟开始到第N分钟结束。当尼克到达单位后他就开始干活。如果在同一时刻有多个任务需要完成，尼克可以任选其中的一个来做，而其余的则由他的同事完成，反之如果只有一个任务，则该任务必需由尼克去完成，假如某些任务开始时刻尼克正在工作，则这些任务也由尼克的同事完成。如果某任务于第P分钟开始，持续时间为T分钟，则该任务将在第P+T-1分钟结束。 写一个程序计算尼克应该如何选取任务，才能获得最大的空暇时间。

输入

输入数据第一行包含两个用空格隔开的整数N和K，1≤N≤10000，1≤K≤10000，N表示尼克的工作时间，单位为分，K表示任务总数。 接下来共有K行，每一行有两个用空格隔开的整数P和T，表示该任务从第P分钟开始，持续时间为T分钟，其中1≤P≤N，1≤P+T-1≤N。

输出

输出文件仅一行包含一个整数表示尼克可能获得的最大空暇时间。

样例输入

15 6

1 2

1 6

4 11

8 5

8 1

11 5

样例输出

4

思路：

首先，我必须珍而重之的说，这个题是倒推的，倒推比较简单，因为正推有后效性

一维的线性动归，状态转移方程：e[j].from != i   f[i] = f[i+1] + 1

      e[j].from = i    f[i] = max{ f[i], f[ e[j].from + e[j].to ] }

所设变量：

int n, k;//n为尼克的工作时间（min），k为任务总数
node e[N];//原始数据
//成员from是工作起始点，to是工作时间，也就是说 第from+to-1分钟 当前任务结束，第from+to分钟 就可以开始新工作了
int f[N];//记录 i 时间到n所能得到的最大空闲时间

</pre></div><div><pre>

根据第一题样例，我们可以得到两个表格

e[N]

	from	to
1	1	2
2	1	6
3	4	11
4	8	5
5	8	1
6	11	5

f[N]数组

i	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
f[i]	4	3	2	1	6	5	4	3	2	1	0	4	3	2	1

先来解释一下状态转移方程：

①e[j].from != i   f[i] = f[i+1] + 1

我们要求最大的空闲时间，所以我们倒着推，i 是从 n 开始的（实际上会用到f[n+1]，由于其值为0不等于所以不用特意初始化），当第 j 个任务上边界不等于当前时间，说明 i 时间所能得到的最大空闲时间比 i+1 时间所能得到的最大空闲时间多一分钟，就是 f[i] = f[i+1] + 1;

看f[N]数组的表格也可以看出来这点，都是以1为单位递增或递减的

②e[j].from = i    f[i] = max{ f[i], f[ e[j].from + e[j].to ] }

e[j].from + e[j].to 指的是可以开始新工作的时间点，由题目中的(p+t-1)可知，e[j].from + e[j].to 就是第 j 个任务结束的时间点

以样例为例：

紫色块就是满足 e[j].from = i 的 i;

i = 11时，e[6].from = i, f[11] = max{f[11], f[e[6].from] + e[6].to} = max{f[11], f[16]}  =max{0, 0} = 0;

i = 8时，e[5].from = i, f[8] = max{f[8], f[e[5].from, + e[5].to} = max{f[8], f[9]} = max{0, 2} = 2;

i = 8时，e[4].from = i, f[8] = max{f[8], f[e[4].from, + e[4].to} = max{f[8], f[13]} = max{2, 3} = 3;

i = 4时，e[3].from = i, f[4] = max{f[4], f[e[3].from] + e[3].to} = max{f[4], f[15]}  =max{0, 1} = 1;

i = 1时，e[2].from = i, f[1] = max{f[1], f[e[2].from] + e[2].to} = max{f[1], f[7]}  =max{0, 4} = 4;

i = 1时，e[6].from = i, f[1] = max{f[1], f[e[1].from] + e[1].to} = max{f[1], f[3]}  =max{4, 2} = 4;

推而广之，可得 f[i] = max{ f[i], 第 i 个任务结束后可以开始新工作的时间点到n所能得到的最大空闲时间 }

代码：

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
//f[i]表示从时间i起的最大空闲时间，逆推
const int N = 10000 + 10;
int n, k;
int f[N];
struct node{
    int from;
    int to;
}e[N];
int cmp(node a, node b)
{
    return a.from < b.from;
}
void dp()
{
    int j = k;
    for(int i = n; i >= 1; i--)
    {
        if(e[j].from != i)
            f[i] = f[i+1] + 1;
        else
        {
            while(e[j].from == i)//可能有多次i一样的情况，如样例中的e[j].from = 8的情况</span>
            {
                if(f[i] < f[e[j].from + e[j].to])//第i分钟开始，所以e[j].from + e[j].to不用-1
                    f[i] = f[e[j].from + e[j].to];
                j--;
            }
        }
    }
}
int main()
{
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= k; i++)
        scanf("%d%d", &e[i].from, &e[i].to);
    sort(e+1, e+k+1, cmp);
    dp();
    printf("%d", f[1]);
    return 0;
}
/*
15 6
1 2
1 6
4 11
8 5
8 1
11 5
---------
4
*/

反思：

我一开始是把f[N]设为0到 i 时间最少的工作时间，也就是正推，做了很久没做出来，因为有后效性，所以要考虑的比较多；

但是我并不觉得正推就不可能实现，我有一定的思路，今晚尝试后再给出答案；

那么这就有个问题，如果有后效性，那这个问题就应该换一个角度看，还是有后效性就是复杂些但还是可以做出来的