• A land cell if grid[r][c] = 0, or
• A water cell containing grid[r][c] fish, if grid[r][c] > 0.

A fisher can start at any water cell (r, c) and can do the following operations any number of times:

• Catch all the fish at cell (r, c), or
• Move to any adjacent water cell.

Return the maximum number of fish the fisher can catch if he chooses his starting cell optimally, or 0 if no water cell exists.

An adjacent cell of the cell (r, c), is one of the cells (r, c + 1), (r, c - 1), (r + 1, c) or (r - 1, c) if it exists.

Example 1:

Input: grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
Output: 7
Explanation: The fisher can start at cell (1,3) and collect 3 fish, then move to cell (2,3) and collect 4 fish.

Example 2:

Input: grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]
Output: 1
Explanation: The fisher can start at cells (0,0) or (3,3) and collect a single fish. 

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 10
• 0 <= grid[i][j] <= 10

Solution: Connected Component

Similar to 花花酱 LeetCode 695. Max Area of Island

Find the connected component that has the max sum.

Time complexity: O(mn)
Space complexity: O(mn)

// Author: Huahua
class Solution {
public:
  int findMaxFish(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    function<int(int, int)> dfs = [&](int r, int c) {
      if (r < 0 || r >= m || c < 0 || c >= n || !grid[r][c]) return 0;      
      return exchange(grid[r][c], 0) 
        + dfs(r - 1, c) + dfs(r, c - 1) + dfs(r + 1, c) + dfs(r, c + 1);
    };
    int ans = 0;
    for (int r = 0; r < m; ++r)
      for (int c = 0; c < n; ++c)
        ans = max(ans, dfs(r, c));
    return ans;
  }
};

The post 花花酱 LeetCode 2658. Maximum Number of Fish in a Grid appeared first on Huahua's Tech Road.

Two strings s1 and s2 are said to be connected if the set of letters of s2 can be obtained from the set of letters of s1 by any one of the following operations:

• Adding exactly one letter to the set of the letters of s1.
• Deleting exactly one letter from the set of the letters of s1.
• Replacing exactly one letter from the set of the letters of s1 with any letter, including itself.

The array words can be divided into one or more non-intersecting groups. A string belongs to a group if any one of the following is true:

• It is connected to at least one other string of the group.
• It is the only string present in the group.

Note that the strings in words should be grouped in such a manner that a string belonging to a group cannot be connected to a string present in any other group. It can be proved that such an arrangement is always unique.

Return an array ans of size 2 where:

• ans[0] is the total number of groups words can be divided into, and
• ans[1] is the size of the largest group.

Example 1:

Input: words = ["a","b","ab","cde"]
Output: [2,3]
Explanation:
- words[0] can be used to obtain words[1] (by replacing 'a' with 'b'), and words[2] (by adding 'b'). So words[0] is connected to words[1] and words[2].
- words[1] can be used to obtain words[0] (by replacing 'b' with 'a'), and words[2] (by adding 'a'). So words[1] is connected to words[0] and words[2].
- words[2] can be used to obtain words[0] (by deleting 'b'), and words[1] (by deleting 'a'). So words[2] is connected to words[0] and words[1].
- words[3] is not connected to any string in words.
Thus, words can be divided into 2 groups ["a","b","ab"] and ["cde"]. The size of the largest group is 3.  

Example 2:

Input: words = ["a","ab","abc"]
Output: [1,3]
Explanation:
- words[0] is connected to words[1].
- words[1] is connected to words[0] and words[2].
- words[2] is connected to words[1].
Since all strings are connected to each other, they should be grouped together.
Thus, the size of the largest group is 3.

Constraints:

• 1 <= words.length <= 2 * 104
• 1 <= words[i].length <= 26
• words[i] consists of lowercase English letters only.
• No letter occurs more than once in words[i].

Solution: Bitmask + DFS

Use a bitmask to represent a string. Use dfs to find connected components.

Time complexity: O(n*26²)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<int> groupStrings(vector<string>& words) {
    unordered_map<int, int> m;
    for (const string& w : words)
      ++m[accumulate(begin(w), end(w), 0, [](int k, char c){ return k | (1 << (c - 'a')); })];
    function<int(int)> dfs = [&](int mask) {
      auto it = m.find(mask);
      if (it == end(m)) return 0;
      int ans = it->second;      
      m.erase(it);
      for (int i = 0; i < 26; ++i) {        
        ans += dfs(mask ^ (1 << i));
        for (int j = i + 1; j < 26; ++j)
          if ((mask >> i & 1) != (mask >> j & 1))
            ans += dfs(mask ^ (1 << i) ^ (1 << j));
      }
      return ans;
    };
    int size = 0;
    int groups = 0;
    while (!m.empty()) {
      size = max(size, dfs(begin(m)->first));
      ++groups;
    }
    return {groups, size};
  }
};

