通过阵列最便宜的成本

Question

问题

给定一个长度为 [N] 的数组，您必须从数组 [0] 开始并遍历到末尾。您可以移动一个或两个位置，即 array[0] -> array[1] 或 array[0] -> array[2] 取决于哪个数字总和较低。这将一直重复到最后，并且必须包含 array[N]。

[1, 10, 3, 8, 4] 最便宜的导航方式是 = 8 via array[0] + array[2] + array[4]

我目前的解决方案：

int totalCost = 0
totalCost += array[0]
int i = 1;
while (i < array.length)
{
    if (i + 1 < array.length)
    {
        int sum1 = totalCost + array[i];
        int sum2 = totalCost + array[i + 1];
        if (sum1 < sum2)
        {
            totalCost += array[i];
            i++;
        }
        else
        {
            totalCost += array[i + 1];
            i += 2;
        }
    }
    else
    {
        totalCost += array[i];
        i++;
    }
}

这似乎适用于大多数数组...如果早期跳转会导致更大的数字，但允许更好地通过数组进一步跳转，最终会导致更低的数字，那么问题就来了。我不知道如何处理。

Answer 1

你的方法行不通，因为当你处于某个元素时，你试图决定下一步行动。关键是，在您知道数组末尾的第二个元素之前的所有元素值之前，您通常无法决定下一步行动。

不仅在计算机科学中，而且通常回顾过去和学习比展望未来和预测更容易。因此，只要可以从历史数据中解决问题或子问题，就不要试图以未来的期望来解决它。

现在，让我们看看如何将其应用于您的问题。

如果您在数组中的位置i，您所做的就是通过查看可能的后续步骤并决定其中一个来尝试预测正确的方式，这无法可靠地工作。因此，让我们假设您在位置i，并且您不想知道下一步要去哪里，而是问“到达当前位置的最佳（成本效益）方法是什么以及它有多少成本？”。

对于第一个位置i=0，这是微不足道的。您通过启动算法到达此位置，成本等于a[0] 的值。

对于第二个位置i=1，也是微不足道的。您可以以 1（小步）或 2（大步）的步长移动，但在这种特定情况下，只有一小步是可能的，因此您从位置 i=0 到达 i=1，成本等于成本到达i=0 加上位置值i=1。

对于所有后续位置i>1，需要做出决定，是通过小步还是大步到达当前位置。如果小步到达当前位置，其成本计算为到达i-1 的成本加上位置i 的值。其他情况，如果当前位置大步到达，其成本计算为到达i-2的成本加上位置i的值。为了以最低的成本到达位置i，通过比较它们的相关成本并选择最小值来决定小步和大步。

当到达数组的末尾时，将计算到达每个位置的成本和步数，并返回到达最后一个位置的成本。

如果您只需要最小成本而不需要实际路径，那么以下应该可以工作（c 相关的伪代码）：

costs[array.size] = { 0 };

for (i = 0; i < array.size; ++i)
{
    if (i > 1) costs[i] = array[i] + min(costs[i-1], costs[i-2]);
    else if (i > 0) costs[i] = array[i] + costs[i-1];
    else costs[i] = array[i];
}

result = costs[array.size - 1];

它基本上说：到达一个点i 可以通过从前一点或从前两点来完成。如果已经计算了前两个点的成本，则决策就像取前两个点成本中的最小值并添加当前点成本一样简单。

您甚至可以使用总共 3 个变量来代替包含所有子成本的数组（丢弃代表低于i-2 的索引的子成本），但是路径不能从子成本。

Answer 2

var c = new List<int>();
for (int i = 0; i < a.Length - 1;)
{
    c.Add(i);
    if (i < a.Length - 2 && a[i + 2] < a[i + 1])
        i += 2;
    else
        i += 1;
}
c.Add(a[a.Length - 1]);

Answer 3

我忽略了未来总和受到早期选择影响的可能性。我同意这是某种程度的人工智能。

我修改为的解决方案。

int total = 0;
cost += array[0];

int i = 0;
while (i < array.Length - 1)
{
    if ((array[i+1] + total) < array[i+2] + total) && (i != array.Length - 3))
    {
        total += array[i + 1];
        i++;
    }
    else
    {
        total += array[i + 2];
        i += 2;
    }
}

我必须添加倒数第二个元素检查，因为如果迭代器落在倒数第二个，没有理由检查哪个更低，因为无论如何我都必须选择最后一个。