For every two consecutive 0‘s, merge all the nodes lying in between them into a single node whose value is the sum of all the merged nodes. The modified list should not contain any 0‘s.

Return the head of the modified linked list.

Example 1:

Input: head = [0,3,1,0,4,5,2,0]
Output: [4,11]
Explanation: 
The above figure represents the given linked list. The modified list contains
- The sum of the nodes marked in green: 3 + 1 = 4.
- The sum of the nodes marked in red: 4 + 5 + 2 = 11.

Example 2:

Input: head = [0,1,0,3,0,2,2,0]
Output: [1,3,4]
Explanation: 
The above figure represents the given linked list. The modified list contains
- The sum of the nodes marked in green: 1 = 1.
- The sum of the nodes marked in red: 3 = 3.
- The sum of the nodes marked in yellow: 2 + 2 = 4.

Constraints:

• The number of nodes in the list is in the range [3, 2 * 105].
• 0 <= Node.val <= 1000
• There are no two consecutive nodes with Node.val == 0.
• The beginning and end of the linked list have Node.val == 0.

Solution: List

Skip the first zero, replace every zero node with the sum of values of its previous nodes.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  ListNode* mergeNodes(ListNode* head) {
    ListNode dummy;    
    head = head->next;
    for (ListNode* prev = &dummy; head; head = head->next) {
      int sum = 0;
      while (head->val != 0) {
        sum += head->val;
        head = head->next;
      }
      prev->next = head;
      head->val = sum;
      prev = head;      
    }
    return dummy.next;
  }
};

The post 花花酱 LeetCode 2181. Merge Nodes in Between Zeros appeared first on Huahua's Tech Road.

In a N x N grid composed of 1 x 1 squares, each 1 x 1 square consists of a /, \, or blank space.  These characters divide the square into contiguous regions.

(Note that backslash characters are escaped, so a \ is represented as "\\".)

Return the number of regions.

Example 1:

Input:[  " /",  "/ "]
Output: 2
Explanation: The 2x2 grid is as follows:

Example 2:

Input:[  " /",  "  "]
Output: 1
Explanation: The 2x2 grid is as follows:

Example 3:

Input:[  "\\/",  "/\\"]
Output: 4
Explanation: (Recall that because \ characters are escaped, "\\/" refers to \/, and "/\\" refers to /\.)The 2x2 grid is as follows:

Example 4:

Input:[  "/\\",  "\\/"]
Output: 5
Explanation: (Recall that because \ characters are escaped, "/\\" refers to /\, and "\\/" refers to \/.)The 2x2 grid is as follows:

Example 5:

Input:[  "//",  "/ "]
Output: 3
Explanation: The 2x2 grid is as follows:

Note:

1. 1 <= grid.length == grid[0].length <= 30
2. grid[i][j] is either '/', '\', or ' '.

Solution 1: Split grid into 4 triangles and Union Find Faces

Divide each grid into 4 triangles and union them if not split.
Time complexity: O(n^2*alphn(n^2))
Space complexity: O(n^2)

class Solution {  
public:
  int regionsBySlashes(vector<string>& grid) {
    int n = grid.size();    
    DSU dsu(4 * n * n);
    for (int r = 0; r < n; ++r)
      for (int c = 0; c < n; ++c) {
        int index = 4 * (r * n + c);
        switch (grid[r][c]) {
          case '/':
            dsu.merge(index + 0, index + 3);
            dsu.merge(index + 1, index + 2);
            break;
          case '\\':
            dsu.merge(index + 0, index + 1);
            dsu.merge(index + 2, index + 3);
            break;
          case ' ':
            dsu.merge(index + 0, index + 1);
            dsu.merge(index + 1, index + 2);
            dsu.merge(index + 2, index + 3);
            break;
          default: break;
        }
        if (r + 1 < n)
          dsu.merge(index + 2, index + 4 * n + 0);
        if (c + 1 < n)
          dsu.merge(index + 1, index + 4 + 3);
      }
    int ans = 0;
    for (int i = 0; i < 4 * n * n; ++i)
      if (dsu.find(i) == i) ++ans;
    return ans;
  }
private:
  class DSU {
    public:
      DSU(int n): parent_(n) {
        for (int i = 0; i < n; ++i)
          parent_[i] = i;
      }
      
      int find(int x) {
        if (parent_[x] != x) parent_[x] = find(parent_[x]);
        return parent_[x];
      }
      
      void merge(int x, int y) {
        parent_[find(x)] = find(y);
      }
    private:
      vector<int> parent_;
  };
};

Solution 2: Euler’s Formula / Union-Find vertices