The post 花花酱 LeetCode 2157. Groups of Strings appeared first on Huahua's Tech Road.

Given a 2D grid consists of 0s (land) and 1s (water).  An island is a maximal 4-directionally connected group of 0s and a closed island is an island totally (all left, top, right, bottom) surrounded by 1s.

Return the number of closed islands.

Example 1:

Input: grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
Output: 2
Explanation: 
Islands in gray are closed because they are completely surrounded by water (group of 1s).

Example 2:

Input: grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
Output: 1

Example 3:

Input: grid = [[1,1,1,1,1,1,1],
               [1,0,0,0,0,0,1],
               [1,0,1,1,1,0,1],
               [1,0,1,0,1,0,1],
               [1,0,1,1,1,0,1],
               [1,0,0,0,0,0,1],
               [1,1,1,1,1,1,1]]
Output: 2

Constraints:

• 1 <= grid.length, grid[0].length <= 100
• 0 <= grid[i][j] <=1

Solution: DFS/Backtracking

For each connected component, if it can reach the boundary then it’s not a closed island.

Time complexity: O(n*m)
Space complexity: O(n*m)

// Author: Huahua
class Solution {
public:
  int closedIsland(vector<vector<int>>& grid) {    
    const int n = grid.size();
    const int m = grid[0].size();    
    function<int(int, int)> dfs = [&](int x, int y) {
      if (x < 0 || y < 0 || x >= m || y >= n) return 0;      
      if (grid[y][x]++) return 1;
      return dfs(x + 1, y) & dfs(x - 1, y) & dfs(x, y + 1) & dfs(x, y - 1);
    };
    
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < m; ++j)
        if (!grid[i][j]) ans += dfs(j, i);      
    return ans;
  }
};

The post 花花酱 LeetCode 1254. Number of Closed Islands appeared first on Huahua's Tech Road.

You are given a string s, and an array of pairs of indices in the string pairs where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.

You can swap the characters at any pair of indices in the given pairs any number of times.

Return the lexicographically smallest string that s can be changed to after using the swaps.

Example 1:

Input: s = "dcab", pairs = [[0,3],[1,2]]
Output: "bacd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[1] and s[2], s = "bacd"

Example 2:

Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
Output: "abcd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[0] and s[2], s = "acbd"
Swap s[1] and s[2], s = "abcd"

Example 3:

Input: s = "cba", pairs = [[0,1],[1,2]]
Output: "abc"
Explaination: 
Swap s[0] and s[1], s = "bca"
Swap s[1] and s[2], s = "bac"
Swap s[0] and s[1], s = "abc"

Constraints:

• 1 <= s.length <= 10^5
• 0 <= pairs.length <= 10^5
• 0 <= pairs[i][0], pairs[i][1] < s.length
• s only contains lower case English letters.

Solution: Connected Components

Use DFS / Union-Find to find all the connected components of swapable indices. For each connected components (index group), extract the subsequence of corresponding chars as a string, sort it and put it back to the original string in the same location.

e.g. s = “dcab”, pairs = [[0,3],[1,2]]
There are two connected components: {0,3}, {1,2}
subsequences:
1. 0,3 “db”, sorted: “bd”
2. 1,2 “ca”, sorted: “ac”
0 => b
1 => a
2 => c
3 => d
final = “bacd”

Time complexity: DFS: O(nlogn + k*(V+E)), Union-Find: O(nlogn + V+E)
Space complexity: O(n)

// Author: Huahua, 268 ms, 89 MB
class Solution {
public:
  string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
    vector<vector<int>> g(s.length());
    for (const auto& e : pairs) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }

    unordered_set<int> seen;
    vector<int> idx;
    string tmp;
    function<void(int)> dfs = [&](int cur) {
      if (seen.count(cur)) return;
      seen.insert(cur);
      idx.push_back(cur);
      tmp += s[cur];
      for (int nxt : g[cur]) dfs(nxt);
    };

    for (int i = 0; i < s.length(); ++i) {
      if (seen.count(i)) continue;
      idx.clear();
      tmp.clear();
      dfs(i);
      sort(begin(tmp), end(tmp));
      sort(begin(idx), end(idx));      
      for (int k = 0; k < idx.size(); ++k)
        s[idx[k]] = tmp[k];
    }
    return s;
  }
};

