Array
Math
Dynamic Programming
Game Theory
Description
Alice and Bob play a game with piles of stones. There are an even number of piles arranged in a row, and each pile has a positive integer number of stones piles[i]
.
The objective of the game is to end with the most stones. The total number of stones across all the piles is odd , so there are no ties.
Alice and Bob take turns, with Alice starting first . Each turn, a player takes the entire pile of stones either from the beginning or from the end of the row. This continues until there are no more piles left, at which point the person with the most stones wins .
Assuming Alice and Bob play optimally, return true
if Alice wins the game, or false
if Bob wins .
Example 1:
Input: piles = [5,3,4,5]
Output: true
Explanation:
Alice starts first, and can only take the first 5 or the last 5.
Say she takes the first 5, so that the row becomes [3, 4, 5].
If Bob takes 3, then the board is [4, 5], and Alice takes 5 to win with 10 points.
If Bob takes the last 5, then the board is [3, 4], and Alice takes 4 to win with 9 points.
This demonstrated that taking the first 5 was a winning move for Alice, so we return true.
Example 2:
Input: piles = [3,7,2,3]
Output: true
Constraints:
2 <= piles.length <= 500
piles.length
is even .
1 <= piles[i] <= 500
sum(piles[i])
is odd .
Solutions
Solution 1
Python3 Java C++ Go TypeScript
class Solution :
def stoneGame ( self , piles : List [ int ]) -> bool :
@cache
def dfs ( i : int , j : int ) -> int :
if i > j :
return 0
return max ( piles [ i ] - dfs ( i + 1 , j ), piles [ j ] - dfs ( i , j - 1 ))
return dfs ( 0 , len ( piles ) - 1 ) > 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 class Solution {
private int [] piles ;
private int [][] f ;
public boolean stoneGame ( int [] piles ) {
this . piles = piles ;
int n = piles . length ;
f = new int [ n ][ n ] ;
return dfs ( 0 , n - 1 ) > 0 ;
}
private int dfs ( int i , int j ) {
if ( i > j ) {
return 0 ;
}
if ( f [ i ][ j ] != 0 ) {
return f [ i ][ j ] ;
}
return f [ i ][ j ] = Math . max ( piles [ i ] - dfs ( i + 1 , j ), piles [ j ] - dfs ( i , j - 1 ));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 class Solution {
public :
bool stoneGame ( vector < int >& piles ) {
int n = piles . size ();
int f [ n ][ n ];
memset ( f , 0 , sizeof ( f ));
auto dfs = [ & ]( auto && dfs , int i , int j ) -> int {
if ( i > j ) {
return 0 ;
}
if ( f [ i ][ j ]) {
return f [ i ][ j ];
}
return f [ i ][ j ] = max ( piles [ i ] - dfs ( dfs , i + 1 , j ), piles [ j ] - dfs ( dfs , i , j - 1 ));
};
return dfs ( dfs , 0 , n - 1 ) > 0 ;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 func stoneGame ( piles [] int ) bool {
n := len ( piles )
f := make ([][] int , n )
for i := range f {
f [ i ] = make ([] int , n )
}
var dfs func ( i , j int ) int
dfs = func ( i , j int ) int {
if i > j {
return 0
}
if f [ i ][ j ] == 0 {
f [ i ][ j ] = max ( piles [ i ] - dfs ( i + 1 , j ), piles [ j ] - dfs ( i , j - 1 ))
}
return f [ i ][ j ]
}
return dfs ( 0 , n - 1 ) > 0
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14 function stoneGame ( piles : number []) : boolean {
const n = piles . length ;
const f : number [][] = new Array ( n ). fill ( 0 ). map (() => new Array ( n ). fill ( 0 ));
const dfs = ( i : number , j : number ) : number => {
if ( i > j ) {
return 0 ;
}
if ( f [ i ][ j ] === 0 ) {
f [ i ][ j ] = Math . max ( piles [ i ] - dfs ( i + 1 , j ), piles [ j ] - dfs ( i , j - 1 ));
}
return f [ i ][ j ];
};
return dfs ( 0 , n - 1 ) > 0 ;
}
Solution 2
Python3 Java C++ Go TypeScript
class Solution :
def stoneGame ( self , piles : List [ int ]) -> bool :
n = len ( piles )
f = [[ 0 ] * n for _ in range ( n )]
for i , x in enumerate ( piles ):
f [ i ][ i ] = x
for i in range ( n - 2 , - 1 , - 1 ):
for j in range ( i + 1 , n ):
f [ i ][ j ] = max ( piles [ i ] - f [ i + 1 ][ j ], piles [ j ] - f [ i ][ j - 1 ])
return f [ 0 ][ n - 1 ] > 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 class Solution {
public boolean stoneGame ( int [] piles ) {
int n = piles . length ;
int [][] f = new int [ n ][ n ] ;
for ( int i = 0 ; i < n ; ++ i ) {
f [ i ][ i ] = piles [ i ] ;
}
for ( int i = n - 2 ; i >= 0 ; -- i ) {
for ( int j = i + 1 ; j < n ; ++ j ) {
f [ i ][ j ] = Math . max ( piles [ i ] - f [ i + 1 ][ j ] , piles [ j ] - f [ i ][ j - 1 ] );
}
}
return f [ 0 ][ n - 1 ] > 0 ;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 class Solution {
public :
bool stoneGame ( vector < int >& piles ) {
int n = piles . size ();
int f [ n ][ n ];
memset ( f , 0 , sizeof ( f ));
for ( int i = 0 ; i < n ; ++ i ) {
f [ i ][ i ] = piles [ i ];
}
for ( int i = n - 2 ; ~ i ; -- i ) {
for ( int j = i + 1 ; j < n ; ++ j ) {
f [ i ][ j ] = max ( piles [ i ] - f [ i + 1 ][ j ], piles [ j ] - f [ i ][ j - 1 ]);
}
}
return f [ 0 ][ n - 1 ] > 0 ;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14 func stoneGame ( piles [] int ) bool {
n := len ( piles )
f := make ([][] int , n )
for i , x := range piles {
f [ i ] = make ([] int , n )
f [ i ][ i ] = x
}
for i := n - 2 ; i >= 0 ; i -- {
for j := i + 1 ; j < n ; j ++ {
f [ i ][ j ] = max ( piles [ i ] - f [ i + 1 ][ j ], piles [ j ] - f [ i ][ j - 1 ])
}
}
return f [ 0 ][ n - 1 ] > 0
}
1
2
3
4
5
6
7
8
9
10
11
12
13 function stoneGame ( piles : number []) : boolean {
const n = piles . length ;
const f : number [][] = new Array ( n ). fill ( 0 ). map (() => new Array ( n ). fill ( 0 ));
for ( let i = 0 ; i < n ; ++ i ) {
f [ i ][ i ] = piles [ i ];
}
for ( let i = n - 2 ; i >= 0 ; -- i ) {
for ( let j = i + 1 ; j < n ; ++ j ) {
f [ i ][ j ] = Math . max ( piles [ i ] - f [ i + 1 ][ j ], piles [ j ] - f [ i ][ j - 1 ]);
}
}
return f [ 0 ][ n - 1 ] > 0 ;
}