总结-博奕类

There are n coins in a line. Two players take turns to take one or two coins from right side until there are no more coins left. The player who take the last coin wins.

Could you please decide the first play will win or lose?

Have you met this question in a real interview?

Yes

Example

n = 1, return true.

n = 2, return true.

n = 3, return false.

n = 4, return true.

n = 5, return true.

class Solution {
public:
    /**
     * @param n: An integer
     * @return: A boolean which equals to true if the first player will win
     */
    bool firstWillWin(int n) {
        // write your code here
        // return firstWillWin1(n);
        return firstWillWin2(n);
    }
    /* 分别对待第一个和第二个；dp[i] 为当前第i个硬币处时，第一个人赢的情况
     * 要保证i处赢，那么不管第二个人怎么取，都要硬才行！！！
     *
     * 当第一个人取一个时，不管第二个人取一个还是两个都要赢 dp[i - 2] && dp[i - 3]
     * 当第一个人取两个时，不管第二个人取一个还是两个都要赢 dp[i - 3] && dp[i - 4]
     *
     * 两个之间只要有一个满足，第一个人都赢了，因为第一个人肯定会选择利于自己的走法
     *
     * 理解的核心时倒着看，从后往前理解。比如取i个，要保证第一个人始终赢，就必须保证
     * 不管第二个人是取一个还是两个，第一个人都要赢，倒着看那么就是第二个人取两个
     * 那么剩下的i - 3第一个人必须赢，如果第二个取一个那么剩下的i - 2第一个人必须赢
     * 两者必须同时满足，所有有了dp[i - 2] && dp[i - 3]
     */
    bool firstWillWin1(int n) {
        if (n <= 0) {
            return false;
        }
        else if (n == 1 || n == 2) {
            return true;
        } else if (n == 3) {
            return false;
        } else if (n == 4) {
            return true;
        }
        vector<bool> dp(n + 1, false);
        dp[1] = true;
        dp[2] = true;
        dp[4] = true;
        for (int i = 5; i <= n; i++) {
            dp[i] = (dp[i - 2] && dp[i - 3]) || (dp[i - 3] && dp[i - 4]);
        }
        return dp[n];
    }
    /* 在i处要保证第一个人赢，那么第一个人会想方设法让第二个人输才行，走一个dp[i - 1]还是走两个
     * dp[i - 2]全看是不是可以让第二个人输掉也就是dp[i - 1]，dp[i - 2]中至少有一个输
     * dp[i] = !(dp[i - 1] && dp[i - 2])
     */
    bool firstWillWin2(int n) {
        if (n <= 0) {
            return false;
        }
        else if (n == 1 || n == 2) {
            return true;
        }

        vector<bool> dp(n + 1, false);
        dp[1] = true;
        dp[2] = true;
        for (int i = 3; i <= n; i++) {
            dp[i] = !(dp[i - 1] && dp[i - 2]);
        }
        return dp[n];
    }
};

http://blog.csdn.net/wutingyehe/article/details/46888919

Coins in a Line II

• Description
• Notes
• Testcase
• Judge

There are n coins with different value in a line. Two players take turns to take one or two coins from left side until there are no more coins left. The player who take the coins with the most value wins.

Could you please decide the first player will win or lose?

Have you met this question in a real interview?

Yes

Example

Given values array A = [1,2,2], return true.

Given A = [1,2,4], return false.

class Solution {
public:
    /*
     * @param values: a vector of integers
     * @return: a boolean which equals to true if the first player will win
     */
    bool firstWillWin(vector<int> &values) {
        // write your code here
        // return firstWillWin1(values);
        return firstWillWin2(values);
    }
    /* dp[i] 表示从i到end，第一个能取的最大值。理解上和第一题类似
     * min是因为对手永远只会让对手选最小的
     * max是本人永远会选择对自己最有利的
     * 结果是dp[0]是大于一半
     */
    bool firstWillWin1(vector<int> &values) {
        // write your code here
        if (values.size() <=2 ) {
            return true;
        }
        int n = values.size();
        vector<int> dp(n + 1, 0);
        dp[n - 1] = values[n - 1];
        dp[n - 2] = values[n - 1] + values[n - 2];
        dp[n - 3] = values[n - 3] + values[n - 2];
        for (int i = n - 4; i >= 0; i--) {
            int selectone = values[i] + min(dp[i + 2], dp[i + 3]);
            int selecttwo = values[i] + values[i + 1] + min(dp[i + 3], dp[i + 4]);
            dp[i] = max(selectone, selecttwo);
        }
        int sum = 0;
        for (int j = 0; j < values.size(); j++) {
            sum += values[j];
        }
        return dp[0] > sum - dp[0];
    }
    bool firstWillWin2(vector<int> &values) {
        // write your code here
        if (values.size() <=2 ) {
            return true;
        }
        int n = values.size();
        vector<int> prefixsum(n + 1, 0);
        for (int i = n - 1; i >= 0; i--) {
            prefixsum[i] = values[i] + prefixsum[i + 1];
        }
        vector<int> dp(n + 1, 0);
        dp[n - 1] = values[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            int selectone = values[i] + prefixsum[i + 1] - dp[i + 1];
            int selecttwo = values[i] + values[i + 1] + prefixsum[i + 2] - dp[i + 2];
            dp[i] = max(selectone, selecttwo);
        }
        return dp[0] > prefixsum[0] - dp[0];
    }
};