// Author: Huahua, 152 ms, 48.2 MB
class Solution {
public:
  string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
    int n = s.length();
    vector<int> p(n);    
    iota(begin(p), end(p), 0); // p = {0, 1, 2, ... n - 1}
    
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : p[x] = find(p[x]);
    };        
    
    for (const auto& e : pairs)
      p[find(e[0])] = find(e[1]); // union
    
    vector<vector<int>> idx(n);
    vector<string> ss(n);
    
    for (int i = 0; i < s.length(); ++i) {
      int id = find(i);      
      idx[id].push_back(i); // already sorted
      ss[id].push_back(s[i]);
    }
    
    for (int i = 0; i < n; ++i) {      
      sort(begin(ss[i]), end(ss[i]));
      for (int k = 0; k < idx[i].size(); ++k)
        s[idx[i][k]] = ss[i][k];
    }
    
    return s;
  }
};

The post 花花酱 LeetCode 1202. Smallest String With Swaps appeared first on Huahua's Tech Road.

On a 2D plane, we place stones at some integer coordinate points.  Each coordinate point may have at most one stone.

Now, a move consists of removing a stone that shares a column or row with another stone on the grid.

What is the largest possible number of moves we can make?

Example 1:

Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
Output: 5

Example 2:

Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
Output: 3

Example 3:

Input: stones = [[0,0]]
Output: 0

Note:

1. 1 <= stones.length <= 1000
2. 0 <= stones[i][j] < 10000

Solution 2: Union Find

Find all connected components (islands)

Ans = # of stones – # of islands

// Author: Huahua, running time: 16 ms
class Solution {
public:
  int removeStones(vector<vector<int>>& stones) {
    const int kSize = 10000;
    DSU dsu(kSize * 2);
    for (const auto& stone : stones)
      dsu.Union(stone[0], stone[1] + kSize);
    unordered_set<int> seen;
    for (const auto& stone : stones)
      seen.insert(dsu.Find(stone[0]));
    return stones.size() - seen.size();
  }
private:
  class DSU {
  public:
    DSU(int n): p_(n) {
      for (int i = 0 ; i < n; ++i)
        p_[i] = i;              
    }
    
    void Union(int i, int j) {
      p_[Find(i)] = Find(j);      
    }
    
    int Find(int i) {
      if (p_[i] != i) p_[i] = Find(p_[i]);
      return p_[i];
    }    
  private:
    vector<int> p_;    
  };
};

Related Problems

• 花花酱 LeetCode 200. Number of Islands

The post 花花酱 LeetCode 947. Most Stones Removed with Same Row or Column appeared first on Huahua's Tech Road.

Problem

There are N rooms and you start in room 0.  Each room has a distinct number in 0, 1, 2, ..., N-1, and each room may have some keys to access the next room.

Formally, each room i has a list of keys rooms[i], and each key rooms[i][j] is an integer in [0, 1, ..., N-1] where N = rooms.length.  A key rooms[i][j] = v opens the room with number v.

Initially, all the rooms start locked (except for room 0).

You can walk back and forth between rooms freely.

Return true if and only if you can enter every room.

Example 1:

Input: [[1],[2],[3],[]]
Output: true
Explanation:  
We start in room 0, and pick up key 1.
We then go to room 1, and pick up key 2.
We then go to room 2, and pick up key 3.
We then go to room 3.  Since we were able to go to every room, we return true.

Example 2:

Input: [[1,3],[3,0,1],[2],[0]]
Output: false
Explanation: We can't enter the room with number 2.

Note:

1. 1 <= rooms.length <= 1000
2. 0 <= rooms[i].length <= 1000
3. The number of keys in all rooms combined is at most 3000.

Solution: DFS

Time complexity: O(V + E)

Space complexity: O(V)

C++

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
  bool canVisitAllRooms(vector<vector<int>>& rooms) {
    unordered_set<int> visited;
    dfs(rooms, 0, visited);
    return visited.size() == rooms.size();
  }
private:
  void dfs(const vector<vector<int>>& rooms, 
           int cur, unordered_set<int>& visited) {
    if (visited.count(cur)) return;
    visited.insert(cur);
    for (int nxt : rooms[cur])
      dfs(rooms, nxt, visited);
  }
};

The post 花花酱 LeetCode 841. Keys and Rooms appeared first on Huahua's Tech Road.

Problem

In a 2D grid of 0s and 1s, we change at most one 0 to a 1.

After, what is the size of the largest island? (An island is a 4-directionally connected group of 1s).

Example 1:

Input: [[1, 0], [0, 1]]
Output: 3
Explanation: Change one 0 to 1 and connect two 1s, then we get an island with area = 3.

Example 2:

Input: [[1, 1], [1, 0]]
Output: 4
Explanation: Change the 0 to 1 and make the island bigger, only one island with area = 1.

Example 3:

Input: [[1, 1], [1, 1]]
Output: 4
Explanation: Can't change any 0 to 1, only one island with area = 1.

