Hamiltonian path Archives - Huahua's Tech Road

花花酱 LeetCode 996. Number of Squareful Arrays

zxi — Sun, 17 Feb 2019 09:02:43 +0000

Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.

Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].

Example 1:

Input: [1,17,8]
Output: 2
Explanation: 
[1,8,17] and [17,8,1] are the valid permutations.

Example 2:

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

Note:

1 <= A.length <= 12
0 <= A[i] <= 1e9

Solution1: DFS

Try all permutations with pruning.

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

C++

// Author: Huahua, running time: 4 ms, 8.8 MB
class Solution {
public:
  int numSquarefulPerms(vector& A) {
    std::sort(begin(A), end(A));
    vector cur;
    vector used(A.size());
    int ans = 0;
    dfs(A, cur, used, ans);
    return ans;
  }
private:
  bool squareful(int x, int y) {
    int s = sqrt(x + y);
    return s * s == x + y;
  }
  
  void dfs(const vector& A, vector& cur, vector& used, int& ans) {    
    if (cur.size() == A.size()) {
      ++ans;
      return;
    }
    for (int i = 0; i < A.size(); ++i) {
      if (used[i]) continue;
      // Avoid duplications.
      if (i > 0 && !used[i - 1] && A[i] == A[i - 1]) continue; 
      // Prune invalid solutions.
      if (!cur.empty() && !squareful(cur.back(), A[i])) continue;
      
      cur.push_back(A[i]);
      used[i] = 1;
      dfs(A, cur, used, ans);
      used[i] = 0;
      cur.pop_back();
    }
  }
};

Solution 2: DP Hamiltonian Path

dp[s][i] := # of ways to reach state s (binary mask of nodes visited) that ends with node i

dp[s | (1 << j)][j] += dp[s][i] if g[i][j]

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

C++

// Author: Huahua, running time: 20 ms, 14.9 MB
class Solution {
public:
  int numSquarefulPerms(vector& A) {
    const int n = A.size();
    // For deduplication.
    std::sort(begin(A), end(A));        
    // g[i][j] == 1 if A[i], A[j] are squareful.
    vector> g(n, vector(n)); 
    // dp[s][i] := number of ways to reach state s and ends with node i.
    vector> dp(1 << n, vector(n)); 

    for (int i = 0; i < n; ++i) {      
      for (int j = 0; j < n; ++j) {
        if (i == j) continue;
        int r = sqrt(A[i] + A[j]);
        if (r * r == A[i] + A[j])
          g[i][j] = 1;
      }
    }
    
    // For the same numbers, only the first one can be the starting point.
    for (int i = 0; i < n; ++i)
      if (i == 0 || A[i] != A[i - 1])
        dp[(1 << i)][i] = 1;    
    
    int ans = 0;
    for (int s = 0; s < (1 << n); ++s)
      for (int i = 0; i < n; ++i) {
        if (!dp[s][i]) continue;
        for (int j = 0; j < n; ++j) {
          if (!g[i][j]) continue;
          if (s & (1 << j)) continue;
          // Only the first one can be used as the dest.
          if (j > 0 && !(s & (1 << (j - 1))) && A[j - 1] == A[j]) continue;
          dp[s | (1 << j)][j] += dp[s][i];
        }
      }
    
    for (int i = 0; i < n; ++i)
      ans += dp[(1 << n) - 1][i];
    return ans;
  }
};

花花酱 LeetCode 980. Unique Paths III

zxi — Sun, 20 Jan 2019 17:21:28 +0000

On a 2-dimensional grid, there are 4 types of squares:

1 represents the starting square. There is exactly one starting square.
2 represents the ending square. There is exactly one ending square.
0 represents empty squares we can walk over.
-1 represents obstacles that we cannot walk over.

Return the number of 4-directional walks from the starting square to the ending square, that walk over every non-obstacle square exactly once.

Example 1:

Input: [[1,0,0,0],[0,0,0,0],[0,0,2,-1]]
Output: 2
Explanation: We have the following two paths: 
1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)

Example 2:

Input: [[1,0,0,0],[0,0,0,0],[0,0,0,2]]
Output: 4
Explanation: We have the following four paths: 
1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2),(2,3)
2. (0,0),(0,1),(1,1),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3)
3. (0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(1,1),(0,1),(0,2),(0,3),(1,3),(2,3)
4. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2),(2,3)

Example 3:

Input: [[0,1],[2,0]]
Output: 0
Explanation: 
There is no path that walks over every empty square exactly once.
Note that the starting and ending square can be anywhere in the grid.

Note:

1 <= grid.length * grid[0].length <= 20

count how many empty blocks there are and try all possible paths to end point and check whether we visited every empty blocks or not.

Solution: Brute force / DP

C++/DFS

class Solution {
public:
  int uniquePathsIII(vector>& grid) {    
    int sx = -1;
    int sy = -1;
    int n = 1;
    for (int i = 0; i < grid.size(); ++i)
      for (int j = 0; j < grid[0].size(); ++j)
        if (grid[i][j] == 0) ++n;
        else if (grid[i][j] == 1) { sx = j; sy = i; }    
    return dfs(grid, sx, sy, n);
  }
private:
  int dfs(vector>& grid, int x, int y, int n) {
    if (x < 0 || x == grid[0].size() || 
        y < 0 || y == grid.size() || 
        grid[y][x] == -1) return 0;
    if (grid[y][x] == 2) return n == 0;    
    grid[y][x] = -1;
    int paths = dfs(grid, x + 1, y, n - 1) + 
                dfs(grid, x - 1, y, n - 1) +
                dfs(grid, x, y + 1, n - 1) + 
                dfs(grid, x, y - 1, n - 1);
    grid[y][x] = 0;
    return paths;
  };
};

C++/DP

class Solution {
public:
  int uniquePathsIII(vector>& grid) {
    const int n = grid.size();
    const int m = grid[0].size();
    const vector dirs{-1, 0, 1, 0, -1};
    
    vector>> cache(n, vector>(m, vector(1 << n * m, -1)));
    int sx = -1;
    int sy = -1;
    int state = 0;
    
    auto key = [m](int x, int y) { return 1 << (y * m + x); };
    
    function dfs = [&](int x, int y, int state) {    
      if (cache[y][x][state] != -1) return cache[y][x][state];
      if (grid[y][x] == 2) return static_cast(state == 0); 
      int paths = 0;      
      for (int i = 0; i < 4; ++i) {
        const int tx = x + dirs[i];
        const int ty = y + dirs[i + 1];
        if (tx < 0 || tx == m || ty < 0 || ty == n || grid[ty][tx] == -1) continue;
        if (!(state & key(tx, ty))) continue;
        paths += dfs(tx, ty, state ^ key(tx, ty));
      }
      return cache[y][x][state] = paths;
    };
    
    for (int y = 0; y < n; ++y)
      for (int x = 0; x < m; ++x)
        if (grid[y][x] == 0 || grid[y][x] == 2) state |= key(x, y);
        else if (grid[y][x] == 1) { sx = x; sy = y; }
    return dfs(sx, sy, state);
  }
};

The post 花花酱 LeetCode 980. Unique Paths III appeared first on Huahua's Tech Road.

花花酱 LeetCode 943. Find the Shortest Superstring

zxi — Sun, 18 Nov 2018 23:10:30 +0000

Problem

Given an array A of strings, find any smallest string that contains each string in A as a substring.

We may assume that no string in A is substring of another string in A.

Example 1:

Input: ["alex","loves","leetcode"]
Output: "alexlovesleetcode"
Explanation: All permutations of "alex","loves","leetcode" would also be accepted.

Example 2:

Input: ["catg","ctaagt","gcta","ttca","atgcatc"]
Output: "gctaagttcatgcatc"

Note:

1 <= A.length <= 12
1 <= A[i].length <= 20

Solution 1: Search + Pruning

Try all permutations. Pre-process the cost from word[i] to word[j] and store it in g[i][j].

Time complexity: O(n!)

Space complexity: O(n)

C++

// Author: Huahua, running time: 692 ms
class Solution {
public:
  string shortestSuperstring(vector& A) {    
    const int n = A.size();
    g_ = vector>(n, vector(n));
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j) {
        g_[i][j] = A[j].length();
        for (int k = 1; k <= min(A[i].length(), A[j].length()); ++k)
          if (A[i].substr(A[i].size() - k) == A[j].substr(0, k))            
            g_[i][j] = A[j].length() - k;
      }
    vector path(n);
    best_len_ = INT_MAX;
    dfs(A, 0, 0, 0, path);    
    string ans = A[best_path_[0]];
    for (int k = 1; k < best_path_.size(); ++k) {
      int i = best_path_[k - 1];
      int j = best_path_[k];
      ans += A[j].substr(A[j].length() - g_[i][j]);
    }
    return ans;
  }
