double的dp,上取整下取整,整数消除浮点数

LINK

给定dist数组，比如是：{1, 3, 2}

我们需要 到达终点C。 步行速度是固定的，为speed
当到达某一点时，如果耗时不是整数 比如是0.25： 则可以选择，是否跳过

• 如果选择跳过： 即立刻继续行走，同时 代价 += 1
• 否则： 必须等到整数点，即等到时间为1时 出发。

当然，如果耗时已经是整数，自然立刻走就行，无代价

---

以上图为例，到达A时， 时间是0.25：

• 不跳过， 达到B点时间是： (1) + (3/4) = 1.75
• 跳过（代价 = 1），到达B点时间是： (0.25) + (3/4) = 1

一种方案（不跳过，不跳过）：
(1/4 上取整) + (3/4 上取整) + (2/4) = 1 + 1 + 0.5 = 2.5
注意，到达终点C时，此时就不用选择是否跳过了 因为已经到了，不存在上取整问题

一种方案（跳过，不跳过）：
(1/4 跳过，不用上取整) + (3/4) + (2/4) = 1.5
在B时，此时耗时是1，已经是整数的，所以可以直接走。

给定一个ma，问在总耗时 <= ma的前提下，最小的代价。无解则输出-1
所谓无解，即如果每次都跳过，总耗时还>ma，则无解

---

n = 1000， dist[] = [1, 1e5], speed = 1e6

很直观的想， dp[i][j]为： 到达第[i]个点，且用了j次跳过，的 最小耗时。
for(i, 0, n-1, 1) if(dp[n-1][j] <= ma){ return j; } return -1;

注意，是到达第[i]个点， 不用考虑在第[i]个点 是否跳过！！
这是后面的事情，dp[i][j]直观到达第i个点。
即，第二维度的j 最多是n-1个，即跳过前面的n-1个点。

令cost = dist[i + 1] / speed，即当前点 到达 下个点，的时间
dp[i + 1][j] = ceil( dp[i][j] ) + cost， 当前在i点，不跳过[i]点，到达下个点
dp[i + 1][j + 1] = dp[i][j] + cost， 当前在i点，直接跳过
一定要注意这里！！ 我们这里是方便写dp转换，所以直接写成等号=，但是实际，肯定是要取min的！！

dp[0][0] = (double)dist[0] / speed;
for(int i = 0; i < n - 1; ++i){
    for(int j = 0; j < n - 1; ++j){
        const double& cur = dp[i][j];
        dp[i + 1][j] = min (dp[i + 1][j], ceil(cur) + (double)dist[i + 1] / speed);
        dp[i + 1][j + 1] = min (dp[i + 1][j + 1], cur + (double)dist[i + 1] / speed);
    }
}
for(int i = 0; i < n; ++i){
    if (dp[n - 1][i] <= ma) { return i; }

}
return -1;

所以，倒是挺简单的dp，但是由于是double的dp，肯定是考察的对double的精度处理。

• 第一个是ceil，他是很危险的。
  比如，本来是2，但计算机存储了[2.0000001]，导致ceil错了。
  所以，ceil(X - eps)， floor(X + eps)
• 第二个是(dp <= ma)的比较，很容易忘记这里的比较！ double的所有比较，也要当心！！
  比如，本来两者相同， 但是ma少存储了0.0000001
  所以是：dp <= ma + eps

好了，这样 上面的代码就正确了。

重点说下，eps怎么取。
首先，计算机产生的误差，肯定要比你的数据的有效位要低！！
比如，你double存最小精度是1e-6，计算机不会产生<=1e-6的误差！！！ 否则，这还了得…
所以，也就意味着： 对于所有<1e-6的值，我们都可以忽略！！！ 因为我们的有效位，就到1e-6

故，eps取到1e-7！！！

---

整数消除浮点数

注意，上面的算法 是完全正确的！！！ 绝对没问题，即使double有误差，但我们已经处理绝对正确了，就使用上面算法足矣。

完全没必要使用这个算法， 了解一下即可。

上面算法大概形式是：

如果要消除分母， 自然重点是看 上取整 的那个式子，其他式子都可以直接同乘s

好了，看上下取整函数：

上下取整函数，不符合 交换律！！！

即，你写成：
$$F_i\ast s=\lceil F_{i-1}\ast s\rceil +dist[i-1]$$
这是错的！！！ 这个s，不可以放入 上取整里面去！！

---

但此时一定不要放弃！！！ 不可以放到里， 那就放到外面呗！！
$$F_i\ast s=\lceil F_{i-1}\rceil \ast s+dist[i-1]$$
这肯定是对的！！

首先看第一个式子：
$$F_0=\frac{d[0]}{s}$$
这个式子，很容易可以把speed给消去：
$$F_0\ast s=d[0]$$

---

此时我们得到：
$F_0\ast s=d[0]$
$F_i\ast s=\lceil F_{i-1}\rceil \ast s+dist[i-1]$
左侧 F0*s是整数！！！因为d[0]是整数
左侧 Fi*s是整数！！ 因为右侧是：上取整*整数 + 整数！！！

---

令： $$P_i=F_i\ast s$$则P都是整数！！！
有：
$$P_0=dist[0]$$$$P_i=\lceil \frac{P_{i-1}}{s}\rceil \ast s+dist[i-1]（不跳过）$$$$P_i=P_{i-1}+dist[i-1]（跳过）$$

所求答案： F[] <= ma，对应于： P[] <= ma * s

$\lceil \frac{P_{i-1}}{s}\rceil$中的$\frac{P_{i-1}}{s}$，他并不是一个整数，否则对一个整数 上取整，没有意义。 原因可以去看P与F的关系。
对于他的求法，你肯定不能： double ans = ceil( Pi-1 / s) 你这有回到double浮点数了！！
因为，这最终是个上取整，即是个整数。“而且，Pi-1 和 s，都是整数”，所以 没必要用double
{(Pi-1) + s - 1} / s便是答案

反正，你根据这个式子 进行dp即可。 毕竟这个式子，完全是推导出来的。

dp[0][0] = dist[0];
for(int i = 0; i < n - 1; ++i){
    for(int j = 0; j < n; ++j){
        const LL& cur = dp[i][j];
        dp[i + 1][j] = min (dp[i + 1][j], 
        		(cur + s - 1) / s * s + (LL)dist[i + 1]);
        		'注意这里！！！ 别写成： (cur + s - 1) / s + (LL)，还有个*s '
        dp[i + 1][j + 1] = min (dp[i + 1][j + 1], cur + dist[i + 1]);
    }
}
for(int i = 0; i < n; ++i){
    if (dp[n - 1][i] <= ma * 1ll * s) { return i; }
}
return -1;