Notes:

• 1 <= grid.length = grid[0].length <= 50.
• 0 <= grid[i][j] <= 1.

Solution

Step 1: give each connected component a unique id and count its ara.

Step 2: for each 0 zero, check its 4 neighbours, sum areas up by unique ids.

Time complexity: O(n*m)

Space complexity: O(n*m)

C++

// Author: Huahua
// Running time: 14 ms
class Solution {
public:
  int largestIsland(vector<vector<int>>& grid) {
    color_ = 1;
    g_ = &grid;
    m_ = grid.size();
    n_ = grid[0].size();
    unordered_map<int, int> areas; // color -> area
    int ans = 0;
    for (int i = 0; i < m_; ++i)
      for (int j = 0; j < n_; ++j)
        if (grid[i][j] == 1) {
          ++color_;
          areas[color_] = getArea(j, i);
          ans = max(ans, areas[color_]);
        }
    for (int i = 0; i < m_; ++i)
      for (int j = 0; j < n_; ++j)
        if (grid[i][j] == 0) {                    
          int area = 1;
          for (int color : set<int>{getColor(j, i - 1), getColor(j, i + 1),
                                    getColor(j - 1, i), getColor(j + 1, i)}) 
            area += areas[color];
          ans = max(ans, area);
        }
    return ans;
  }
private:
  int m_;
  int n_;
  int color_;
  vector<vector<int>>* g_; // does not own the object.
  
  int getColor(int x, int y) {
    return (x < 0 || x >= n_ || y < 0 || y >= m_) ? 0 : (*g_)[y][x];
  }
  
  // Return the area of a connected component, set all elements to color_.
  int getArea(int x, int y) {
    if (x < 0 || x >= n_ || y < 0 || y >= m_ || (*g_)[y][x] != 1) return 0;
    (*g_)[y][x] = color_;
    return 1 + getArea(x - 1, y) + getArea(x + 1, y) 
             + getArea(x, y - 1) + getArea(x, y + 1);
  }
};

The post 花花酱 LeetCode 827. Making A Large Island appeared first on Huahua's Tech Road.

Problem

题目大意：给你一个链表，再给你一些合法的节点，问你链表中有多少个连通分量（所有节点必须合法）。

https://leetcode.com/problems/linked-list-components/description/

We are given head, the head node of a linked list containing unique integer values.

We are also given the list G, a subset of the values in the linked list.

Return the number of connected components in G, where two values are connected if they appear consecutively in the linked list.

Example 1:

Input: 
head: 0->1->2->3
G = [0, 1, 3]
Output: 2
Explanation: 
0 and 1 are connected, so [0, 1] and [3] are the two connected components.

Example 2:

Input: 
head: 0->1->2->3->4
G = [0, 3, 1, 4]
Output: 2
Explanation: 
0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.

Note:

• If N is the length of the linked list given by head, 1 <= N <= 10000.
• The value of each node in the linked list will be in the range [0, N - 1].
• 1 <= G.length <= 10000.
• G is a subset of all values in the linked list.

Solution1: Graph Traversal using DFS

// Author: Huahua
// Running time: 76 ms
class Solution {
public:
  int numComponents(ListNode* head, vector<int>& G) {
    unordered_set<int> f(G.begin(), G.end());
    unordered_map<int, vector<int>> g;
    int u = head->val;
    while (head->next) {
      head = head->next;
      int v = head->val;
      if (f.count(v) && f.count(u)) {
        g[u].push_back(v);
        g[v].push_back(u);
      }
      u = v;
    }
    int ans = 0;
    unordered_set<int> visited;
    for (int u : G) {      
      if (visited.count(u)) continue;
      ++ans;
      dfs(u, g, visited);
    }
    return ans;
  }
private:
  void dfs(int cur, unordered_map<int, vector<int>>& g, unordered_set<int>& visited) {
    if (visited.count(cur)) return;
    visited.insert(cur);
    for (const int next : g[cur])
      dfs(next, g, visited);    
  }
};

Solution 2: Count tail node in sub graph

