# Daily Coding Challenge #117

This is a series of Daily Coding Challenge. Each day I show a few solutions written in C++. The questions are from coding practice/contest sites such as HackerRank, LeetCode, Codeforces, Atcoder and etc.

``````/*
Sum of Root To Leaf Binary Numbers
https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/

Given a binary tree, each node has value 0 or 1.  Each root-to-leaf path represents a binary number starting with the most significant bit.  For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13.

For all leaves in the tree, consider the numbers represented by the path from the root to that leaf.

Return the sum of these numbers.

Example 1:

Input: [1,0,1,0,1,0,1]
Output: 22
Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22

Note:

The number of nodes in the tree is between 1 and 1000.
node.val is 0 or 1.
The answer will not exceed 2^31 - 1.
*/

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode() : val(0), left(nullptr), right(nullptr) {}
*     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
*     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int solve(TreeNode* node, int n){
if(!node) return 0;
n = (n<<1) | node->val;
if(!node->left&&!node->right) return n;
return solve(node->left, n) + solve(node->right, n);
}
int sumRootToLeaf(TreeNode* root) {
return solve(root, 0);
}
};
``````

``````/*
Largest-Island-Area
https://binarysearch.io/problems/Largest-Island-Area

You are given a two-dimensional integer matrix of 1s and 0s. A 1 represents land and 0 represents water, so an island is a group of 1s that are neighboring whose perimeter is surrounded by water. You can assume that the edges of the matrix are surrounded by water.

Return the area of the largest island in matrix.

Constraints

n, m ≤ 250 where n and m are the number of rows and columns in matrix
Example 1
Input

matrix = [
[0, 0, 0, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0]
]
Output

7
Explanation

The largest island in the center has an area of 7 units.
*/

#include "solution.hpp"
using namespace std;

class Solution {
public:
int dfs(vector<vector<int>>& matrix, int i, int j){
if(i<0||i>matrix.size()-1||j<0||j>matrix[0].size()-1||matrix[i][j]==0) return 0;
matrix[i][j]=0;
return 1 + dfs(matrix,i+1,j)+ dfs(matrix,i-1,j) + dfs(matrix,i,j+1) + dfs(matrix,i,j-1);
}
int solve(vector<vector<int>>& matrix) {
int ans=0;
for(int i=0;i<matrix.size();i++){
for(int j=0;j<matrix[i].size();j++){
if(matrix[i][j]==1){
ans=max(ans,dfs(matrix,i,j));
}
}
}
return ans;
}
};

``````

There are other programming solutions in the following repositories below. Star and watch for timely updates!

## wingkwong / competitive-programming

Posted on by:

### Wing-Kam

Consultant by day. Developer by night. AWS certified. Exploring #CloudNative currently.