C++ 具有加油站任务变化的DP算法

我有一个问题，我从a点旅行到B点，距离定义为

l

。在我的车里，我有一个油箱，它只能让我跑

b

公里。在

n

的地方有加油站，加油的费用（我只能完全加油）。我从满油箱开始

从高速公路的起点到终点，成本最低的最有效的算法是什么

我最近的想法：

使用窗口滑动最小算法查找（长度为

b

）成本最低的站点。代码：

int n, range, targetDist;
scanf("%d %d %d", &n, &targetDist, &range);
int di, ci;
for (int k = 1; k <= n; k++)
{
    scanf("%d %d", &di, &ci);
    D[k] = di;
    C[k] = ci;
}
D[0] = C[0] = bestcost[0] = 0;
for (int i = 1; i < n+1; ++i)
{
    bestcost[i] = 1 << 30;
    for (int j = 0; j < i; ++j)
    {
        int xx = bestcost[j] + C[i];
        if (D[i] - D[j] <= range && xx < bestcost[i])
        {
            bestcost[i] = xx;
            printf("(%d, %d)\n", i, bestcost[i]);
        }
    }
}

输出为：

(1, 1)
(2, 2)
(3, 4) 

所以它对应于成本（i，成本（i））-要到达第i站，我必须支付成本（i）

---

如何利用这些信息找到整个距离的最小成本？

我找到了一种在O（n）时间内使用滑动窗口算法的方法：

#include <vector>
#include <algorithm>
#include <deque>
#include <stdio.h>


typedef unsigned long long int ulli;

using namespace std;

void sliding_window_minimum(vector<pair<ulli, ulli>> st, ulli n, ulli targetDist, ulli range)
{
    deque<pair<ulli, ulli>> minimize;
    ulli j = 0;
    for (ulli i = 0; i < n; i++)
    {
        if (st[i].first <= range)
        {
            while (!(minimize.empty()) && (minimize.back().second > st[i].second))
            {
                minimize.pop_back();
            }
            minimize.push_back(st[i]);
            j++;
        }
        else
        {
            break;
        }
    }
    for (ulli k = j; k < n; k++)
    {
        while (!(minimize.empty()) && ((st[k].first - minimize.front().first) > range))
        {
            minimize.pop_front();
        }
        if (minimize.empty()) {
            break;
        }
        ulli tempCost = st[k].second + minimize.front().second;
        while (!(minimize.empty()) && (minimize.back().second > tempCost))
        {
            minimize.pop_back();
        }
        minimize.push_back(make_pair(st[k].first, tempCost));
    }
    while (!(minimize.empty()) && ((targetDist - minimize.front().first) > range))
    {
        minimize.pop_front();
    }
    if (minimize.empty())
    {
        printf("NIE\n");
    }
    else
    {
        printf("%llu", minimize.front().second);
    }
}

int main()
{
    ulli n, d, b;
    scanf("%llu %llu %llu", &n, &d, &b);
    if (b >= d)
    {
        printf("%d", 0);
        return 0;
    }
    int temp = n;
    ulli d1, c1;
    vector<pair<ulli, ulli>> st;
    st.reserve(n+1);
    while (temp--)
    {
        scanf("%llu %llu", &d1, &c1);
        st.push_back(make_pair(d1, c1));
    }
    sliding_window_minimum(st, n, d, b);
}

#包括
#包括
#包括
#包括
typedef无符号长整型ulli；
使用名称空间std；
无效滑动窗口最小值（矢量st、ulli n、ulli targetDist、ulli范围）
{
德克最小化；
ulli j=0；
对于（ulli i=0；i范围）
{
最小化.pop_front（）；
}
if（最小化.empty（））{
打破
}
ulli tempCost=st[k].second+minimize.front（）.second；
而（！（minimize.empty（））&&（minimize.back（）.second>tempCost））
{
最小化.pop_back（）；
}
最小化。向后推（生成一对（st[k]。首先，tempCost））；
}
而（！（minimize.empty（））&（（targetDist-minimize.front（）.first）>范围）
{
最小化.pop_front（）；
}
if（最小化.empty（））
{
printf（“NIE\n”）；
}
其他的
{
printf（“%llu”，minimize.front（）.second）；
}
}
int main（）
{
乌利n，d，b；
scanf（“%llu%llu%llu”、&n、&d、&b）；
如果（b>=d）
{
printf（“%d”，0）；
返回0；
}
内部温度=n；
ulli d1，c1；
向量st；
圣保留地（n+1）；
while（临时--）
{
scanf（“%llu%llu”、&d1和&c1）；
st.push_back（形成一对（d1，c1））；
}
滑动窗口最小值（st、n、d、b）；
}

显然，问题已经讨论过了。

#include <vector>
#include <algorithm>
#include <deque>
#include <stdio.h>


typedef unsigned long long int ulli;

using namespace std;

void sliding_window_minimum(vector<pair<ulli, ulli>> st, ulli n, ulli targetDist, ulli range)
{
    deque<pair<ulli, ulli>> minimize;
    ulli j = 0;
    for (ulli i = 0; i < n; i++)
    {
        if (st[i].first <= range)
        {
            while (!(minimize.empty()) && (minimize.back().second > st[i].second))
            {
                minimize.pop_back();
            }
            minimize.push_back(st[i]);
            j++;
        }
        else
        {
            break;
        }
    }
    for (ulli k = j; k < n; k++)
    {
        while (!(minimize.empty()) && ((st[k].first - minimize.front().first) > range))
        {
            minimize.pop_front();
        }
        if (minimize.empty()) {
            break;
        }
        ulli tempCost = st[k].second + minimize.front().second;
        while (!(minimize.empty()) && (minimize.back().second > tempCost))
        {
            minimize.pop_back();
        }
        minimize.push_back(make_pair(st[k].first, tempCost));
    }
    while (!(minimize.empty()) && ((targetDist - minimize.front().first) > range))
    {
        minimize.pop_front();
    }
    if (minimize.empty())
    {
        printf("NIE\n");
    }
    else
    {
        printf("%llu", minimize.front().second);
    }
}

int main()
{
    ulli n, d, b;
    scanf("%llu %llu %llu", &n, &d, &b);
    if (b >= d)
    {
        printf("%d", 0);
        return 0;
    }
    int temp = n;
    ulli d1, c1;
    vector<pair<ulli, ulli>> st;
    st.reserve(n+1);
    while (temp--)
    {
        scanf("%llu %llu", &d1, &c1);
        st.push_back(make_pair(d1, c1));
    }
    sliding_window_minimum(st, n, d, b);
}