// Author: Huahua
// Running time: 35 ms
class Solution {
public:
  int numComponents(ListNode* head, vector<int>& G) {
    unordered_set<int> g(G.begin(), G.end());
    int ans = 0;
    while (head) {
      if (g.count(head->val) && (!head->next || !g.count(head->next->val)))
        ++ans;
      head = head->next;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 817. Linked List Components appeared first on Huahua's Tech Road.

Problem

题目大意：给你一堵砖墙，求每次击碎一块后掉落的砖头数量。

We have a grid of 1s and 0s; the 1s in a cell represent bricks.  A brick will not drop if and only if it is directly connected to the top of the grid, or at least one of its (4-way) adjacent bricks will not drop.

We will do some erasures sequentially. Each time we want to do the erasure at the location (i, j), the brick (if it exists) on that location will disappear, and then some other bricks may drop because of that erasure.

Return an array representing the number of bricks that will drop after each erasure in sequence.

Example 1:
Input: 
grid = [[1,0,0,0],[1,1,1,0]]
hits = [[1,0]]
Output: [2]
Explanation: 
If we erase the brick at (1, 0), the brick at (1, 1) and (1, 2) will drop. So we should return 2.

Example 2:
Input: 
grid = [[1,0,0,0],[1,1,0,0]]
hits = [[1,1],[1,0]]
Output: [0,0]
Explanation: 
When we erase the brick at (1, 0), the brick at (1, 1) has already disappeared due to the last move. So each erasure will cause no bricks dropping.  Note that the erased brick (1, 0) will not be counted as a dropped brick.

Idea

1. For each day, hit and clear the specified brick.
2. Find all connected components (CCs) using DFS.
3. For each CC, if there is no brick that is on the first row that the entire cc will drop. Clear those CCs.

Solution: DFS

// Author: Huahua
// Running time: 1261 ms
class Solution {
public:
  vector<int> hitBricks(vector<vector<int>>& grid, vector<vector<int>>& hits) {    
    dirs_ = {0, -1, 0, 1, 0};    
    m_ = grid.size();
    n_ = grid[0].size();
    g_.swap(grid);
    seq_ = 1;
    
    vector<int> ans;
    for (int i = 0; i < hits.size(); ++i)
      ans.push_back(hit(hits[i][1], hits[i][0]));
    return ans;
  }
private:
  vector<vector<int>> g_;
  vector<int> dirs_;
  int seq_;
  int m_;
  int n_;
  
  // hit x, y and return the number of bricks fallen.
  int hit(int x, int y) {
    if (x < 0 || x >= n_ || y < 0 || y >= m_) return 0;    
    g_[y][x] = 0;
    int ans = 0; 
    for (int i = 0; i < 4; ++i) {
      ++seq_;
      int count = 0;
      if (!fall(x + dirs_[i], y + dirs_[i + 1], false, count)) continue;      
      ++seq_;
      ans += count;
      fall(x + dirs_[i], y + dirs_[i + 1], true, count);
    }
    return ans;
  }
  
  // Check whether the CC contains (x, y) will fall or not.
  // Set all nodes in this CC as seq_ or 0 if clear.
  // count: the # of nodes in this CC.
  bool fall(int x, int y, bool clear, int& count) {
    if (x < 0 || x >= n_ || y < 0 || y >= m_) return true;
    if (g_[y][x] == seq_ || g_[y][x] == 0) return true;
    if (y == 0) return false;
    g_[y][x] = clear ? 0 : seq_;
    ++count;
    for (int i = 0; i < 4; ++i)
      if (!fall(x + dirs_[i], y + dirs_[i + 1], clear, count)) return false;
    return true;
  }
};

// Author: Huahua
// Stack Overflow (1024 recursive calls)
class Solution {
  int[] dirs = new int[]{0, -1, 0, 1, 0};
  int m;
  int n;
  int[][] g;
  int seq;
  int count;
  
  public int[] hitBricks(int[][] grid, int[][] hits) {
    this.g = grid;
    this.m = grid.length;
    this.n = grid[0].length;
    
    int[] ans = new int[hits.length];
    
    for (int i = 0; i < hits.length; ++i)
      ans[i] = hit(hits[i][1], hits[i][0]);
    
    return ans;
  }
  
  private int hit(int x, int y) {
    if (x < 0 || x >= n || y < 0 || y >= m || g[y][x] == 0) return 0;
    g[y][x] = 0;
    int ans = 0;
    for (int i = 0; i < 4; ++i) {
      ++seq;      
      count = 0;
      if (!fall(x + dirs[i], y + dirs[i + 1], false)) continue;    
      ans += count;
      ++seq;
      fall(x + dirs[i], y + dirs[i + 1], true);
    }
    return ans;
  }
  
  private boolean fall(int x, int y, boolean clear) {
    if (x < 0 || x >= n || y < 0 || y >= m) return true;
    if (g[y][x] == seq || g[y][x] == 0) return true;
    if (y == 0) return false;
    g[y][x] = clear ? 0 : seq;
    ++count;
    for (int i = 0; i < 4; ++i)
      if (!fall(x + dirs[i], y + dirs[i + 1], clear)) return false;
    return true;
  }
}

Related Problems

• 花花酱 LeetCode 749. Contain Virus

The post 花花酱 LeetCode 803. Bricks Falling When Hit appeared first on Huahua's Tech Road.

https://leetcode.com/problems/redundant-connection/description/

Problem:

In this problem, a tree is an undirected graph that is connected and has no cycles.

The given input is a graph that started as a tree with N nodes (with distinct values 1, 2, …, N), with one additional edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.

The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [u, v] with u < v, that represents an undirected edge connecting nodes u and v.

Return an edge that can be removed so that the resulting graph is a tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array. The answer edge [u, v] should be in the same format, with u < v.

Example 1:

Input: [[1,2], [1,3], [2,3]]
Output: [2,3]
Explanation: The given undirected graph will be like this:
  1
 / \
2 - 3

Example 2:

Input: [[1,2], [2,3], [3,4], [1,4], [1,5]]
Output: [1,4]
Explanation: The given undirected graph will be like this:
5 - 1 - 2
    |   |
    4 - 3

Note:

• The size of the input 2D-array will be between 3 and 1000.
• Every integer represented in the 2D-array will be between 1 and N, where N is the size of the input array.

Idea:
DFS / Union-Find

Solutions:

C++ / DFS

// Author: Huahua
// Time Complexity: O(n^2)
// Running Time: 22 ms
class Solution {
public:
    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        unordered_map<int, vector<int>> graph;
        for (const auto& edge : edges) {
            int u = edge[0];
            int v = edge[1];
            
            unordered_set<int> visited;
            if (hasPath(u, v, graph, visited))
                return edge;
            
            graph[u].push_back(v);
            graph[v].push_back(u);
        }
        return {};
    }
private:
    bool hasPath(int curr, 
                 int goal, 
                 const unordered_map<int, vector<int>>& graph, 
                 unordered_set<int>& visited) {
        if (curr == goal) return true;
        visited.insert(curr);
        if (!graph.count(curr) || !graph.count(goal)) return false;
        for (int next : graph.at(curr)) {
            if (visited.count(next)) continue;
            if (hasPath(next, goal, graph, visited)) return true;
        }
        return false;
    }
};

C++ / Union Find

// Author: Huahua
// Running time: 6 ms
class UnionFindSet {
public:
    UnionFindSet(int n) {
        ranks_ = vector<int>(n + 1, 0);        
        parents_ = vector<int>(n + 1, 0);                
        
        for (int i = 0; i < parents_.size(); ++i)
            parents_[i] = i;
    }
    
    // Merge sets that contains u and v.
    // Return true if merged, false if u and v are already in one set.
    bool Union(int u, int v) {
        int pu = Find(u);
        int pv = Find(v);
        if (pu == pv) return false;
        
        // Meger low rank tree into high rank tree
        if (ranks_[pv] > ranks_[pu])
            parents_[pu] = pv;           
        else if (ranks_[pu] > ranks_[pv])
            parents_[pv] = pu;
        else {
            parents_[pv] = pu;
            ranks_[pv] += 1;
        }
        
        return true;
    }
    
    // Get the root of u.
    int Find(int u) {        
        // Compress the path during traversal
        if (u != parents_[u])
            parents_[u] = Find(parents_[u]);        
        return parents_[u];
    }
private:
    vector<int> parents_;
    vector<int> ranks_;
};

class Solution {
public:
    vector<int> findRedundantConnection(vector<vector<int>>& edges) {    
        UnionFindSet s(edges.size());
        
        for(const auto& edge: edges)
            if (!s.Union(edge[0], edge[1]))
                return edge;
        
        return {};
    }
};

Java / Union Find

// Author: Huahua
// Runtime: 6 ms
class Solution {
    class UnionFindSet {
        private int[] parents_;
        private int[] ranks_;

        public UnionFindSet(int n) {
            parents_ = new int[n + 1];
            ranks_ = new int[n + 1];
            for (int i = 0; i < parents_.length; ++i) {
                parents_[i] = i;
                ranks_[i] = 1;
            }
        }

        public boolean Union(int u, int v) {
            int pu = Find(u);
            int pv = Find(v);
            if (pu == pv) return false;

            if (ranks_[pv] > ranks_[pu])
                parents_[pu] = pv;           
            else if (ranks_[pu] > ranks_[pv])
                parents_[pv] = pu;
            else {
                parents_[pv] = pu;
                ranks_[pu] += 1;
            }

            return true;
        }

        public int Find(int u) {
            while (parents_[u] != u) {
                parents_[u] = parents_[parents_[u]];
                u = parents_[u];
            }
            return u;
        }
    }
    
    public int[] findRedundantConnection(int[][] edges) {
        UnionFindSet s = new UnionFindSet(edges.length);
        for (int[] edge : edges)
            if (!s.Union(edge[0], edge[1]))
                return edge;
        return null;
    }
    
    
}

Python: Union Find

"""
Author: Huahua
Running Time: 66 ms
"""
class Solution:
    def findRedundantConnection(self, edges):
        
        p = [0]*(len(edges) + 1)
        s = [1]*(len(edges) + 1)
        
        def find(u):
            while p[u] != u:
                p[u] = p[p[u]]
                u = p[u]
            return u
        
        for u, v in edges:
            if p[u] == 0: p[u] = u
            if p[v] == 0: p[v] = v
            pu, pv = find(u), find(v)
            if pu == pv: return [u, v]
            
            if s[pv] > s[pu]: u, v = v, u
            p[pv] = pu
            s[pu] += s[pv]

        return []

Python / Union Find V2

"""
Author: Huahua
Runtime: 59 ms (<92.42%)
"""
class UnionFindSet:
    def __init__(self, n):
        self._parents = [i for i in range(n + 1)]
        self._ranks = [1 for i in range(n + 1)]
    
    def find(self, u):
        while u != self._parents[u]:
            self._parents[u] = self._parents[self._parents[u]]
            u = self._parents[u]
        return u
    
    def union(self, u, v):
        pu, pv = self.find(u), self.find(v)
        if pu == pv: return False
        
        if self._ranks[pu] < self._ranks[pv]:
            self._parents[pu] = pv
        elif self._ranks[pu] > self._ranks[pv]:
            self._parents[pv] = pu
        else:        
            self._parents[pv] = pu
            self._ranks[pu] += 1
        
        return True
        
class Solution:
    def findRedundantConnection(self, edges):
        s = UnionFindSet(len(edges))
        for edge in edges:
            if not s.union(edge[0], edge[1]): return edge
        return None
        ndSet(len(edges))
        for edge in edges:
            if not s.union(edge[0], edge[1]): return edge
        return None

The post 花花酱 LeetCode 684. Redundant Connection appeared first on Huahua's Tech Road.

Problem:

There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. For example, if A is a direct friend of B, and B is a direct friend of C, then A is an indirect friend of C. And we defined a friend circle is a group of students who are direct or indirect friends.

Given a N*N matrix M representing the friend relationship between students in the class. If M[i][j] = 1, then the i_thand j_th students are direct friends with each other, otherwise not. And you have to output the total number of friend circles among all the students.

Example 1:

Input: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
Output: 2

Example 2:

Input: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
Output: 1

1. N is in range [1,200].
2. M[i][i] = 1 for all students.
3. If M[i][j] = 1, then M[j][i] = 1.

Idea:

Find all connected components using DFS

Solution: DFS

// Author: Huahua
// Time complexity: O(n^2)
// Space complexity: O(n)
// Running Time: 25 ms
class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        if (M.empty()) return 0;
        int n = M.size();
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (!M[i][i]) continue;
            ++ans;
            dfs(M, i, n);
        }
        return ans;
    }
