Algorithm 过一个生活编码问题——如何解决这类问题

我正在寻求如何处理这个问题的想法。我的想法是贪婪的做法

问题是：

你在俄罗斯的萨马拉工作了几天，每天每工作一个单位都有新的工资，每食物一个单位都有新的成本。工作1单位消耗1单位能量，吃1单位食物增加1单位能量。在这里 以下是您工作的一些规范：

+你到达时没有钱，但充满活力。你永远不会有比到达目的地时更多的精力，也永远不会是消极的

+你可以每天做任何数量的工作，可能根本不做任何工作，只受你精力的限制。当你的能量为零时，你不能工作

+你可以每天吃任何数量的食物，可能根本没有食物，受你的钱限制。当你的钱为零时，你不能吃东西

+你可以在一天结束时吃东西，并且不能在饭后返回工作岗位。你可以在第二天回去工作。 你真正的目标是带着尽可能多的钱回家。计算你能带回家的最大金额

例如，考虑3天的逗留时间，每天的单位工作报酬如下：收入=（1, 2, 4）。食物的成本是成本=[1,3,6]。从e=5个能量单位开始

*第一天：一份工作值一份，一份食物值一份。今天上班没有任何经济激励

*第二天：一份工作挣2英镑，一份食物要花3英镑，因此你在吃饭上的花费比总收入还要多，所以这一天上班没有任何经济激励

*第三天：你每单位工作挣4个单位。这一天，食物的价格无关紧要，因为你将直接下班回家。你把所有的精力都花在工作上了，你的工资是5 x 4=20个单位 钱，不用买晚饭就回家

功能描述 在下面的编辑器中完成函数calculatePro fit。函数必须返回一个整数，该整数表示您在住宿结束时可以带回家的最大收入

到目前为止，我的解决方案需要改进：

function calculateProfit(n, earning, cost, e) {
    // Write your code here

    let sum = 0

    let ef = e;

    let count = 0;

    let max = 0;

    for (let i = 0; i < n; i++){

        if (i != n - 1) {


                console.log("next day " + ef + " " + ef * earning[i + 1] + "--" + ef * cost[i]);

                if (earning[i] > cost[i]) {

                    sum += ef * earning[i];
                    e = 0;

                    max = 0;

                    if (ef * earning[i + 1] > ef * cost[i] && sum > 0) {

                        //console.log(e);
                        sum -= ef * cost[i];
                        e = ef;
                    }


                }
                else {
                    count++;
                    max = Math.max(max, earning[i]);
                }             




        }
        else {//last day

            if (earning[i] <= cost[i]) {
                count++;                
            }

            max = Math.max(max, earning[i]);

            if (e > 0)
                sum += ef * max;

        }

        console.log(i, "-", sum," max=",max);

    }

    console.log("count",count);    

    if (count == n) {
        earning.sort();
        sum = earning[n-1] * ef;
    }

    return sum;

}

---

不幸的是，不同的日子不能单独考虑。举个例子，第一天劳动和食物都很贵，第二天很便宜。显然，你会在第一天工作，第二天吃饭

那么，我们如何解决这个问题呢？使用动态程序。每天，你必须做出两个选择：你工作多少和吃多少？在一天结束时，你有一些总收入和一定数量的精力。该能量量在0和最大能量之间只能有几个不同的值

让我们将这两个决定分开，并跟踪每个剩余能量级别的最大收益。让E_afterWorkday:i，energy:E为您在第i天工作后能获得的最大收入和剩余能量E。同样，E_afterEatday:i，energy:E是在第一天吃过东西后的最大收入。我们将在几天内跟踪这些值。最后，我们对E_afterWorkday:totalDays-1，energy:0感兴趣。这是我们留下的钱的数量

对于第一天，我们可以立即将E_afterWork设置为：

我们对所有能级都这样做

然后，我们必须逐步更新E_afterEat和E_afterWork。这些是：