class Solution {  
public:
  int regionsBySlashes(vector<string>& grid) {
    int n = grid.size();
    p_ = vector<int>((n + 1) * (n + 1));     
    // All vertices on the boundaries are merged into root(0).    
    for (int r = 0; r < n + 1; ++r)
      for (int c = 0; c < n + 1; ++c)
        p_[getIndex(n, r, c)] = (r == 0 || r == n || c == 0 || c == n) ? 0 : getIndex(n, r, c);
    
    int f = 1;    
    for (int r = 0; r < n; ++r)
      for (int c = 0; c < n; ++c) {
        if (grid[r][c] == ' ') continue;
        // A new face will created if two vertices are already in the same group.        
        if (grid[r][c] == '/') {
          f += merge(getIndex(n, r, c + 1),
                     getIndex(n, r + 1, c));
        } else {
          f += merge(getIndex(n, r, c),
                     getIndex(n, r + 1, c + 1));
        }
      }    
    return f;
  }
private:
  vector<int> p_;  
  
  int getIndex(int n, int r, int c) { return r * (n + 1) + c; }  
      
  int find(int x) {
    if (p_[x] != x) p_[x] = find(p_[x]);
      return p_[x];
  }
  
  int merge(int x, int y) {
    int rx = find(x);
    int ry = find(y);
    if (rx == ry) return 1;
    p_[ry] = rx;
    return 0;
  }
};

Solution 3: Pixelation (Upscale 3 times)

Time complexity: O(n^2)
Space complexity: O(n^2)

// Author: Huahua, running time: 20 ms
class Solution {
public:
  int regionsBySlashes(vector<string>& grid) {
    const int n = grid.size();
    vector<vector<int>> g(n * 3, vector<int>(n * 3));
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j) {
        if (grid[i][j] == '/') {
          g[i * 3 + 0][j * 3 + 2] = 1;
          g[i * 3 + 1][j * 3 + 1] = 1;
          g[i * 3 + 2][j * 3 + 0] = 1;
        } else if (grid[i][j] == '\\') {
          g[i * 3 + 0][j * 3 + 0] = 1;
          g[i * 3 + 1][j * 3 + 1] = 1;
          g[i * 3 + 2][j * 3 + 2] = 1;
        }
      }
    int ans = 0;
    for (int i = 0; i < 3 * n; ++i)
      for (int j = 0; j < 3 * n; ++j) {
        if (g[i][j]) continue;
        visit(g, j, i, n * 3);
        ++ans;
      }
    return ans;
  }
private:
  void visit(vector<vector<int>>& g, int x, int y, int n) {
    if (x < 0 || x >= n || y < 0 || y >= n) return;
    if (g[y][x]) return;
    g[y][x] = 1;
    visit(g, x + 1, y, n);
    visit(g, x, y + 1, n);
    visit(g, x - 1, y, n);
    visit(g, x, y - 1, n);
  }
};

The post 花花酱 LeetCode 959. Regions Cut By Slashes appeared first on Huahua's Tech Road.

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

Solution 1: Brute Force

Time complexity: O(nk)

Space complexity: O(1)

// Author: Huahua, 420 ms
class Solution {
public:
  ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode dummy(0);
    ListNode *cur = &dummy;
    while (true) {
      ListNode** min_head = nullptr;
      for (auto& head : lists) {          
        if (!head) continue;        
        if (!min_head || head->val < (*min_head)->val)
          min_head = &head;
      }
      if (!min_head) break;
      cur->next = new ListNode((*min_head)->val);
      cur = cur->next;
      *min_head = (*min_head)->next;      
    }
    return dummy.next;
  }
};

Solution 2: Heap / Priority Queue

Time complexity: O(nlogk)

Space complexity: O(k)

// Author: Huahua, 16 ms (<99.88%)
class Solution {
public:
  ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode dummy(0);
    ListNode *cur = &dummy;
    
    auto comp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
    priority_queue<ListNode*, vector<ListNode*>, decltype(comp)> q(comp);
    
    for (ListNode* list : lists) 
      if (list) q.push(list);
    
    while (!q.empty()) {
      cur->next = q.top(); q.pop();      
      cur = cur->next;
      if (cur->next) q.push(cur->next);
    }
    return dummy.next;
  }
};

The post 花花酱 LeetCode 23. Merge k Sorted Lists appeared first on Huahua's Tech Road.

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:

• The number of elements initialized in nums1 and nums2 are m and n respectively.
• You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.

Example:

Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

Output: [1,2,2,3,5,6]

Solution:

Fill nums1 from back to front

Time complexity: O(m + n)

Space complexity: O(1) in-place

// Author: Huahua
class Solution {
public:
  void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
    int i = m - 1;
    int j = n - 1;
    int tail = m + n - 1;
    while (j >= 0)
      nums1[tail--] = (i >= 0 && nums1[i] > nums2[j]) ? nums1[i--] : nums2[j--];    
  }
};

The post 花花酱 LeetCode 88. Merge Sorted Array appeared first on Huahua's Tech Road.

Problem

Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.

You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.

Example 1:

Input: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
Output: 
Merged tree:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   7

Note: The merging process must start from the root nodes of both trees.

Solution: Recursion

Reuse t1/t2

// Author: Huahua
// Running time: 52 ms
class Solution {
public:
  TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
    if (t1 == nullptr) return t2;
    if (t2 == nullptr) return t1;

    auto root = t1;
    root->val += t2->val;
    root->left = mergeTrees(t1->left, t2->left);
    root->right = mergeTrees(t1->right, t2->right);

    return root;
  }
};

