feat: add solutions to lc problem: No.1634

No.1634.Add Two Polynomials Represented as Linked Lists

Author: yanglbme

solution/1600-1699/1632.Rank Transform of a Matrix/README.md

@@ -74,13 +74,13 @@ matrix[1][1] 的秩为 3 ，因为 matrix[1][1] > matrix[0][1]， matrix[1][1] >
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：贪心 + 并查集**
+**方法一：排序 + 并查集**
 
-先考虑简化情形：没有相同的元素。那么显然最小的元素的秩为 $1$，第二小的元素则要考虑是否和最小元素同行或同列。于是得到贪心解法：从小到大遍历元素，并维护每行、每列的最大秩，该元素的秩即为同行、同列的最大秩加 $1$。见题目：[2371. Minimize Maximum Value in a Grid](/solution/2300-2399/2371.Minimize%20Maximum%20Value%20in%20a%20Grid/README.md)。
+我们先考虑简化情形：没有相同的元素。那么显然最小的元素的秩为 $1$，第二小的元素则要考虑是否和最小元素同行或同列。于是得到贪心解法：从小到大遍历元素，并维护每行、每列的最大秩，该元素的秩即为同行、同列的最大秩加 $1$。见题目：[2371. 最小化网格中的最大值](/solution/2300-2399/2371.Minimize%20Maximum%20Value%20in%20a%20Grid/README.md)。
 
 存在相同元素时则较为复杂，假设两个相同元素同行（或同列），那么就要考虑到两个元素分别对应的行（或列）的最大秩。同时还可能出现联动，比如元素 `a` 和 `b` 同行，`b` 和 `c` 同列，那么要同时考虑这三个元素。
 
-这种联动容易想到并查集，于是用并查集将相同元素分为几个连通块，对于每个连通块，里面所有元素对应的行或列的最大秩加 $1$，即为该连通块内所有元素的秩。
+这种联动容易想到并查集，于是我们用并查集将元素分为几个连通块，对于每个连通块，里面所有元素对应的行或列的最大秩加 $1$，即为该连通块内所有元素的秩。
 
 时间复杂度 $O(m \times n \times \log(m \times n))$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数。
 

solution/1600-1699/1634.Add Two Polynomials Represented as Linked Lists/README.md

@@ -72,7 +72,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-遍历两多项式链表，比较节点间的 power 值，进行节点串联。若两节点 coefficient 值相加和为 0，不串联此合并的节点。
+**方法一：遍历链表**
+
+我们可以同时遍历两个链表，根据指数大小关系，将节点添加到结果链表中。
+
+最后，如果链表 $1$ 或链表 $2$ 还有剩余节点，将其添加到结果链表中。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为两个链表中节点数的较大值。
 
 <!-- tabs:start -->
 
@@ -90,26 +96,24 @@
 
 
 class Solution:
-    def addPoly(self, poly1: 'PolyNode', poly2: 'PolyNode') -> 'PolyNode':
-        dummy = PolyNode()
-        cur = dummy
-        while poly1 or poly2:
-            if poly1 is None or (poly2 and poly2.power > poly1.power):
-                cur.next = poly2
-                cur = cur.next
-                poly2 = poly2.next
-            elif poly2 is None or (poly1 and poly1.power > poly2.power):
-                cur.next = poly1
-                cur = cur.next
+    def addPoly(self, poly1: "PolyNode", poly2: "PolyNode") -> "PolyNode":
+        dummy = curr = PolyNode()
+        while poly1 and poly2:
+            if poly1.power > poly2.power:
+                curr.next = poly1
                 poly1 = poly1.next
+                curr = curr.next
+            elif poly1.power < poly2.power:
+                curr.next = poly2
+                poly2 = poly2.next
+                curr = curr.next
             else:
-                val = poly1.coefficient + poly2.coefficient
-                if val != 0:
-                    cur.next = PolyNode(x=val, y=poly1.power)
-                    cur = cur.next
+                if c := poly1.coefficient + poly2.coefficient:
+                    curr.next = PolyNode(c, poly1.power)
+                    curr = curr.next
                 poly1 = poly1.next
                 poly2 = poly2.next