There are n coins in a line. Two players take turns to take a coin from one of the ends of the line until there are no more coins left. The player with the larger amount of money wins.

Could you please decide the first player will win or lose?

Example

Given array A = [3,2,2], return true.

Given array A = [1,2,4], return true.

Given array A = [1,20,4], return false.

Challenge

Follow Up Question:

If n is even. Is there any hacky algorithm that can decide whether first player will win or lose in O(1) memory and O(n) time?

点题1：dp题，主要是要推导出公式：
dp[i][j]=max(A[i]+sum[i+1][j]-dp[i+1][j], A[j]+sum[i][j-1]-dp[i][j-1])
A[i]+sum[i+1][j] 和 A[j]+sum[i][j-1]都等于sum[i][j],因此最后公式成为：
dp[i][j]=sum[i][j]-min(dp[i+1][j],dp[i][j-1])

比较特别的dp题。game theory

public class Solution {
    public boolean firstWillWin(int[] values) {
        int len = values.length;
        if (len <= 1) {
            return true;
        }
        int[][] store = new int[len][len];
        int[][] sum = new int[len][len];
        for (int i = 0; i < len; i++) {
            for (int j = i; j < len; j++) {
                sum[i][j] = i == j ? values[j] : sum[i][j-1] + values[j];
            }
        }
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j < len; j++) {
                if (i == j) {
                    store[i][j] = values[i];
                } else {
                    int cur = Math.min(store[i+1][j], store[i][j-1]);
                    store[i][j] = sum[i][j] - cur;
                }
            }
        }
        return store[0][len - 1] > sum[0][len-1] - store[0][len - 1];
    }
}

点题2：dp[left][right]表示从left到right所能取到的最大值，因为双方都取最优策略，所以取完一个后，对手有两种选择，我们要加让对手得到更多value的那种方案，也就是自己得到更少value的方案

class Solution {
public:
    /**
     * @param values: a vector of integers
     * @return: a boolean which equals to true if the first player will win
     */
    bool firstWillWin(vector<int> &values) {
        // write your code here
        int n = values.size();
        vector<vector<int>> dp(n + 1, vector<int>(n + 1, -1));
        int sum = 0;
        for (auto v : values) sum += v;
        return sum < 2 * dfs(dp, values, 0, n - 1);
    }
    int dfs(vector<vector<int>> &dp, vector<int> &values, int left, int right) {
        if (dp[left][right] != -1) return dp[left][right];
        if (left == right) {
            dp[left][right] = values[left];
        } else if (left > right) {
            dp[left][right] = 0;
        } else {
            int take_left = min(dfs(dp, values, left + 2, right), dfs(dp, values, left + 1, right - 1)) + values[left];
            int take_right = min(dfs(dp, values, left, right - 2), dfs(dp, values, left + 1, right - 1)) + values[right];
            dp[left][right] = max(take_left, take_right);
        }
        return dp[left][right];
    }
};

这个一看感觉就是动态规划，但是状态确实有点难表示，可以用dp[i][j]表示从i到j这一段，先手的最大值和后手的最大值，用一个pair<int,int>保存，如果已知dp[i+1][j]和dp[i][j-1]，那么就可以枚举两端确定dp[i][j]

class Solution {
public:
    /**
     * @param values: a vector of integers
     * @return: a boolean which equals to true if the first player will win
     */
    bool firstWillWin(vector<int> &values) {
        // write your code here
        int n = values.size();
        vector<vector<pair<int,int> > > dp(n,vector<pair<int,int> >(n,make_pair(0,0)));
        for(int len=1;len<=n;len++)
        {
            for(int i=0;i+len<=n;i++)
            {
                int j = i+len-1;
                if(i==j)
                    dp[i][j] = make_pair(values[i],0);
                else
                {
                    pair<int,int> p1 = dp[i+1][j];
                    pair<int,int> p2 = dp[i][j-1];
                    if(p1.second+values[i]>p2.second+values[j])
                    {
                        dp[i][j] = make_pair(p1.second+values[i],p1.first);
                    }
                    else
                    {
                        dp[i][j] = make_pair(p2.second+values[j],p2.first);
                    }
                }
            }
        }
        if(dp[0][n-1].first>dp[0][n-1].second)
            return true;
        else
            return false;
    }
};