leetcode375

We are playing the Guess Game. The game is as follows:
I pick a number from 1 to n. You have to guess which number I picked.
Every time you guess wrong, I'll tell you whether the number I picked is higher or lower.
However, when you guess a particular number x, and you guess wrong, you pay $x. You win the game when you guess the number I picked.
Example:
n = 10, I pick 8.
First round: You guess 5, I tell you that it's higher. You pay $5.
Second round: You guess 7, I tell you that it's higher. You pay $7.
Third round: You guess 9, I tell you that it's lower. You pay $9.
Game over. 8 is the number I picked.
You end up paying $5 + $7 + $9 = $21.
Given a particular n ≥ 1, find out how much money you need to have to guarantee a win.

DP。
理解题意：要在最坏情况下求最优解。最坏情况指的是你不能控制的：也就是你每猜一个数字对方返回的答案将你转向不利于你的那一侧继续猜。最优解是你能控制的：也就是你要按照怎么样的策略猜数字，比如第一次给3第二次给8这样子的顺序从而能够在最坏情况下也损耗得最少。
本题最后求的cost和真实答案是什么无关，只与猜数字的范围有关。比如456猜数字，不管真实答案是什么，你走一步就要假设最坏情况（你没猜中而且真实答案在对你当前出招不利的一侧）。你猜4，就要假设没猜中对方叫你接着去56猜。

肉眼可见的例子：
长度为1: [5]: 不用猜就是它了，cost0。
长度为2: [5, 6]: 猜小一点的即5。因为这轮猜完不管猜中没都结束游戏了。cost5。
长度为3: [5, 6, 7]: 猜中间的。因为猜5的话，要假设最坏情况也就是没猜中，你还得在[6, 7]再猜，所以最后cost11。猜7不好同理。猜中间的最好。cost6。
长度为4: [5, 6, 7, 8]: 和后面的都是general case了，一点点分割试试，比如猜5是分为[]和[678]，猜6是分为[5]和[78]，猜7是分为[56]和[8]，猜8是分为[567]和[]。当然要选最小的也就是最优的。程序来算。

DP算法：
定义：dp[i][j]为对数字从i～j的范围内猜，最少的消耗是多少。
初始化：设置所有长度为2的区间，dp答案为小的那个数字。（长度为1的答案是0数组已经自动设好了，长度为3的包括在下面general的转移方程里了）
状态转移方程：dp[i][j] = min(k + max(dp[i][k - 1], dp[k + 1][j]))，参数k满足条件属于(i, j)开区间
扫描方式：如果是按[i,j]区间扫的话，外层扫j++，从左到右[3,n]；内层扫i--，从右到左[j-2, 1]。

细节：
1.扫描方式里ij一定要方向相反，一般区间型dp要这样，这样才能每次大循环能让区间从小区间变成大区间。因为大区间依赖小区间，你每换一个新的末尾点j，都要让i移动方式是使得[i,j]慢慢扩大的，所以要先紧贴后远离。更具体的例子是比如第一次外循环得到[1, 3]，第二次外循环你不能也正序直接求[1,4]啊，[1,4]依赖[1,3]和[2,4]，你[2,4]还没求呢。正确的是从[2,4]求起。所以所有内循环的范围要从小到大，先贴近外层j再远离。
2.状态转移方程里等式右边依赖的子dp一定要把k都隔绝出去。因为guess(k)后要是猜中你就溜了，没猜中你也肯定不会再考虑k啊。

我的实现：

    class Solution {
        public int getMoneyAmount(int n) {
            int[][] dp = new int[n + 1][n + 1];
            for (int i = 1; i < n; i++) {
                dp[i][i + 1] = i;
            }
            
            for (int j = 3; j <= n; j++) {
                for (int i = j - 2; i >= 1; i--) {
                    dp[i][j] = Integer.MAX_VALUE;
                    for (int k = i + 1; k < j; k++) {
                        // P1： 转移后的子dp一定要把k都隔绝出去。因为guess(k)后要是猜中你就溜了，没猜中你也肯定不会再考虑k啊。
                        dp[i][j] = Math.min(dp[i][j], k + Math.max(dp[i][k - 1], dp[k + 1][j]));
                    }
                }
            }
            return dp[1][n];
        }
    }