zoukankan      html  css  js  c++  java
  • sicily 1176. Two Ends (Top-down 动态规划+记忆化搜索 v.s. Bottom-up 动态规划)

    Description

    In the two-player game "Two Ends", an even number of cards is laid out in a row. On each card, face up, is written a positive integer. Players take turns removing a card from either end of the row and placing the card in their pile. The player whose cards add up to the highest number wins the game. Now one strategy is to simply pick the card at the end that is the largest -- we'll call this the greedy strategy. However, this is not always optimal, as the following example shows: (The first player would win if she would first pick the 3 instead of the 4.)
    3 2 10 4
    You are to determine exactly how bad the greedy strategy is for different games when the second player uses it but the first player is free to use any strategy she wishes.

    Input

    There will be multiple test cases. Each test case will be contained on one line. Each line will start with an even integer n followed by n positive integers. A value of n = 0 indicates end of input. You may assume that n is no more than 1000. Furthermore, you may assume that the sum of the numbers in the list does not exceed 1,000,000.

    Output

    For each test case you should print one line of output of the form:

      In game m, the greedy strategy might lose by as many as p points.

    where m is the number of the game (starting at game 1) and p is the maximum possible difference between the first player's score and second player's score when the second player uses the greedy strategy. When employing the greedy strategy, always take the larger end. If there is a tie, remove the left end.

    题意:给定一个数列,两人轮流取数,只能从两端取,第一个取的人可以用任何策略,第二个贪心,问结束时第一个人会赢多少分。

    思路就是Top-Down的动态规划+记忆化搜索或者Bottom-Up的动态规划,,复杂度O(n2)。由于有比较多的判断就不写状态转移方程了,具体见代码和注释。

    Notes:

    Top-Down DP + Memorization 与 Bottom-Up DP 的区别

    两种写法:

    1. Top-Down:

    //#define JDEBUG
    
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    
    int cards[1001];
    int state[1001][1001];
    
    /**
     * Top-Down DP. Get the scores won by a in [l, r]
     *
     * @param l   start of the interval
     * @param r   end of the interval
     * @return  the scores won by a in [l, r]
     */
    int dp(int l, int r) {    
        // reach the end
        if (l > r)
            return 0;
        // one card
        if (l == r)
            return cards[l];
        // [Memoization] searched
        if (state[l][r] != -1)
            return state[l][r];
    
        int takeLeft = 0, takeRight = 0;
        
        // check what happens if a takes left
        // cards[r] > cards[l+1], so b would take right
        // narrowdown to [l+1, r-1]
        if (cards[r] > cards[l + 1]) {
            takeLeft = dp(l + 1, r - 1) + cards[l];
        } else {  // cards[r] <= cards[l+1], so b would take next left
        // narrow down to [l+2, r]
            takeLeft = dp(l + 2, r) + cards[l];
        }
    
        // check what happens if a takes right
        // cards[r-1] > cards[l], so b would take next right
        // narrow down to [l, r-2]
        if (cards[r - 1] > cards[l]) {
            takeRight = dp(l, r - 2) + cards[r];
        } else {  // cards[r-1] <= cards[l], so b would take left
        // narrow down to [l+1, r-1]
            takeRight = dp(l + 1, r - 1) + cards[r];
        }
    
        // return the best outcome
        return state[l][r] = (takeLeft > takeRight) ? takeLeft : takeRight;
    }
    
    int main(void) {
    #ifdef JDEBUG
        freopen("1176.in", "r", stdin);
        freopen("1176.out", "w", stdout);
    #endif
    
        int n = 0;
        int game = 1;
        while(scanf("%d", &n) && n != 0) {
            // initialization
            int sum = 0;
            memset(cards, -1, sizeof(cards));
            memset(state, -1, sizeof(state));
    
            for(int i = 0; i < n; i++) {
                scanf("%d", &cards[i]);
                sum += cards[i];
            }
    
            int scoreOfA = dp(0, n - 1);
            int scoreOfB = sum - scoreOfA;
            printf("In game %d, the greedy strategy might lose by as many as %d points.
    ",
                game++, scoreOfA - scoreOfB);
        }
    }

    2. Bottom-Up

    //#define JDEBUG
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    
    int cards[1001];
    int state[1001][1001];
    
    /**
     * Bottom up DP.
     *
     * @param  n number of cards
     * @return   score by which b will lose
     */
    int dp(int n) {
        // base case: in [i, i+1], a would take the larger one,
        // so b lose by abs(cards[i] - cards[i + 1])
        for (int i = 0; i < n - 1; i++) {
            state[i][i + 1] = abs(cards[i] - cards[i + 1]);
        }
    
        // dp starts from [l, l+3] since [l, l+1] is known
        // iterate: when [l, l+intvl] are left
        for (int intvl = 3; intvl < n; intvl++) {
            for (int l = 0; l < n - intvl; l++) {
                int r = l + intvl;
                int takeLeft = 0, takeRight = 0;
    
                // check what happens if a takes left
                // cards[r] > cards[l+1], so b would take right
                if (cards[r] > cards[l + 1]) {
                    takeLeft = state[l + 1][r - 1] + cards[l] - cards[r];
                } else {  // cards[r] <= cards[l+1], so b would take next left
                    takeLeft = state[l + 2][r] + cards[l] - cards[l + 1];
                }
    
                // check what happens if a takes right
                // cards[r-1] > cards[l], so b would take next right
                if (cards[r - 1] > cards[l]) {
                    takeRight = state[l][r - 2] + cards[r] - cards[r - 1];
                } else {  // cards[r-1] <= cards[l], so b would take left
                    takeRight = state[l + 1][r - 1] + cards[r] - cards[l];
                }
    
                // use the one with the best outcome
                state[l][r] = takeLeft > takeRight ? takeLeft : takeRight;
            }
        }
    
        return state[0][n - 1];
    }
    
    int main(void) {
    #ifdef JDEBUG
        freopen("1176.in", "r", stdin);
        freopen("1176.out", "w", stdout);
    #endif
        int n = 0;
        int game = 1;
    
        while (scanf("%d", &n) && n != 0) {
            // store the card numbers
            for (int i = 0; i < n; i++) {
                scanf("%d", &cards[i]);
            }
    
            memset(state, 0, sizeof(state));
            printf("In game %d, the greedy strategy might lose by as many as %d points.
    ",
                   game++, dp(n));
        }
    
        return 0;
    }
  • 相关阅读:
    表模块模式与事务脚本模式的代码编写
    解决方案下显示的网站名称被追加编号的问题解决方法
    应用层代码
    关于CodeReview(java)(转)
    关于事务的几个概念介绍(转)
    关于JVM的ClassLoader(转)
    svn相关
    .subversion
    linux用户与组的管理(命令加入、手动加入、加入组、用户之间的切换)
    回调函数
  • 原文地址:https://www.cnblogs.com/joyeecheung/p/3995682.html
Copyright © 2011-2022 走看看