feat: add solutions to lc problem: No.2130

No.2130.Maximum Twin Sum of a Linked List

Author: yanglbme

solution/2100-2199/2130.Maximum Twin Sum of a Linked List/README.md

@@ -66,6 +66,14 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：链表转成列表（数组）求解**
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。
+
+**方法二：快慢指针 + 反转链表 + 双指针**
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -88,6 +96,39 @@ class Solution:
         return max(s[i] + s[-(i + 1)] for i in range(n >> 1))
 ```
 
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def pairSum(self, head: Optional[ListNode]) -> int:
+        def reverse(head):
+            dummy = ListNode()
+            curr = head
+            while curr:
+                next = curr.next
+                curr.next = dummy.next
+                dummy.next = curr
+                curr = next
+            return dummy.next
+
+        slow, fast = head, head.next
+        while fast and fast.next:
+            slow, fast = slow.next, fast.next.next
+        pa = head
+        q = slow.next
+        slow.next = None
+        pb = reverse(q)
+        ans = 0
+        while pa and pb:
+            ans = max(ans, pa.val + pb.val)
+            pa = pa.next
+            pb = pb.next
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -118,6 +159,52 @@ class Solution {
 }
 ```
 
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public int pairSum(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode pa = head;
+        ListNode q = slow.next;
+        slow.next = null;
+        ListNode pb = reverse(q);
+        int ans = 0;
+        while (pa != null) {
+            ans = Math.max(ans, pa.val + pb.val);
+            pa = pa.next;
+            pb = pb.next;
+        }
+        return ans;
+    }
+
+    private ListNode reverse(ListNode head) {
+        ListNode dummy = new ListNode();
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = dummy.next;
+            dummy.next = curr;
+            curr = next;
+        }
+        return dummy.next;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -143,6 +230,56 @@ public:
 };
 ```
 
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    int pairSum(ListNode* head) {
+        ListNode* slow = head;
+        ListNode* fast = head->next;
+        while (fast && fast->next)
+        {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        ListNode* pa = head;
+        ListNode* q = slow->next;
+        slow->next = nullptr;
+        ListNode* pb = reverse(q);
+        int ans = 0;
+        while (pa)
+        {
+            ans = max(ans, pa->val + pb->val);
+            pa = pa->next;
+            pb = pb->next;
+        }
+        return ans;
+    }
+
+    ListNode* reverse(ListNode* head) {
+        ListNode* dummy = new ListNode();
+        ListNode* curr = head;
+        while (curr)
+        {
+            ListNode* next = curr->next;
+            curr->next = dummy->next;
+            dummy->next = curr;
+            curr = next;
+        }
+        return dummy->next;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -168,6 +305,51 @@ func pairSum(head *ListNode) int {
 }
 ```
 
+```go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func pairSum(head *ListNode) int {
+	reverse := func(head *ListNode) *ListNode {
+		dummy := &ListNode{}
+		curr := head
+		for curr != nil {
+			next := curr.Next
+			curr.Next = dummy.Next
+			dummy.Next = curr
+			curr = next
+		}
+		return dummy.Next
+	}
+	slow, fast := head, head.Next
+	for fast != nil && fast.Next != nil {
+		slow, fast = slow.Next, fast.Next.Next
+	}
+	pa := head
+	q := slow.Next
+	slow.Next = nil
+	pb := reverse(q)
+	ans := 0
+	for pa != nil {
+		ans = max(ans, pa.Val+pb.Val)
+		pa = pa.Next
+		pb = pb.Next
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
 ### **TypeScript**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->