leetcode contest 20

Q1: 520. Detect Capital

Given a word, you need to judge whether the usage of capitals in it is right or not.

We define the usage of capitals in a word to be right when one of the following cases holds:

1. All letters in this word are capitals, like "USA".
2. All letters in this word are not capitals, like "leetcode".
3. Only the first letter in this word is capital if it has more than one letter, like "Google".

Otherwise, we define that this word doesn't use capitals in a right way.

Solution one, it is clear to follow when you are reading the code(AC):

class Solution {
public:
    bool detectCapitalUse(string word) {
        if(word.empty()){
            return false;
        }
        if(word.size() == 1){
            return true;
        }
        char* cstr = new char[word.size() + 1];
        strcpy(cstr, word.c_str());
        // first capital
        if(cstr[0] >= 'A' && cstr[0] <= 'Z'){
            // second is capital
            if(cstr[1] >= 'A' && cstr[1] <= 'Z'){
                for(int i= 2; i < word.size(); i++){
                    if(cstr[i] < 'A' || cstr[i] > 'Z'){
                        return false;
                    }
                }
                return true;
            } else {
                // second is not capital
                for(int i= 2; i < word.size(); i++){
                    if(cstr[i] >= 'A' && cstr[i] <= 'Z'){
                        return false;
                    }
                }
                return true; 
            }
        } else {
            // first is not capital
            for(int i= 1; i < word.size(); i++){
                if(cstr[i] >= 'A' && cstr[i] <= 'Z'){
                    return false;
                }
            }
            return true; 
        }
    }
};

Another solution with std function is as follow, I prefer this solution as it is clear to understand.(AC)

class Solution {
public:
    bool detectCapitalUse(string word) {
        if(word.empty()){
            return false;
        }
        if(word.size() == 1){
            return true;
        }
        
        // first capital
        if(isupper(word[0])){
            // second is capital
            if(isupper(word[1])){
                for(string::size_type ix= 2; ix < word.size(); ix++){
                    if(!isupper(word[ix])){
                        return false;
                    }
                }
                return true;
            } else {
                // second is not capital
                for(string::size_type ix= 2; ix < word.size(); ix++){
                    if(isupper(word[ix])){
                        return false;
                    }
                }
                return true; 
            }
        } else {
            // first is not capital
            for(string::size_type ix= 1; ix < word.size(); ix++){
                if(isupper(word[ix])){
                    return false;
                }
            }
            return true; 
        }
    }
};

Q2: 525. Contiguous Array

Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1.

Example 1:

Input: [0,1]
Output: 2
Explanation: [0, 1] is the longest contiguous subarray with equal number of 0 and 1.

Example 2:

Input: [0,1,0]
Output: 2
Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.

Note: The length of the given binary array will not exceed 50,000.

Solution one: Dynamic programming(NOT AC, Time Limits Exceed)

I use dynamic programming to update the total number of 1 and 0 before current element(including itself). And loop from start position to current element to update the subarray, the time complexity is O(n*n), it is not smart solution since it takes much space and time. 

But it is just part of the problem, the key idea of this problem is to use hash table to find the previous index with the same difference between 1 and 0, and update the maximum length. I will give this as solution two. 

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        if(nums.size() < 2){
            return 0;
        }
        int size = nums.size();
        vector<int> zero_cnt(size, 0);
        vector<int> one_cnt(size, 0);
        vector<int> max_len(size, 0);
        
        max_len[0] = 0;
        if(nums[0] == 0){
            zero_cnt[0]++;
        } else {
            one_cnt[0]++;
        }
        for(int i = 1; i < nums.size(); i++){
            // state update
            if(nums[i] == 0){
                zero_cnt[i] = zero_cnt[i - 1] + 1;
                one_cnt[i] = one_cnt[i - 1];
            } else {
                zero_cnt[i] = zero_cnt[i - 1];
                one_cnt[i] = one_cnt[i - 1] + 1;
            }
            
            //update max length for each element
            if(zero_cnt[i] == one_cnt[i]){
                max_len[i] = i + 1;
            } else {
                for(int j = 0; j < i; j++){
                    if((zero_cnt[i] - zero_cnt[j]) == (one_cnt[i] - one_cnt[j])){
                         max_len[i] = max(max_len[i], i - j);
                    }
                }
            }
        }
        int max_sub_len = 0;
        for(int i = 0; i< max_len.size(); i++){
            max_sub_len = max(max_len[i], max_sub_len);
        }
        return max_sub_len;
    }
};

Solution two: Hash table and a sum variable(AC).

This is a smart solution, change 0 to -1, and keep a variable to record the sum of all element by current element.

if sum is 0

• update the max length is i + 1;

else: look up into the hash table

• if we already push current sum to hash table, max length update to max(max_len, i - has_table[i]).
• The reason is we have the same sum, that means all the number between these two indexs is zero, they contain the equal number of 1 and 0.
• else, put current sum to hash table, the key is sum, the value is index.
• return max length

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        unordered_map<int, int> diff;
        int cur_sum = 0;
        int max_len = 0;
        for(int i = 0; i < nums.size(); i++){
            cur_sum += (nums[i] == 0 ? -1 : 1);
            if(cur_sum == 0){
                max_len = i + 1;
            } else {
                if(diff.find(cur_sum) != diff.end()){
                    max_len = max(max_len, i - diff[cur_sum]);
                } else {
                    diff[cur_sum] = i;
                }
            }
        }
        return max_len;
    }
};