Description
You are given an array nums of positive integers and a positive integer k.
A subset of nums is beautiful if it does not contain two integers with an absolute difference equal to k.
Return the number of non-empty beautiful subsets of the array nums.
A subset of nums is an array that can be obtained by deleting some (possibly none) elements from nums. Two subsets are different if and only if the chosen indices to delete are different.
Example 1:
Input: nums = [2,4,6], k = 2
Output: 4
Explanation: The beautiful subsets of the array nums are: [2], [4], [6], [2, 6].
It can be proved that there are only 4 beautiful subsets in the array [2,4,6].
Example 2:
Input: nums = [1], k = 1
Output: 1
Explanation: The beautiful subset of the array nums is [1].
It can be proved that there is only 1 beautiful subset in the array [1].
Constraints:
1 <= nums.length <= 181 <= nums[i], k <= 1000
Solutions
Solution 1: Counting + Backtracking
We use a hash table or array cnt to record the currently selected numbers and their counts, and use ans to record the number of beautiful subsets. Initially, ans = -1 to exclude the empty set.
For each number x in the array nums, we have two choices:
- Do not select x, and directly recurse to the next number;
- Select x, and check if x + k and x - k have already appeared in cnt. If neither has appeared, we can select x. In this case, we increment the count of x by one, recurse to the next number, and then decrement the count of x by one.
Finally, we return ans.
The time complexity is O(2n), and the space complexity is O(n). Where n is the length of the array nums.
PythonJavaC++GoTypeScriptC#
class Solution:
def beautifulSubsets(self, nums: List[int], k: int) -> int:
def dfs(i: int) -> None:
nonlocal ans
if i >= len(nums):
ans += 1
return
dfs(i + 1)
if cnt[nums[i] + k] == 0 and cnt[nums[i] - k] == 0:
cnt[nums[i]] += 1
dfs(i + 1)
cnt[nums[i]] -= 1
ans = -1
cnt = Counter()
dfs(0)
return ans(code-box)
class Solution {
private int[] nums;
private int[] cnt = new int[1010];
private int ans = -1;
private int k;
public int beautifulSubsets(int[] nums, int k) {
this.k = k;
this.nums = nums;
dfs(0);
return ans;
}
private void dfs(int i) {
if (i >= nums.length) {
++ans;
return;
}
dfs(i + 1);
boolean ok1 = nums[i] + k >= cnt.length || cnt[nums[i] + k] == 0;
boolean ok2 = nums[i] - k < 0 || cnt[nums[i] - k] == 0;
if (ok1 && ok2) {
++cnt[nums[i]];
dfs(i + 1);
--cnt[nums[i]];
}
}
}(code-box)
class Solution {
public:
int beautifulSubsets(vector<int>& nums, int k) {
int ans = -1;
int cnt[1010]{};
int n = nums.size();
auto dfs = [&](this auto&& dfs, int i) {
if (i >= n) {
++ans;
return;
}
dfs(i + 1);
bool ok1 = nums[i] + k >= 1010 || cnt[nums[i] + k] == 0;
bool ok2 = nums[i] - k < 0 || cnt[nums[i] - k] == 0;
if (ok1 && ok2) {
++cnt[nums[i]];
dfs(i + 1);
--cnt[nums[i]];
}
};
dfs(0);
return ans;
}
};(code-box)
func beautifulSubsets(nums []int, k int) int {
ans := -1
n := len(nums)
cnt := [1010]int{}
var dfs func(int)
dfs = func(i int) {
if i >= n {
ans++
return
}
dfs(i + 1)
ok1 := nums[i]+k >= len(cnt) || cnt[nums[i]+k] == 0
ok2 := nums[i]-k < 0 || cnt[nums[i]-k] == 0
if ok1 && ok2 {
cnt[nums[i]]++
dfs(i + 1)
cnt[nums[i]]--
}
}
dfs(0)
return ans
}(code-box)
function beautifulSubsets(nums: number[], k: number): number {
let ans: number = -1;
const cnt: number[] = new Array(1010).fill(0);
const n: number = nums.length;
const dfs = (i: number) => {
if (i >= n) {
++ans;
return;
}
dfs(i + 1);
const ok1: boolean = nums[i] + k >= 1010 || cnt[nums[i] + k] === 0;
const ok2: boolean = nums[i] - k < 0 || cnt[nums[i] - k] === 0;
if (ok1 && ok2) {
++cnt[nums[i]];
dfs(i + 1);
--cnt[nums[i]];
}
};
dfs(0);
return ans;
}(code-box)
public class Solution {
public int BeautifulSubsets(int[] nums, int k) {
int ans = -1;
int[] cnt = new int[1010];
int n = nums.Length;
void Dfs(int i) {
if (i >= n) {
ans++;
return;
}
Dfs(i + 1);
bool ok1 = nums[i] + k >= 1010 || cnt[nums[i] + k] == 0;
bool ok2 = nums[i] - k < 0 || cnt[nums[i] - k] == 0;
if (ok1 && ok2) {
cnt[nums[i]]++;
Dfs(i + 1);
cnt[nums[i]]--;
}
}
Dfs(0);
return ans;
}
}(code-box)
