使用動態規划解決問題

Question

我在接受采訪時被問到以下問題。

給定一排房子，每個房子都有能量和硬幣。 在能量不變為負值的情況下可以收集的最大硬幣是多少？ 從一所房子到另一所房子的能量是 1，房子不能跳過。

例如，EnergyArray = {1, 5, 3, 3, 1} 和 CoinsArray = {3, 23, 9, 2, 2} 初始能量為 1，則輸出應為 32，因為從房子 1 獲取 1 能量加上當前的能量，所以總能量 = 2 並旅行到第二宮（能量-1 = 1）拿硬幣，所以硬幣 = 23，旅行到下一個房子（能量-1 = 0）拿硬幣，所以總共 32。

同樣，對於energyArray = {2, 1, 1} 和coinsArray = {11, 5, 7} 和初始能量= 0，輸出應該是12。

我寫的程序就像

public class HouseEnergyCoin {
    /*static int[] energyA = {1,5,3,3,1};
    static int[] coins = {3,23,9,2,2};
    static int initialEnergy = 1;*/
    static int[] energyA = {2,1,1};
    static int[] coins = {11,5,7};
    static int initialEnergy = 0;


    public static void main(String[] args) {

        int energySum = initialEnergy;
        for (int i=0; i< energyA.length;i++){
            energySum+=energyA[i];
        }
        int[][] mem = new int[coins.length+1][energySum];
        System.out.println(maxCoins(initialEnergy, 1, mem));
    }



    static int maxCoins(int energy, int index, int[][] mem) {
        if (energy < 0 || index > coins.length) {
            return 0;
        }
        if (mem[index][energy] != 0){
            return mem[index][energy];
        }
        else {
            int result = max(maxCoins(energy+energyA[index-1]-1,index+1, mem),
                    coins[index-1]+maxCoins(energy-1, index+1, mem));
            mem[index][energy] = result;
            return result;
        }
    }


    static int max(int a, int b) { return (a > b)? a : b; }
}

這適用於某些情況，而對於其他情況則超時，有人可以幫我提供更好的解決方案嗎？

Answer 1

一些可能對您有幫助的提示：

• 所需能量的上限是energyA.length ，所以int[][] mem = new int[coins.length+1][energyA.length]; 足夠。
• 如果coins = [0, 0, 0, 0, 0, 0 .... 0] ，您的解決方案將是O(2 ^ coins.lenght) 。 您需要一個更好的機制來決定您是否在mem有一些解決方案。
• 您可以使用“自下而上”方法將遞歸“自上而下”解決方案轉換為 for 循環。
• 如果energy > coins.lenght - index ，你可以貪婪地獲取硬幣而不需要能量。

我的解決方案memory: O(N) ， time: O(N^2) ：

int UNREACHABLE = -1;

Arrays.fill(sum, UNREACHABLE);
sum[Math.min(initialEnergy + energyA[0], coins.length)] = 0;
sum[Math.min(initialEnergy, coins.length)] = coins[0];

for (int i = 1; i < coins.length; i++) {
    Arrays.fill(newSum, UNREACHABLE);

    for (int energy = 1; energy < coins.length; energy++) {
        if (sum[energy] == UNREACHABLE) {
            continue;
        }

        int newCoins = sum[energy] + coins[i];
        newSum[energy - 1] = Math.max(newCoins, newSum[energy - 1]);

        int newEnergy = Math.min(energy - 1 + energyA[i], coins.length);
        newSum[newEnergy] = Math.max(sum[energy], newSum[newEnergy]);
    }

    int[] temp = sum;
    sum = newSum;
    newSum = temp;
}

int result = Collections.max(Arrays.asList(sum));;
System.out.println(result);