private:
    void dfs(vector<vector<int>>& M, int curr, int n) {        
        // Visit all friends (neighbors)
        for (int i = 0; i < n; ++i) {
            if (!M[curr][i]) continue;
            M[curr][i] = M[i][curr] = 0;
            dfs(M, i, n);
        }
    }
};

// Author: Huahua
// Time complexity: O(n^2)
// Space complexity: O(n)
// Running Time: 20 ms
class Solution {
    public int findCircleNum(int[][] M) {
        int n = M.length;
        if (n == 0) return 0;
        
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (M[i][i] == 0) continue;            
            ++ans;
            dfs(M, i, n);
        }
        return ans;
    }
    
    private void dfs(int[][] M, int curr, int n) {
        for (int i = 0; i < n; ++i) {
            if (M[curr][i] == 0) continue;
            M[curr][i] = M[i][curr] = 0;
            dfs(M, i, n);
        }
    }
}

"""
Author: Huahua
Time complexity: O(n^2)
Space complexity: O(n)
Running Time: 162 ms
"""
class Solution(object):
    def findCircleNum(self, M):
        """
        :type M: List[List[int]]
        :rtype: int
        """
        
        def dfs(M, curr, n):
            for i in xrange(n):
                if M[curr][i] == 1:
                    M[curr][i] = M[i][curr] = 0
                    dfs(M, i, n)
        
        n = len(M)
        ans = 0
        for i in xrange(n):
            if M[i][i] == 1:
                ans += 1
                dfs(M, i, n)
        
        return ans