Create a copy

// Author: Huahua
// Running time: 52 ms
class Solution {
public:
  TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
    if (t1 == nullptr) return copyTree(t2);
    if (t2 == nullptr) return copyTree(t1);

    TreeNode* root = new TreeNode(t1->val + t2->val);    
    root->left = mergeTrees(t1->left, t2->left);
    root->right = mergeTrees(t1->right, t2->right);

    return root;
  }
private:
  TreeNode* copyTree(TreeNode* root) {
    if (root == nullptr) return nullptr;
    TreeNode* r = new TreeNode(root->val);
    r->left = copyTree(root->left);
    r->right = copyTree(root->right);
    return r;
  }
};

The post 花花酱 LeetCode 617. Merge Two Binary Trees appeared first on Huahua's Tech Road.

Problem:

Solution:

C++

// Author: Huahua
// Runtime: 16 ms
class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        auto it = intervals.begin();
        while (it != intervals.end() && newInterval.start > it->start) ++it;
        intervals.insert(it, newInterval);
        
        // Merge intervals without sorting
        vector<Interval> ans;        
        for (const auto& interval : intervals) {
            if (ans.empty() || interval.start > ans.back().end) {
                ans.push_back(interval);
            } else {
                ans.back().end = max(ans.back().end, interval.end);
            }
        }
        
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 78 ms
"""
class Solution(object):
    def insert(self, intervals, newInterval):
        
        index = len(intervals)
        for i in range(len(intervals)):
            if newInterval.start < intervals[i].start:
                index = i
                break
        
        intervals.insert(index, newInterval)
        
        ans = []
        for interval in intervals:
            if not ans or interval.start > ans[-1].end:
                ans.append(interval)
            else:
                ans[-1].end = max(ans[-1].end, interval.end)
        return ans

Solution 2:

C++

// Author: Huahua
// Runtime: 13 ms
class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        vector<Interval> l;
        vector<Interval> r;
        int start = newInterval.start;
        int end = newInterval.end;
        for (const Interval& interval : intervals) {
            if (interval.end < start)
                l.push_back(interval);
            else if (interval.start > end)
                r.push_back(interval);
            else {
                start = min(start, interval.start);
                end = max(end, interval.end);
            }                
        }
        
        vector<Interval> ans(std::move(l));
        ans.emplace_back(start, end);
        ans.insert(ans.end(), r.begin(), r.end());
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 68 ms
"""
class Solution(object):
    def insert(self, intervals, newInterval):
        start, end = newInterval.start, newInterval.end
        l, r = [], []        
        for interval in intervals:
            if interval.end < start: l += interval, 
            elif interval.start > end: r += interval,
            else: 
                start = min(start, interval.start)
                end = max(end, interval.end)
        return l + [Interval(start, end)] + r

Related problems:

• [解题报告] LeetCode 56. Merge Intervals
• [解题报告] LeetCode 218. The Skyline Problem

The post 花花酱 LeetCode 57. Insert Interval appeared first on Huahua's Tech Road.

Problem:

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

Idea:

Sweep line

Solution:

C++

// Author: Huahua
// Runtime: 12 ms
class Solution {
public:
    vector<Interval> merge(vector<Interval>& intervals) {
        if (intervals.empty()) return {};
        
        std::sort(intervals.begin(), intervals.end(), 
                  [](const Interval& a, const Interval& b){
                        return a.start < b.start;
                    });
        
        vector<Interval> ans;        
        for (const auto& interval : intervals) {
            if (ans.empty() || interval.start > ans.back().end) {
                ans.push_back(interval);
            } else {
                ans.back().end = max(ans.back().end, interval.end);
            }
        }
        
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 69 ms
"""
class Solution(object):
    def merge(self, intervals):
        ans = []
        for interval in sorted(intervals, key=lambda x: x.start):
            if not ans or interval.start > ans[-1].end:
                ans.append(interval)
            else:
                ans[-1].end = max(ans[-1].end, interval.end)
        return ans

Related Problems:

• [解题报告] LeetCode 57. Insert Interval
• [解题报告] LeetCode 218. The Skyline Problem

The post 花花酱 LeetCode 56. Merge Intervals appeared first on Huahua's Tech Road.

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Solution 1: Iterative O(n)

// Author: Huahua
class Solution {
public:
    Solution 1: Iterative
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode dummy(0);
        ListNode* tail=&dummy;
        while(l1 && l2) {
            if(l1->val < l2->val) {
                tail->next=l1;
                l1=l1->next;
            }else{
                tail->next=l2;
                l2=l2->next;
            }
            tail=tail->next;
        }
        
        if(l1) tail->next = l1;
        if(l2) tail->next = l2;
        
        return dummy.next;
        
    }
};

Solution 2: Recursive O(n)

// Author: Huahua
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // If one of the list is emptry, return the other one.
        if(!l1 || !l2) return l1 ? l1 : l2;
        // The smaller one becomes the head.
        if(l1->val < l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        } else {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
};

The post 花花酱 LeetCode 21: Merge Two Sorted Lists appeared first on Huahua's Tech Road.