DFS Archives - Page 8 of 19 - Huahua's Tech Road

花花酱 LeetCode 1219. Path with Maximum Gold

By zxi on October 5, 2019

In a gold mine grid of size m * n, each cell in this mine has an integer representing the amount of gold in that cell, 0 if it is empty.

Return the maximum amount of gold you can collect under the conditions:

Every time you are located in a cell you will collect all the gold in that cell.
From your position you can walk one step to the left, right, up or down.
You can’t visit the same cell more than once.
Never visit a cell with 0 gold.
You can start and stop collecting gold from any position in the grid that has some gold.

Example 1:

Input: grid = [[0,6,0],[5,8,7],[0,9,0]]
Output: 24
Explanation:
[[0,6,0],
 [5,8,7],
 [0,9,0]]
Path to get the maximum gold, 9 -> 8 -> 7.

Example 2:

Input: grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]
Output: 28
Explanation:
[[1,0,7],
 [2,0,6],
 [3,4,5],
 [0,3,0],
 [9,0,20]]
Path to get the maximum gold, 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7.

Constraints:

1 <= grid.length, grid[i].length <= 15
0 <= grid[i][j] <= 100
There are at most 25 cells containing gold.

Solution: DFS

Time compleixty: O(4^25) ???
Space complexity: O(25)

C++

// Author: Huahua

class Solution {

public:

int getMaximumGold(vector<vector<int>>& g) {

int n = g.size();

int m = g[0].size();

int ans = 0;

function<int(int, int)> dfs = [&](int x, int y) {

if (x < 0 || x >= m || y < 0 || y >= n || g[y][x] == 0) return 0;

int c = 0;

swap(c, g[y][x]);

int r = c + max({dfs(x - 1, y), dfs(x + 1, y), dfs(x, y - 1), dfs(x, y + 1)});

swap(c, g[y][x]);

return r;

};

for (int i = 0; i < n; ++i)

for (int j = 0; j < m; ++j)

ans = max(ans, dfs(j, i));

return ans;

}

};

花花酱 LeetCode 46. Permutations

By zxi on October 2, 2019

Given a collection of distinct integers, return all possible permutations.

Example:

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

Solution: DFS

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

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> permute(vector<int>& nums) {

const int n = nums.size();

vector<vector<int>> ans;

vector<int> used(n);

vector<int> path;

function<void(int)> dfs = [&](int d) {

if (d == n) {

ans.push_back(path);

return;

}

for (int i = 0; i < n; ++i) {

if (used[i]) continue;

used[i] = 1;

path.push_back(nums[i]);

dfs(d + 1);

path.pop_back();

used[i] = 0;

}

};

dfs(0);

return ans;

}

};

花花酱 LeetCode 52. N-Queens II

By zxi on October 2, 2019

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return the number of distinct solutions to the n-queens puzzle.

Example:

Input: 4
Output: 2
Explanation: There are two distinct solutions to the 4-queens puzzle as shown below.
[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

Solution: DFS

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

C++

// Author: Huahua

class Solution {

public:

int totalNQueens(int n) {

vector<int> cols(n);

vector<int> diag1(2 * n - 1);

vector<int> diag2(2 * n - 1);

int ans = 0;

function<void(int)> dfs = [&](int r) {

if (r == n) {

++ans;

return;

}

for (int i = 0; i < n; i++) {

int& c = cols[i];

int& d1 = diag1[r + i];

int& d2 = diag2[r - i + n - 1];

if (c || d1 || d2) continue;

c = d1 = d2 = 1;

dfs(r + 1);

c = d1 = d2 = 0;

}

};

dfs(0);

return ans;

}

};

花花酱 LeetCode 77. Combinations

By zxi on September 30, 2019

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

Example:

Input: n = 4, k = 2
Output:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

Solution: DFS

Time complexity: O(C(n, k))
Space complexity: O(k)

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> combine(int n, int k) {

vector<vector<int>> ans;

vector<int> cur;

function<void(int)> dfs = [&](int s) {

if (cur.size() == k) {

ans.push_back(cur);

return;

}

for (int i = s; i < n; ++i) {

cur.push_back(i + 1);

dfs(i + 1);

cur.pop_back();

}

};

dfs(0);

return ans;

}

};

花花酱 LeetCode 93. Restore IP Addresses

By zxi on September 30, 2019

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

Example:

Input: "25525511135"
Output: ["255.255.11.135", "255.255.111.35"]

Solution: DFS

The range of valid numbers is [0, 255]

Time complexity: O(3^4)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

vector<string> restoreIpAddresses(string s) {

vector<string> ans;

string ip;

dfs(0, s, ip, ans);

return ans;

}

private:

void dfs(int d, string s, string ip, vector<string> &ans) {

int l = s.length();

if (d == 4) {

if (l == 0) ans.push_back(ip);

return;

}

for (int i = 1; i <= min(3, s[0] == '0' ? 1 : l); i++) {

string ss = s.substr(0, i);

if (i == 3 && stoi(ss) > 255) return;

dfs(d + 1, s.substr(i), ip + (d == 0 ? "" : ".") + ss , ans);

}

};

Posts tagged as “DFS”

花花酱 LeetCode 1219. Path with Maximum Gold

Solution: DFS

C++

花花酱 LeetCode 46. Permutations

Solution: DFS

C++

Related Problems

花花酱 LeetCode 52. N-Queens II

Solution: DFS

C++

Related Problems

花花酱 LeetCode 77. Combinations

Solution: DFS

C++

Related Problems

花花酱 LeetCode 93. Restore IP Addresses

Solution: DFS

C++