Solution 2: Union Find

// Author: Huahua
// Runtime: 19 ms
class UnionFindSet {
public:
    UnionFindSet(int n) {
        parents_ = vector<int>(n + 1, 0);
        ranks_ = vector<int>(n + 1, 0);
        
        for (int i = 0; i < parents_.size(); ++i)
            parents_[i] = i;
    }
    
    bool Union(int u, int v) {
        int pu = Find(u);
        int pv = Find(v);
        if (pu == pv) return false;
        
        if (ranks_[pu] > ranks_[pv]) {
            parents_[pv] = pu;
        } else if (ranks_[pv] > ranks_[pu]) {
            parents_[pu] = pv;
        } else {
            parents_[pu] = pv;
            ++ranks_[pv];
        }
 
        return true;
    }
    
    int Find(int id) {        
        if (id != parents_[id])
            parents_[id] = Find(parents_[id]);        
        return parents_[id];
    }
    
private:
    vector<int> parents_;
    vector<int> ranks_;
};
 
class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        int n = M.size();
        UnionFindSet s(n);
        for (int i = 0; i < n; ++i)
            for (int j = i + 1; j < n; ++j)
                if (M[i][j] == 1) s.Union(i, j);
        
        unordered_set<int> circles;
        for (int i = 0; i < n; ++i)
            circles.insert(s.Find(i));
        
        return circles.size();
    }
};