-        cur.next = None
+        curr.next = poly1 or poly2
         return dummy.next
 ```
 
@@ -126,40 +130,188 @@ class Solution:
 
  *     PolyNode() {}
  *     PolyNode(int x, int y) { this.coefficient = x; this.power = y; }
- *     PolyNode(int x, int y, PolyNode next) { this.coefficient = x; this.power = y; this.next =
- next; }
+ *     PolyNode(int x, int y, PolyNode next) { this.coefficient = x; this.power = y; this.next = next; }
  * }
  */
 
-class Solution {
+ class Solution {
     public PolyNode addPoly(PolyNode poly1, PolyNode poly2) {
         PolyNode dummy = new PolyNode();
-        PolyNode cur = dummy;
-        while (poly1 != null || poly2 != null) {
-            if (poly1 == null || (poly2 != null && poly2.power > poly1.power)) {
-                cur.next = poly2;
-                cur = cur.next;
+        PolyNode curr = dummy;
+        while (poly1 != null && poly2 != null) {
+            if (poly1.power > poly2.power) {
+                curr.next = poly1;
+                poly1 = poly1.next;
+                curr = curr.next;
+            } else if (poly1.power < poly2.power) {
+                curr.next = poly2;
                 poly2 = poly2.next;
-            } else if (poly2 == null || (poly1 != null && poly1.power > poly2.power)) {
-                cur.next = poly1;
-                cur = cur.next;
+                curr = curr.next;
+            } else {
+                int c = poly1.coefficient + poly2.coefficient;
+                if (c != 0) {
+                    curr.next = new PolyNode(c, poly1.power);
+                    curr = curr.next;
+                }
+                poly1 = poly1.next;
+                poly2 = poly2.next;
+            }
+        }
+        if (poly1 == null) {
+            curr.next = poly2;
+        }
+        if (poly2 == null) {
+            curr.next = poly1;
+        }
+        return dummy.next;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * Definition for polynomial singly-linked list->
+ * struct PolyNode {
+ *     int coefficient, power;
+ *     PolyNode *next;
+ *     PolyNode(): coefficient(0), power(0), next(nullptr) {};
+ *     PolyNode(int x, int y): coefficient(x), power(y), next(nullptr) {};
+ *     PolyNode(int x, int y, PolyNode* next): coefficient(x), power(y), next(next) {};
+ * };
+ */
+
+class Solution {
+public:
+    PolyNode* addPoly(PolyNode* poly1, PolyNode* poly2) {
+        PolyNode* dummy = new PolyNode();
+        PolyNode* curr = dummy;
+        while (poly1 && poly2) {
+            if (poly1->power > poly2->power) {
+                curr->next = poly1;
+                poly1 = poly1->next;
+                curr = curr->next;
+            } else if (poly1->power < poly2->power) {
+                curr->next = poly2;
+                poly2 = poly2->next;
+                curr = curr->next;
+            } else {
+                int c = poly1->coefficient + poly2->coefficient;
+                if (c != 0) {
+                    curr->next = new PolyNode(c, poly1->power);
+                    curr = curr->next;
+                }
+                poly1 = poly1->next;
+                poly2 = poly2->next;
+            }
+        }
+        if (!poly1) {
+            curr->next = poly2;
+        }
+        if (!poly2) {
+            curr->next = poly1;
+        }
+        return dummy->next;
+    }
+};
+```
+
+### **C#**
+
+```cs
+/**
+ * Definition for polynomial singly-linked list.
+ * public class PolyNode {
+ *     public int coefficient, power;
+ *     public PolyNode next;
+ *
+ *     public PolyNode(int x=0, int y=0, PolyNode next=null) {
+ *         this.coefficient = x;
+ *         this.power = y;
+ *         this.next = next;
+ *     }
+ * }
+ */
+
+public class Solution {
+    public PolyNode AddPoly(PolyNode poly1, PolyNode poly2) {
+        PolyNode dummy = new PolyNode();
+        PolyNode curr = dummy;
+        while (poly1 != null && poly2 != null) {
+            if (poly1.power > poly2.power) {
+                curr.next = poly1;
                 poly1 = poly1.next;
+                curr = curr.next;
+            } else if (poly1.power < poly2.power) {
+                curr.next = poly2;
+                poly2 = poly2.next;
+                curr = curr.next;
             } else {
-                int val = poly1.coefficient + poly2.coefficient;
-                if (val != 0) {
-                    cur.next = new PolyNode(val, poly1.power);
-                    cur = cur.next;
+                int c = poly1.coefficient + poly2.coefficient;
+                if (c != 0) {
+                    curr.next = new PolyNode(c, poly1.power);
+                    curr = curr.next;
                 }
                 poly1 = poly1.next;
                 poly2 = poly2.next;
             }
         }
-        cur.next = null;
+        if (poly1 == null) {
+            curr.next = poly2;
+        }
+        if (poly2 == null) {
+            curr.next = poly1;
+        }
         return dummy.next;
     }
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for polynomial singly-linked list.
+ * function PolyNode(x=0, y=0, next=null) {
+ *     this.coefficient = x;
+ *     this.power = y;
+ *     this.next = next;
+ * }
+ */
+
+/**
+ * @param {PolyNode} poly1
+ * @param {PolyNode} poly2
+ * @return {PolyNode}
+ */
+var addPoly = function (poly1, poly2) {
+    const dummy = new PolyNode();
+    let curr = dummy;
+    while (poly1 && poly2) {
+        if (poly1.power > poly2.power) {
+            curr.next = poly1;
+            poly1 = poly1.next;
+            curr = curr.next;
+        } else if (poly1.power < poly2.power) {
+            curr.next = poly2;
+            poly2 = poly2.next;
+            curr = curr.next;
+        } else {
+            const c = poly1.coefficient + poly2.coefficient;
+            if (c != 0) {
+                curr.next = new PolyNode(c, poly1.power);
+                curr = curr.next;
+            }
+            poly1 = poly1.next;
+            poly2 = poly2.next;
+        }
+    }
+    curr.next = poly1 || poly2;
+    return dummy.next;
+};
+```
+
 ### **...**
 
 ```