private:
  vector> g_;
  vector best_path_;
  int best_len_;
  void dfs(const vector& A, int d, int used, int cur_len, vector& path) {
    if (cur_len >= best_len_) return;
    if (d == A.size()) {
      best_len_ = cur_len;
      best_path_ = path;
      return;
    }
    
    for (int i = 0; i < A.size(); ++i) {
      if (used & (1 << i)) continue;      
      path[d] = i;
      dfs(A,
          d + 1, 
          used | (1 << i),
          d == 0 ? A[i].length() : cur_len + g_[path[d - 1]][i],
          path);
    }
  }
};

Java

// Author: Huahua, 439 ms, 35.8MB
class Solution {
  private int n;
  private int[][] g;
  private String[] a;
  private int best_len;
  private int[] path;
  private int[] best_path;
  
  private void dfs(int d, int used, int cur_len) {
    if (cur_len >= best_len) return;
    if (d == n) {
      best_len = cur_len;
      best_path = path.clone();
      return;
    }
    
    for (int i = 0; i < n; ++i) {
      if ((used & (1 << i)) != 0) continue;
      path[d] = i;
      dfs(d + 1, 
          used | (1 << i), 
          d == 0 ? a[i].length() : cur_len + g[path[d - 1]][i]);
    }
  }
  
  public String shortestSuperstring(String[] A) {
    n = A.length;
    g = new int[n][n];
    a = A;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j) {
        g[i][j] = A[j].length();
        for (int k = 1; k <= Math.min(A[i].length(), A[j].length()); ++k)
          if (A[i].substring(A[i].length() - k).equals(A[j].substring(0, k)))
            g[i][j] = A[j].length() - k;        
      }
    
    path = new int[n];
    best_len = Integer.MAX_VALUE;
    
    dfs(0, 0, 0);
    
    String ans = A[best_path[0]];
    for (int k = 1; k < n; ++k) {
      int i = best_path[k - 1];
      int j = best_path[k];
      ans += A[j].substring(A[j].length() - g[i][j]);      
    }
    return ans;
  }
}

Solution 2: DP

g[i][j] is the cost of appending word[j] after word[i], or weight of edge[i][j].

We would like find the shortest path to visit each node from 0 to n – 1 once and only once this is called the Travelling sells man’s problem which is NP-Complete.

We can solve it with DP that uses exponential time.

dp[s][i] := min distance to visit nodes (represented as a binary state s) once and only once and the path ends with node i.

e.g. dp[7][1] is the min distance to visit nodes (0, 1, 2) and ends with node 1, the possible paths could be (0, 2, 1), (2, 0, 1).

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

Space complexity: O(n * 2^n)

C++

// Author: Huahua, running time: 20 ms
class Solution {
public:
  string shortestSuperstring(vector& A) {        
    const int n = A.size();
    vector> g(n, vector(n));
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j) {
        g[i][j] = A[j].length();
        for (int k = 1; k <= min(A[i].length(), A[j].length()); ++k)
          if (A[i].substr(A[i].size() - k) == A[j].substr(0, k)) 
            g[i][j] = A[j].length() - k;
      }
    
    vector> dp(1 << n, vector(n, INT_MAX / 2));
    vector> parent(1 << n, vector(n, -1));
    
    for (int i = 0; i < n; ++i) dp[1 << i][i] = A[i].length();
    
    for (int s = 1; s < (1 << n); ++s) {
      for (int j = 0; j < n; ++j) {
        if (!(s & (1 << j))) continue;
        int ps = s & ~(1 << j);
        for (int i = 0; i < n; ++i) {
          if (dp[ps][i] + g[i][j] < dp[s][j]) {
            dp[s][j] = dp[ps][i] + g[i][j];
            parent[s][j] = i;
          }
        }
      }
    }
    
    auto it = min_element(begin(dp.back()), end(dp.back()));
    int j = it - begin(dp.back());
    int s = (1 << n) - 1;
    string ans;
    while (s) {
      int i = parent[s][j];
      if (i < 0) ans = A[j] + ans;
      else ans = A[j].substr(A[j].length() - g[i][j]) + ans;
      s &= ~(1 << j);
      j = i;
    }
    return ans;
  } 
};

The post 花花酱 LeetCode 943. Find the Shortest Superstring appeared first on Huahua's Tech Road.

Hamiltonian path Archives - Huahua's Tech Road

花花酱 LeetCode 996. Number of Squareful Arrays

Solution1: DFS

C++

Solution 2: DP Hamiltonian Path

C++

Related Problems

花花酱 LeetCode 980. Unique Paths III

Solution: Brute force / DP

C++/DFS

C++/DP

花花酱 LeetCode 943. Find the Shortest Superstring

Problem

Solution 1: Search + Pruning

C++

Java

Solution 2: DP

C++