Related Problems

• [解题报告] LeetCode 200. Number of Islands
• [解题报告] LeetCode 695. Max Area of Island
• [解题报告] LeetCode 684. Redundant Connection
• [解题报告] LeetCode 685. Redundant Connection II
• [解题报告] LeetCode 737. Sentence Similarity II

The post 花花酱 LeetCode 547. Friend Circles appeared first on Huahua's Tech Road.

Problem:

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

11110
11010
11000
00000

Answer: 1

Example 2:

11000
11000
00100
00011

Idea: DFS

Use DFS to find a connected component (an island) and mark all the nodes to 0.

Time complexity: O(mn)

Space complexity: O(mn)

Solution

// Author: Huahua
// Time complexity: O(mn)
// Running time: 6 ms
class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if (grid.empty()) return 0;
        int m = grid.size();
        int n = grid[0].size();
        int ans = 0;
        for (int y = 0; y < m; ++y)
            for (int x = 0; x < n; ++x) {
                ans += grid[y][x] - '0';
                dfs(grid, x, y, m, n);
            }
        return ans;                
    }   
private:
    void dfs(vector<vector<char>>& grid, int x, int y, int m, int n) {
        if (x < 0 || y < 0 || x >= n || y >= m || grid[y][x] == '0')
            return;
        grid[y][x] = '0';
        dfs(grid, x + 1, y, m, n);
        dfs(grid, x - 1, y, m, n);
        dfs(grid, x, y + 1, m, n);
        dfs(grid, x, y - 1, m, n);
    }
};

// Author: Huahua
// Time Complexity: O(mn)
// Running time: 13 ms
class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        if (m == 0) return 0;
        int n = grid[0].length;
        
        int ans = 0;
        for (int y = 0; y < m; ++y)
            for (int x = 0; x < n; ++x)
                if (grid[y][x] == '1') {
                    ++ans;
                    dfs(grid, x, y, n, m);
                }
        
        return ans;
    }
    
    private void dfs(char[][] grid, int x, int y, int n, int m) {
        if (x < 0 || y < 0 || x >= n || y >= m || grid[y][x] == '0')
            return;
        grid[y][x] = '0';
        dfs(grid, x + 1, y, n, m);
        dfs(grid, x - 1, y, n, m);
        dfs(grid, x, y + 1, n, m);
        dfs(grid, x, y - 1, n, m);
    }
}

"""
Author: Huahua
Time Complexity: O(mn)
Running Time: 102 ms
"""
class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        m = len(grid)
        if m == 0: return 0
        n = len(grid[0])
        
        ans = 0
        for y in xrange(m):
            for x in xrange(n):
                if grid[y][x] == '1':
                    ans += 1
                    self.__dfs(grid, x, y, n, m)
        return ans
    
    def __dfs(self, grid, x, y, n, m):
        if x < 0 or y < 0 or x >=n or y >= m or grid[y][x] == '0':
            return
        grid[y][x] = '0'
        self.__dfs(grid, x + 1, y, n, m)
        self.__dfs(grid, x - 1, y, n, m)
        self.__dfs(grid, x, y + 1, n, m)
        self.__dfs(grid, x, y - 1, n, m)

Related Problems

• [解题报告] LeetCode 695. Max Area of Island
• [解题报告] LeetCode 547. Friend Circles
• 花花酱 LeetCode 827. Making A Large Island
• 花花酱 LeetCode 934. Shortest Bridge

The post 花花酱 LeetCode 200. Number of Islands appeared first on Huahua's Tech Road.