LeetCode 474.Ones and Zeroes & 486.Predict the Winner

Problem 474 Ones and Zeroes

In the computer world, use restricted resource you have to generate maximum benefit is what we always want to pursue.

For now, suppose you are a dominator of m 0s and n 1s respectively. On the other hand, there is an array with strings consisting of only 0s and 1s.

Now your task is to find the maximum number of strings that you can form with given m 0s and n 1s. Each 0 and 1 can be used at most once.

Note:

1. The given numbers of 0s and 1s will both not exceed 100
2. The size of given string array won't exceed 600.

Example 1:

Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
Output: 4

Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”

Example 2:

Input: Array = {"10", "0", "1"}, m = 1, n = 1
Output: 2

Explanation: You could form "10", but then you'd have nothing left. Better form "0" and "1".

解题思路：

1. 利用动态编程的思想，用dp[i][j]表示有i个0，j个1的时候，能组成的字符串的最大数量，对于字符串数组strs中的每一个字符串，我们都用一个数组count来记录它的0和1的个数，count[0]记录0的个数，count[1]记录1的个数

2. 对于每一个字符串，动态转移方程为：dp[i][j] = max{dp[i][j],dp[i - count[0]][j-count[1]]+1}，这样遍历所有字符串后，最后得到的dp[m][n]即为所求。

代码如下：

public class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int [m+1][n+1];
        for(String str: strs){
            int[] count = count(str);
            for(int i = m;i >= count[0];i--){
                for(int j = n;j >= count[1];j--){
                    dp[i][j] = Math.max(dp[i][j],dp[i - count[0]][j-count[1]]+1);
                }
            }
        }
        return dp[m][n];
        
    }
    
    
    public int[] count(String str){
        int[] res = new int[2];
        for(int i = 0;i < str.length();i++){
            res[str.charAt(i) - '0']++;
        }
        return res;
    }
}

Problem 486 Predict the Winner

Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.

Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.

Example 1:

Input: [1, 5, 2]
Output: False
Explanation: Initially, player 1 can choose between 1 and 2. 
If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2). 
So, final score of player 1 is 1 + 2 = 3, and player 2 is 5. 
Hence, player 1 will never be the winner and you need to return False.

Example 2:

Input: [1, 5, 233, 7]
Output: True
Explanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.

Note:

1. 1 <= length of the array <= 20.
2. Any scores in the given array are non-negative integers and will not exceed 10,000,000.
3. If the scores of both players are equal, then player 1 is still the winner.

解题思路：

1. 用sum(i,j)表示第i个数到第j个数的值的总和，dp[i][j]表示第i个到第j个数中，第一个玩家能够取到数的最大值

2. 玩家每一次可以有两个选择，从头取和从尾取，从头取的话，取得的总值为：Sh = sum(i+1,j) - dp[i+1][j] + nums[i]，从尾取的话，取得的总值为：St = sum(i,j-1) - dp[i][j-1] + nums[j]，因此 动态转移方程为：dp[i][j] = max{Sh,St}

3. 特殊情况，i = j时，dp[i][j] = nums[i]，j= i+1时，dp[i][j] = max{nums[i], nums[j]}

代码如下：

public class Solution {
    public boolean PredictTheWinner(int[] nums) {
        int[][] dp = new int[nums.length][nums.length];
        for(int i = 0;i < nums.length;i++){
            dp[i][i] = nums[i];
            if(i +1 < nums.length){
               dp[i][i+1] = Math.max(nums[i],nums[i+1]); 
            }
            
        }
        for(int i = nums.length-1;i >= 0;i-- ){
            
            for(int j = i +2;j < nums.length;j++){
               
                dp[i][j] = Math.max(sum(nums,i,j-1) - dp[i][j-1] + nums[j],sum(nums,i+1,j) - dp[i+1][j] + nums[i]);
                //ystem.out.println("dp["+i+"]["+j+"] = " + dp[i][j]);
                
                
            }
        }
        
        if(dp[0][nums.length-1] >= (double)sum(nums,0,nums.length - 1)/2){
            return true;
        }
        else{
            return false;
        }
        
    }
    
    public int sum(int[] nums,int i,int j){
        int res = 0;
        for(int k = i;k <= j;k++){
            res += nums[k];
        }
        return res;
    }
}