LeetCode Weekly Contest 8

LeetCode Weekly Contest 8

415. Add Strings

• User Accepted: 765
• User Tried: 822
• Total Accepted: 789
• Total Submissions: 1844
• Difficulty: Easy

Given two non-negative numbers num1 and num2 represented as string, return the sum of num1 and num2.

Note:

1. The length of both num1 and num2 is < 5100.
2. Both num1 and num2 contains only digits 0-9.
3. Both num1 and num2 does not contain any leading zero.
4. You must not use any built-in BigInteger library or convert the inputs to integer directly.

简单的模拟题。

class Solution {
public:
    string addStrings(string num1, string num2) {
        int len1 = num1.length(), len2 = num2.length();
        int t = 0, c = 0, i = len1-1, j = len2-1;
        string ret = "";
        while(i>=0 && j>=0){
            c = (t + (num1[i]-'0') + (num2[j]-'0'))%10;
            t = (t + (num1[i]-'0') + (num2[j]-'0'))/10;
            ret.insert(ret.begin(), char('0' + c));
            --i; --j;
        }
        while(i>=0){
            c = (t + (num1[i]-'0'))%10;
            t = (t + (num1[i]-'0'))/10;
            ret.insert(ret.begin(), char('0' + c));
            --i;
        }
        while(j>=0){
            c = (t +  (num2[j]-'0'))%10;
            t = (t +  (num2[j]-'0'))/10;
            ret.insert(ret.begin(), char('0' + c));
            --j;
        }
        if(t != 0){
            ret.insert(ret.begin(), char('0' + t));
        }
        return ret;
    }
};

　　

416. Partition Equal Subset Sum

• User Accepted: 488
• User Tried: 670
• Total Accepted: 506
• Total Submissions: 1689
• Difficulty: Medium

Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.

Note:
Both the array size and each of the array element will not exceed 100.

Example 1:

Input: [1, 5, 11, 5]

Output: true

Explanation: The array can be partitioned as [1, 5, 5] and [11].

Example 2:

Input: [1, 2, 3, 5]

Output: false

Explanation: The array cannot be partitioned into equal sum subsets.

简单的单重背包问题

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0, len = nums.size();
        for(int i=0; i<len; ++i){
            sum += nums[i];
        }
        if(sum%2 != 0){
            return false;
        }
        int* dp = new int[sum/2 + 1];
        for(int i=sum/2; i>=1; --i){
            dp[i] = 0;
        }
        dp[0] = 1;
        for(int i=0; i<len; ++i){
            for(int j=sum/2; j>=nums[i]; --j){
                if(dp[j-nums[i]]){
                    dp[j] = 1;
                }
            }
        }
        bool flag = (dp[sum/2]==1);
        delete[] dp;
        return flag;
    }
};

　　

417. Pacific Atlantic Water Flow

• User
  Accepted: 259
• User
  Tried: 403
• Total
  Accepted: 265
• Total
  Submissions: 1217
• Difficulty: Medium

Given an m x n matrix of non-negative integers representing the height of each unit cell
in a continent, the "Pacific ocean" touches the left and top edges of
the matrix and the "Atlantic ocean" touches the right and bottom
edges.

Water can only flow in four directions (up,
down, left, or right) from a cell to another one with height equal or lower.

Find the list of grid coordinates where
water can flow to both the Pacific and Atlantic ocean.

Note:

1. The order of returned grid coordinates does
   not matter.
2. Both m and n are less than 150.

Example:

Given the following 5x5 matrix:

Pacific ~   ~  
~   ~   ~

~  1  
2   2   3  (5)
*

~  3  
2   3  (4) (4) *

~  2  
4  (5)  3   1  *

~ (6) (7)  1  
4   5  *

~ (5)  1  
1   2   4  *

*   *  
*   *   * Atlantic

Return:

[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with
parentheses in above matrix).

双重bfs，
要注意不能重复采集到顶点。

class Solution {
public:
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    vector<pair<int, int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<pair<int,int>> ret;
        int m = matrix.size();
        if(m == 0){ return ret; }
        int n = matrix[0].size();
        if(n == 0){ return ret; } 

        vector<vector<int>> cnt(m, vector<int>(n, 0));
        vector<vector<int>> vis(m, vector<int>(n, 0));
        int tmp, cur_x, cur_y, tmp_x, tmp_y, i = 0, j = 0;
        queue<pair<int, int>> qt;
        for(int i=0; i<m; ++i){
            qt.push(make_pair(i, 0));
            cnt[i][0] += 1;
            vis[i][0] = 1;
        }
        for(int i=1; i<n; ++i){
            qt.push(make_pair(0, i));
            cnt[0][i] += 1;
            vis[0][i] = 1;
        }
        while(!qt.empty()){
            cur_x = qt.front().first;  cur_y = qt.front().second;
            tmp = matrix[cur_x][cur_y];
            qt.pop();
            for(int i=0; i<4; ++i){
                tmp_x = cur_x + dx[i]; tmp_y = cur_y + dy[i];
                if(tmp_x>=0 && tmp_x<m && tmp_y>=0 && tmp_y<n && !vis[tmp_x][tmp_y] && matrix[tmp_x][tmp_y]>=tmp){
                    qt.push(make_pair(tmp_x, tmp_y));
                    cnt[tmp_x][tmp_y] += 1;
                    vis[tmp_x][tmp_y] = 1;
                }
            }
        }
        for(int i=0; i<m; ++i){
            for(int j=0; j<n; ++j){
                vis[i][j] = 0;
            }
        }
        for(int i=0; i<m; ++i){
            qt.push(make_pair(i, n-1));
            cnt[i][n-1] += 1;
            vis[i][n-1] = 1;
        }
        for(int i=0; i<n-1; ++i){
            qt.push(make_pair(m-1, i));
            cnt[m-1][i] += 1;
            vis[m-1][i] = 1;
        }
        while(!qt.empty()){
            cur_x = qt.front().first;  cur_y = qt.front().second;
            tmp = matrix[cur_x][cur_y];
            qt.pop();
            for(int i=0; i<4; ++i){
                tmp_x = cur_x + dx[i]; tmp_y = cur_y + dy[i];
                if(tmp_x>=0 && tmp_x<m && tmp_y>=0 && tmp_y<n && !vis[tmp_x][tmp_y] && matrix[tmp_x][tmp_y]>=tmp){
                    qt.push(make_pair(tmp_x, tmp_y));
                    cnt[tmp_x][tmp_y] += 1;
                    vis[tmp_x][tmp_y] = 1;
                }
            }
        }
        for(int i=0; i<m; ++i){
            for(int j=0; j<n; ++j){
                if(cnt[i][j] == 2){
                    ret.push_back(make_pair(i, j));
                }
            }
        }
        return ret;
    }
};