2018-10-03 19:29:43

問題描述：

問題求解：

很有意思的題目，首先想到的是暴力遍歷解空間，當然也用到了memo，可惜還是TLE，因為時間復雜度確實有點過高了，應該是O(n!)。

    Map<LinkedList, Integer> map = new HashMap<>();
    public int maxCoins(int[] nums) {
        if (nums.length == 0) return 0;
        LinkedList<Integer> list = new LinkedList<>();
        for (int i : nums) list.add(i);
        return helper(list);
    }

    private int helper(LinkedList<Integer> list) {
        if (list.size() == 1) return list.get(0);
        if (map.containsKey(list)) return map.get(list);
        int res = 1;
        ArrayList<Integer> arr = new ArrayList<>(list);
        for (int i = 0; i < list.size(); i++) {
            int pre = i == 0 ? 1 : arr.get(i - 1);
            int cur = arr.get(i);
            int next = i == arr.size() - 1 ? 1 : arr.get(i + 1);
            list.remove(i);
            res = Math.max(res, pre * cur * next + helper(list));
            list.add(i, cur);
        }
        map.put(list, res);
        return res;
    }

本題給出了數據規模，基本已經提示了時間復雜度為O(n^3)左右比較合適。下面給出本題的標準解法，使用的是動態規劃算法。

dp[i][j]：nums[i]到nums[j]能獲得的最高分數

dp[i][j] = max(dp[i][k - 1] + nums[i - 1] * nums[k] * nums[j + 1] + dp[k + 1][j]) i <= k <= j // 每次挑選一個最後打爆的氣球可以將問題規模下降

給原問題加上padding可以更方便編程。

    public int maxCoins(int[] nums) {
        if (nums.length == 0) return 0;
        int n = nums.length;
        int[] numsPadding = new int[n + 2];
        numsPadding[0] = 1;
        numsPadding[n + 1] = 1;
        for (int i = 1; i <= n; i++) numsPadding[i] = nums[i - 1];
        int[][] dp = new int[n + 2][n + 2];
        for (int len = 1; len <= n; len++) {
            for (int i = 1; i <= n - len + 1; i++) {
                int j = i + len - 1;
                for (int k = i; k <= j; k++) {
                    dp[i][j] = Math.max(dp[i][j], dp[i][k - 1] + numsPadding[i - 1] * numsPadding[k] * numsPadding[j + 1] + dp[k + 1][j]);
                }
            }
        }
        return dp[1][n];
    }

動態規劃-擊爆氣球 Burst Balloons