Bit Manipulation on Jiang Yi(姜祎)'s Homepage

506. Relative Ranks

Thu, 22 Aug 2024 21:36:01 +0800

Given an integer, flip all bits in its binary representation.

Intuition

Use XOR operation to complete this task.

Approach

We can use the XOR operation to complete this task. However, notice that we cannot simply use num ^ INT_MAX since the leading 1s are still 1s if num is too small. Instead, we need to compute the number of digits in num, and use the corresponding masks.

Notice that if 2^30 < num <= 2^31-1, in this case the corresponding mask will exceeds the integer ranges, thus we use INT_MAX directly in this case.

Complexity

Time complexity: Compute the digits of a number.
$$O(\log n)$$
Space complexity: No extra spaces needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 int findComplement(int num) {
 int num_bits = 0;
 int temp = num;
 while (temp) {
 temp >>= 1;
 ++num_bits;
 }
 if (num_bits == 31) {
 return num ^ INT_MAX;
 }
 int mask = (1 << num_bits) - 1;
 return num ^ mask;
 }
};

Reference

leetcode 476

3068. Find the Maximum Sum of Node Values

Thu, 09 May 2024 20:21:07 +0800

Given a graph and an integer $k$, where the nodes represent values, we can choose an edge, and perform XOR operations on its nodes corresponding to $k$. The goal is the find the maximum sum of the values after 0 or more XOR operations.

Intuition

Since XOR operations satisfies the property that a XOR b XOR b = a, we can record the gain after XOR operation on an edge and finally obtain the result.

Approach

We use total_sum to record the sum of the values of the original trees.

Then for each node, we perform the XOR operation and record the change if the change > 0, and this change requires one operation, which we add to count. Meanwhile, we use positive_min and negative_max to record the minimum absolute change for reverting use.

Now after all nodes are computed, we need to compute the result.

If count is even, it means the operations satisfied the requirement that the nodes of an edge changes simultaneously
If count is odd, then there is one invalid operation and we need to revert the operation. To make the final sum maximum, we can either subtract the positive_min or add negative_max, the result is then obtained by taking the maximum of them.

Complexity

Time complexity: iterate the array once.
$$O(n)$$
Space complexity: No extra spaces are needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 long long maximumValueSum(vector<int>& nums, int k,
 vector<vector<int>>& edges) {
 long long total_sum = 0;
 int count = 0;
 int positive_min = INT_MAX, negative_max = INT_MIN;
 for (int num : nums) {
 int new_num = num ^ k;
 total_sum += num;
 int change = new_num - num;
 if (change > 0) {
 positive_min = min(positive_min, change);
 total_sum += change;
 ++count;
 } else {
 negative_max = max(negative_max, change);
 }
 }

 if (count % 2 == 0)
 return total_sum;
 return max(total_sum - positive_min, total_sum + negative_max);
 }
};

Reference

Leetcode

1915. Number of Wonderful Substrings

Thu, 02 May 2024 10:51:29 +0800

Given a string ,count the number of wonderful substrings, where a wonderful string is a string that at most one character appears in an odd number of times.

Intuition

We use the prefix sum and bitwise representation to solve the problem. The idea is that every string can be represented by a state, and we can count the number of wonderful substrings by performing operations among states

Approach

According to the hint and the problem description, we have:

there are $10$ possible variables, which represent a to j
we only care about if the variable appears in odd number of times or in even number of times, which means that each variable has $2$ possible states.

so the number of overall possible states is $2^10=1024$. We define the prefix substring as prefix[i] = s[1...i].

For each substring, we can represent the state of the prefix as an index of the array, that is, state(prefix[i]) is a number between 0 and 1023, with each byte representing if the corresponding character appears in odd number of times (1) or in even number of times (0). A wonderful string is then defined as a string whose state representation is 0 or a power of 2.

now the substring s[i...j] is defined as prefix[j]-prefix[i], in state representations, there are three cases:

if one character appears in odd number of times in both prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (1, 1) -> 0
if one character appears in even number of times in both prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (0, 0) -> 0
If one character appears in even number of times in one prefix substring, and appears in odd number of times in the other prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (1, 0) -> 1

so, according to analysis, the minus operation in string corresponding to the XOR operation in states. That is, the state of s[i...j] is given by state(s[i...j])=state(prefix[j]) XOR state(prefix[i]).

Note that there is also a simplification since if a XOR b = c, then a XOR c = b. Instead of using a for loop to compute all substrings that ended with character j:

1
2
3
4
5


for (int i = 0; i <j; ++i) {
 // substring s[i...j]
 int substr_state = state[j] ^ state[i];
 // check if substr is a wonderful substring
}

with the property of XOR, wo directly check if state(prefix[j]) XOR 2^k exists, that is:

1
2
3
4


for (int i = 0; i < 10; ++i) {
 int state = state[j] ^ (1 << i);
 // check if state exists and add them.
}

Complexity

Time complexity: iterate string once
$$O(n)$$
Space complexity: stores the state representation.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 long long wonderfulSubstrings(string word) {
 vector<int> bits(1024);
 bits[0] = 1;
 long long result = 0;
 int prefix = 0;
 for (char c: word) {
 prefix ^= 1 << (c - 'a');
 result += bits[prefix];
 for (int i = 0; i < 10; ++i) {
 result += bits[prefix ^ (1 << i)];
 }
 ++bits[prefix];
 }
 return result;
 }
};

References:

Leetcode

2997. Minimum Number of Operations to Make Array XOR Equal to K

Mon, 29 Apr 2024 21:16:53 +0800

Given an integer array, we can flip one bit of one element of the array at every step, we asked to compute the minimum flips, such that the XOR of all elements of the array is equal to the given integer $k$.

Intuition

XOR of multiple bits is always equal to either 1 or 0, and changes one of the input bits will cause the result change to the other one.

Approach

We first compute the XOR of all elements of the array, then we compare bit by bit with the XOR result and the given k, utils all bits becomes the same.

Complexity

Time complexity: compute the XOR result
$$O(n)$$
Space complexity: No extra spaces are needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 int minOperations(vector<int>& nums, int k) {
 int result = nums[0];
 for (int i = 1; i < nums.size(); ++i) {
 result ^= nums[i];
 }
 vector<int> bits_result, bits_k;
 while (k) {
 bits_k.push_back(k % 2);
 k /= 2;
 }
 while (result) {
 bits_result.push_back(result % 2);
 result /= 2;
 }
 int count = 0;
 int i = 0;
 for (; i < bits_result.size() && i < bits_k.size(); ++i) {
 if (bits_result[i] != bits_k[i])
 ++count;
 }
 for (; i < bits_result.size(); ++i) {
 if (bits_result[i] == 1)
 ++count;
 }
 for (; i < bits_k.size(); ++i) {
 if (bits_k[i] == 1)
 ++count;
 }
 return count;
 }
};

405. Convert a Number to Hexadecimal

Sun, 14 Apr 2024 21:06:34 +0800

Intuition

Just use the transformation algorithm from decimal to hexadecimal

Approach

Simulation by doing the following:

compute remain = num % 16, add remain to the result (push_back)
update num = (num - remainder) / 16
repeat step 1 and step 2 until num is 0

Notice that when num < 0, we need use its complement.

Complexity

Time complexity: the loop depends on the number of digits of num.
$$O(\log n)$$
Space complexity:
$$ O(1) $$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 string toHex(long num) {
 if (num == 0) return "0";
 if (num < 0) num = INT_MAX + num + 2 + INT_MAX;
 string result;
 while (num) {
 int divide = num % 16;
 num = (num - divide) / 16;
 if (divide < 10) result += ('0' + divide);
 else result += ('a' + (divide - 10));
 }
 reverse(result.begin(), result.end());
 return result;
 }
};