E_afterEat(day: i, energy: e) = maximum over possible previous energy pe (E_afterWork(day: i, energy: pe) - cost[i] * (e - pe))

我们必须检查所有小于或等于e的pe值，以及我们能负担得起食物的地方，即结果为正值。后者应自动完成，无需做任何特殊操作

我们在这里干什么？我们在下班后检查当天所有可能的结果，并尝试吃不同量的食物。我们通过将收入计算为完成工作后的收入减去食品成本，从而节省了给我们带来最大收入的选择

现在，如何在下班后更新E_？这其实很简单：

E_afterWork(day: i, energy: e) = maximum over possible previous energy pe (E_afterEat(day: i-1, energy: pe) + earning[i] * (pe - e))

我也有同样的想法

让我们举个例子：

earning=[7, 2, 4]
cost=[7, 3, 6]
maxEnergy=5

让我们初始化。我将用AW缩写E_afterWork，用AE缩写E_afterEat：

现在更新AE。对于第一个条目，我们将计算：

AE(0, 5) = max (0 - 0 * 7, 7 - 1 * 7, 14 - 2 * 7, 21 - 3 * 7, …) = 0

e | AW(0, e)  AE(0, e)
--+--------------------
5 |    0         0   
4 |    7         7
3 |   14        14
2 |   21        21
1 |   28        28
0 |   35        35

下一个工作日：

e | AW(0, e)  AE(0, e)  AW(1, e)
--+-----------------------------
5 |    0         0         0
4 |    7         7         7 = max(0 + 1 * 2, 7 + 0 * 2)
3 |   14        14        14 = max(0 + 2 * 2, 7 + 1 * 2, 14 + 0 * 2)
2 |   21        21        21
1 |   28        28        28
0 |   35        35        35

吃：

工作：

---

因此，第一天工作，第二天吃饭，最后一天再工作，你总共可以挣40英镑。

有什么问题吗？你具体在问什么？我需要一些关于如何解决编码难题的见解我看不出简单循环方法在这里不起作用的任何原因。每一天都是充满活力的新的一天，与前一天所做的任何选择无关。你介意向我推荐一本学习动态规划的好书或资源吗？不介意。我认为，最好的方法是尝试一些例子。检查标签。但是请注意，并非所有带有此标记的问题实际上都是动态编程问题。

AE(0, 5) = max (0 - 0 * 7, 7 - 1 * 7, 14 - 2 * 7, 21 - 3 * 7, …) = 0

e | AW(0, e)  AE(0, e)
--+--------------------
5 |    0         0   
4 |    7         7
3 |   14        14
2 |   21        21
1 |   28        28
0 |   35        35

e | AW(0, e)  AE(0, e)  AW(1, e)
--+-----------------------------
5 |    0         0         0
4 |    7         7         7 = max(0 + 1 * 2, 7 + 0 * 2)
3 |   14        14        14 = max(0 + 2 * 2, 7 + 1 * 2, 14 + 0 * 2)
2 |   21        21        21
1 |   28        28        28
0 |   35        35        35

e | AW(0, e)  AE(0, e)  AW(1, e)  AE(1, e)
--+---------------------------------------
5 |    0         0         0        20
4 |    7         7         7        23
3 |   14        14        14        26
2 |   21        21        21        29 = max(21 - 0 * 3, 28 - 1 * 3, 35 - 2 * 3)
1 |   28        28        28        32 = max(28 - 0 * 3, 35 - 1 * 3)
0 |   35        35        35        35

e | AW(0, e)  AE(0, e)  AW(1, e)  AE(1, e)  AW(2, e)
--+-------------------------------------------------
5 |    0         0         0        20       20
4 |    7         7         7        23       24 = max(20 + 1 * 4, 23 + 0 * 4)
3 |   14        14        14        26       28
2 |   21        21        21        29       32
1 |   28        28        28        32       36
0 |   35        35        35        35       40