Merge branch 'doocs:main' into main

Author: Nothing-avil

.github/workflows/deploy.yml

@@ -21,6 +21,8 @@ jobs:
           path: mkdocs
       - run: |
           mv -f mkdocs/* .
+          mv solution/CONTEST_README.md docs/contest.md
+          mv solution/CONTEST_README_EN.md docs-en/contest.md
       - name: Configure Git Credentials
         run: |
           git config user.name github-actions[bot]

.gitignore

@@ -5,12 +5,6 @@
 .cache
 /node_modules
 /solution/result.json
-/solution/contest.json
-/solution/contest_list.json
-/solution/raw.json
-/lcof/lcof.json
-/lcof/lcof_list.json
-/lcci/lcci.json
 /solution/__pycache__
 /solution/.env
 *.iml

solution/1700-1799/1780.Check if Number is a Sum of Powers of Three/README_EN.md

@@ -43,7 +43,13 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Mathematical Analysis
+
+We find that if a number $n$ can be expressed as the sum of several "different" powers of three, then in the ternary representation of $n$, each digit can only be $0$ or $1$.
+
+Therefore, we convert $n$ to ternary and then check whether each digit is $0$ or $1$. If not, then $n$ cannot be expressed as the sum of several powers of three, and we directly return `false`; otherwise, $n$ can be expressed as the sum of several powers of three, and we return `true`.
+
+The time complexity is $O(\log_3 n)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md

@@ -54,7 +54,15 @@ The answers for each of the queries are as follows:
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Hash Table + Sorting + Binary Search
+
+From the problem, we know that the number of edges connected to the point pair $(a, b)$ is equal to the "number of edges connected to $a$" plus the "number of edges connected to $b$", minus the number of edges connected to both $a$ and $b$.
+
+Therefore, we can first use the array $cnt$ to count the number of edges connected to each point, and use the hash table $g$ to count the number of each point pair.
+
+Then, for each query $q$, we can enumerate $a$. For each $a$, we can find the first $b$ that satisfies $cnt[a] + cnt[b] > q$ through binary search, add the number to the current query answer, and then subtract some duplicate edges.
+
+The time complexity is $O(q \times (n \times \log n + m))$, and the space complexity is $O(n + m)$. Where $n$ and $m$ are the number of points and edges respectively, and $q$ is the number of queries.
 
 <!-- tabs:start -->
 

solution/1700-1799/1787.Make the XOR of All Segments Equal to Zero/README_EN.md

@@ -44,7 +44,33 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+Notice that after modifying the array `nums`, the XOR result of any interval of length $k$ is equal to $0$. Therefore, for any $i$, we have:
+
+$$
+nums[i] \oplus nums[i+1] \oplus ... \oplus nums[i+k-1] = 0
+$$
+
+and
+
+$$
+nums[i+1] \oplus nums[i+2] \oplus ... \oplus nums[i+k] = 0
+$$
+
+Combining the two equations and the properties of XOR operation, we can get $nums[i] \oplus nums[i+k] = 0$, which means $nums[i]=nums[i+k]$. We find that the elements in the modified array `nums` are cyclic with a period of $k$. The numbers congruent modulo $k$ can only take a fixed value, and the XOR result of the first $k$ numbers must be $0$.
+
+First, we count each group $i$, the number of elements in each group is $size[i]$, and the number of elements with value $v$ in each group is $cnt[i][v]$.
+
+Next, we can use dynamic programming to solve it. Let $f[i][j]$ represent the minimum number of modifications with the XOR sum of the first $i+1$ groups being $j$. Since the value of each group is only related to the value of the previous group, we can use a rolling array to optimize the space complexity.
+
+Redefine $f[j]$ to represent the minimum number of modifications with the XOR sum being $j$ when processing to the current group.
+
+When transitioning states, there are two choices: one is to modify all the numbers in the current group to the same value, then we can choose the one with the smallest previous cost, plus the number of elements $size[i]$ in this group, the cost is $\min{f[0..n]} + size[i]$; the second is to modify all the numbers in the current group to some value $j$ of the current group, enumerate $j$ and the element $v$ of the current group, then the previous cost is $f[j \oplus v]$, the cost is $f[j \oplus v] + size[i] - cnt[i][v]$. Take the minimum value.
+
+The final answer is $f[0]$.
+
+The time complexity is $O(2^{C}\times k + n)$. Where $n$ is the length of the array `nums`, and $C$ is the maximum number of bits in the binary representation of the elements in `nums`, in this problem $C=10$.
 
 <!-- tabs:start -->