Create XOR Triangle Explanation.txt

Author: MathProgrammer

2023/Contests/Div 2/810/Explanations/XOR Triangle Explanation.txt

@@ -0,0 +1,179 @@
+1. Fact - A triangle is good only if the pairwise AND is non-0. 
+
+Proof - x+y = x^y + 2(x&y) 
+
+x^y counts all bits which are set either in x or y. 
+x&y counts all bits which are set in both x and y and therefore needs to be multiplied by 2. 
+
+We also know that if x, y and z form a triangle, then x + y > z 
+
+Let the integers we choose be (a, b, c) 
+
+(a^b) + (b^c) = (a^b^b^c) + 2[(a^b)&(b^c)] = 
+(a^b) + (b^c) = (a^c) + 2[(a^b)&(b^c)] 
+
+(a^b) + (b^c) > (a^c) => (a^b)&(b^c) > 0 
+
+We can prove this cyclically for all 3 variables. 
+
+-----
+
+We have an easier task now. 
+We now have to count the nummber of integers (a, b, c) such that 1 <= a, b, c <= n and 
+
+1. (a^b)&(b^c) > 0 
+2. (b^c)&(c^a) > 0 
+3. (c^a)&(a^b) > 0 
+
+We will use Digit DP with the observation that all of a, b and c will match some prefix of n (possibly of length 0). 
+
+-----
+
+We will represent the triplet as T[0], T[1], T[2] for convenience instead of (a, b, c). 
+
+The state of the DP is f(i, prefix_mask, condition_mask). 
+This represents the number of triplets of consisting of the bits [0, i - 1] of N satsifying the two masks. 
+The reason we are using i to represent the triplets ending with [i - 1] bits is because the string is 0-indexed. 
+It might have been more intuitive if it were 1-indexed. 
+
+Here is the elaborate meaning of each variable.
+
+1. i represents the bit of n where we are at now. 
+2. prefix_mask is a mask of 3 bits represnting whether each member of the triplet
+ is either = or less than the prefix of [0, i - 1]
+3. condition_mask is a mask of 3 bits reprsenting which of 3 conditions is already true in the prefix of length [0, i - 1]
+
+Elaborating on how the masks are created. 
+Let us suppose 
+1. The first [0, i - 1] of T[0] match the first [0, i - 1] bits of N 
+2. The first [0, i - 1] of T[1] is smaller than N
+3. The first [0, i - 1] of T[2] match the first [0, i - 1] bits of N 
+
+The prefix mask is 101 
+
+The condition mask is also similar. A mask of 110 means two of the conditions required for being a good triangle are satisfied. 
+-----
+
+This is a DP where it is easier to calculate the states f(i + 1, _, _) which f(i, _, _) will contribute to then 
+build f(i, _, _) from f(i - 1, _, _)
+
+We will iterate over all possibilities of the i-th bit of T[0], T[1], T[2] 
+
+If the first [0, i - 1] bits of N are equal to the first [0, i - 1] bits of T[0], the i-th bit of T[0] can only be [0, N[i]]
+If the first [0, i - 1] bits of N are smaller than the first [0, i - 1] bits of T[0], the i-th bit of T[0] can be both 0 or 1.
+
+Recalculate the new prefix_mask and new condition_mask and accordingly do 
+
+f(i + 1, new_prefix_mask, new_condition_mask) += f(i, prefix_mask, condition_mask)
+
+-----
+
+Let us discuss the base case and the final answer 
+
+Let the base case be f(0, 111, 0) = 1
+
+When we consider the empty string, it is not possible for a, b, c to be < N so the prefix mask has to be 111 only. 
+None of the conditions are met so the condition mask be 0 
+
+The empty string N corresponds to prefix 111 and condition 0. 
+
+f(0, _, _) = 0 for all other values.
+
+----
+
+The final answer is when all the bits are used so i = N.size() 
+The prefix mask can be any legal value 
+The condition mask is 111 
+
+Answer = Sum f(N.size(), p, 111) over all legal values of prefix_mask
+
+
+------
+
+Time limit is tight so do some language level optimizations like global arrays.
+
+------
+
+
+int is_bit_set(int n, int bit)
+{
+    return ( (n&(1 << bit)) != 0 );
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string S;
+    cin >> S;
+
+    no_of_triplets[0][MAX_MASK][0] = 1;
+    for(int i = 0; i < S.size(); i++)
+    {
+        int prefix = i - 1;
+        for(int prefix_match = 0; prefix_match <= MAX_MASK; prefix_match++)
+        {
+            for(int condition_met = 0; condition_met <= MAX_MASK; condition_met++)
+            {
+                for(int bit = 0; bit < NO_OF_TRIANGLE_SIDES; bit++)
+                {
+                    limit[bit] = (is_bit_set(prefix_match, bit) ? S[i] : '1') - '0';
+                }
+
+                for(next_bit[0] = 0; next_bit[0] <= limit[0]; next_bit[0]++)
+                {
+                    for(next_bit[1] = 0; next_bit[1] <= limit[1]; next_bit[1]++)
+                    {
+                        for(next_bit[2] = 0; next_bit[2] <= limit[2]; next_bit[2]++)
+                        {
+
+                            for(int bit = 0; bit < NO_OF_TRIANGLE_SIDES; bit++)
+                            {
+                                triangle_sides[bit] = next_bit[bit]^next_bit[(bit + 1)%NO_OF_TRIANGLE_SIDES];
+                            }
+
+                            int next_prefix_match = 0;
+                            for(int bit = 0; bit < NO_OF_TRIANGLE_SIDES; bit++)
+                            {
+                                if(is_bit_set(prefix_match, bit) && next_bit[bit] == S[i] - '0')
+                                {
+                                    next_prefix_match |= (1 << bit);
+                                }
+                            }
+
+                            int next_condition_met = 0;
+                            for(int bit = 0; bit < NO_OF_TRIANGLE_SIDES; bit++)
+                            {
+                                int condition_here = (triangle_sides[bit]&triangle_sides[(bit + 1)%NO_OF_TRIANGLE_SIDES] != 0);
+                                if(is_bit_set(condition_met, bit) || condition_here)
+                                {
+                                    next_condition_met |= (1 << bit);
+                                }
+                            }
+
+                            no_of_triplets[i + 1][next_prefix_match][next_condition_met] += no_of_triplets[i][prefix_match][condition_met];
+                            no_of_triplets[i + 1][next_prefix_match][next_condition_met] %= MOD;
+
+                            /*cout << "F(" << i + 1 << "," << next_prefix_match << "," << next_condition_met << ") = "
+                            << no_of_triplets[i + 1][next_prefix_match][next_condition_met] << " added "
+                            << "F(" << i << "," << prefix_match << "," << condition_met << ") = "
+                            << no_of_triplets[i][prefix_match][condition_met] << " Current "
+                            << next_bit[0] << " " << next_bit[1] << " " << next_bit[2] << "\n";*/
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    long long answer = 0;
+    for(int prefix_match = 0, all_conditions_met = MAX_MASK; prefix_match <= MAX_MASK; prefix_match++)
+    {
+        answer += no_of_triplets[S.size()][prefix_match][all_conditions_met];
+        answer %= MOD;
+    }
+
+    cout << answer << "\n";
+    return 0;
+}