问题

Question

问题

给定一个长度[N]的数组，你必须从数组[0]开始并遍历到结尾。您可以移动一个或两个位置，即数组[0] - > array [1]或array [0] - ＆gt;数组[2]取决于哪个数字总和较低。这将一直重复到最后，必须包含数组[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位置并且您不想知道接下来要去哪里，而是要求＆＃34;达到目标的最佳（成本效益）方式是什么？目前的位置和费用是多少？＆＃34; 。

对于第一个位置i=0，这是微不足道的。您可以通过启动算法来达到此位置，并且费用等于a[0]的值。

对于第二个位置i=1，它也是微不足道的。您可以按1（小步）或2（大步）的步长移动，但在这种特定情况下，只能执行一小步，因此您可以通过从位置i=1到达i=0来达到i=0费用等于达到i=1加上位置i>1的费用。

对于以下所有职位i-1，需要做出决定，无论是通过一小步还是一大步都能达到当前位置。如果通过一小步达到当前位置，则其成本将计算为达到i的成本加上位置i-2的值。在其他情况下，如果通过大步骤达到当前位置，则其成本计算为达到i的成本加上位置i的值。为了以最低的成本达到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];的位置，通过比较相关成本和选择最小成本来决定小步和大步。

当到达阵列的末尾时，将计算到达每个位置的成本和步骤，并且可以返回到达最后位置的成本。

如果您只需要最低成本而不是实际路径，则以下内容应该有效（与c相关的伪代码）：

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

除了包含所有子成本的数组之外，您甚至可以使用总共3个变量（丢弃代表低于//Router file - index.js //import React, BrowserRouter, React Dom, Header and Components A, B and C parent //Create Root component, add BrowserRouter and add a subpath for browserRouter - needed for the nested routes //Root component renders inside HTML element with an ID of main //Have a Match for '/' (it will actually be to "/subpath")- then it renders Parent of ABC import React from 'react'; import { render } from 'react-dom';//instead of importing ALL react dom we just import the render //React Router V4 uses Match and Miss - if something Matches a path it will render the assigned component and you use Miss for a 404/not found page import { BrowserRouter, Match, Miss } from 'react-router'; import Header from './components/Header'; import ComponentABCParent from './components/ComponentABCParent'; const Root = () => { return ( <BrowserRouter basename="/subpathHere"> <div> <div id="header"> <Header /> </div> <div className="app-content"> <Match pattern="/" component={ComponentABCParent}/> <Miss component={NotFound} /> </div> </div> </BrowserRouter> ) } render(<Root/>, document.getElementById('main')); //Parent of A, B and C with nested route //Create parent component - place inside ComponentA and two Match's //One Match for Component B which is rendered immediately //Second Match for ComponentC import React from 'react'; import {Link, Match, Miss} from 'react-router'; import OracleCircle from './ComponentA'; import Intro from './ComponentB'; import StepOne from './ComponentC'; const ComponentABCParent = ({ pathname }) => { return ( <div> <ComponentA /> <Match exactly pattern={`${pathname}`} component={ComponentB} /> <Match pattern={`${pathname}component-c`} component={ComponentC}/> </div> ); } export default ComponentABCParent; //Component B - ComponentB.js //Inside ComponentB I have a Link that points to ComponentC import React from 'react'; import {Link} from 'react-router'; const ComponentB = ({pathname}) => { return ( <div> <h1>"Stack Overflow is not a tutorial website"</h1> <Link to={`${pathname}component-c`}>Go to C</Link> </div> ); } export default ComponentB; //Component C - ComponentC.js //Render ComponentC with funny answer import React from 'react'; import {Link} from 'react-router'; const ComponentA = ({pathname}) => { return ( <div> <h1>"Your Momma is a tutorial website"</h1> </div> ); } export default ComponentA;的索引的子成本），但这条路径不能重新使用 - 从次级成本构建。

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

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

解决方案我修改为。

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;
    }
}

我必须添加第二个到最后一个元素检查，因为如果迭代器在第二个到最后一个登陆，那么没有理由检查哪个更低，因为我不得不选择最后一个。

通过阵列最便宜的成本

问题

我目前的解决方案：

3 个答案:

解决方案我修改为。