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
5
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
6
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
}