Amazon Campus(2013-Sep-22)Question 2 / 2 (Amazon Campus（9）: MM-Chess)-优快云博客

本文介绍了一款名为MM-Chess的游戏，玩家需通过合理使用不同步数的卡片来获得最高分数。文章详细解释了游戏规则，并提供了一种递归算法求解最优解的方法，同时也提到了面对大数据量时该算法的局限性以及可以采用动态规划来优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Question 2 / 2 (Amazon Campus（9）: MM-Chess)

There is an interesting game called MM-Chess. The size of the board is 1*N, every grid has a score (non-negative). The first grid is the start and the Nth grid is the end. The game requires players to control the chess starting from the starting point to the end.

There're four types of cards in the game and the total number is M. Each type of card are labeled one integer number in [1,4]. After using a card with number x on it, the chess will move x steps forward. Each time, player will choose one unused card to move the chess forward, and each card can only be used once. In the game, the chess gains the score at the starting point automatically. When the chess arrives at a new grid, it also gets the score on that point. The goal of the game is to get the most score.

Input:

The first line contains two integers N (the size of board) and M (the number of the cards).

The second line contains N integers, meaning the scores on the the board (the i-th integer corresponds to the score on the i-th grid).

The third line contains M integers, meaning the numbers on the M cards.

The sum of the number of M cards equals to N-1.

You can assume that 1 <= N <= 350, 1 <= M <= 120, and that the number of cards are less than 40 for each kind.

Output:

One integer. The most score that player can get.

Sample Input 1

4 2

1 2 1 2

1 2

Sample Output 1

Given two cards with number 1 and number 2 each, we have two choices: path one is 1 -> 2 -> 2, path two is 1 -> 1 -> 2. The maximum score is 5, which is the output.

Sample Input 2

5 3

1 2 1 2 1

1 2 1

Sample Output 2

Given three cards (one can move 2 steps, two can move 1 steps), we have three choices: path one is 1 -> 2 -> 1 -> 1, path two is 1 -> 2 -> 2 -> 1, path three is 1 -> 1 -> 2 -> 1. The maximum score is 6, which is the output.

    static int MMchess(int[] Nscores, int[] Mnumbers) {
        // Nscores : the scores on the the board (the i-th integer corresponds to the score on the i-th grid) 
        // Mnumbers : the numbers on the M cards
        // return value : the most score that player can get
        if(Mnumbers.length == 0) return Nscores[0];
    	int max = 0;
    	for(int i=0; i<Mnumbers.length; i++) {
    		int score = Nscores[0];
    		int []tempNscores = new int[Nscores.length-Mnumbers[i]];
    		for(int j=Mnumbers[i],k=0; j<Nscores.length; j++) {
    			tempNscores[k] = Nscores[j];
    			k++;
    		}
    		int []tempMnumbers = new int[Mnumbers.length-1];
    		for(int j=0,k=0; j<Mnumbers.length; j++) {
    			if(j==i) continue;
    			tempMnumbers[k] = Mnumbers[j];
    			k++;
    			
    		}
    		score += MMchess(tempNscores, tempMnumbers);
    		
    		if(max < score) max = score;
    	}
    	return max;
    }

上述采用递归，大数据量时TLE。可采用动态规划：

dp[type1][type2][type3][type4]=
max{
dp[type1-1][type2][type3][type4]+sorce,
dp[type1][type2-1][type3][type4]+score,
dp[type1][type2][type3-1][type4]+score,
dp[type1][type2][type3][type4-1]+score
}