Description
In a linked list of size n
, where n
is even, the ith
node (0-indexed) of the linked list is known as the twin of the (n-1-i)th
node, if 0 <= i <= (n / 2) - 1
.
- For example, if
n = 4
, then node 0
is the twin of node 3
, and node 1
is the twin of node 2
. These are the only nodes with twins for n = 4
.
The twin sum is defined as the sum of a node and its twin.
Given the head
of a linked list with even length, return the maximum twin sum of the linked list.
Example 1:

1
2
3
4
5
6
| Input: head = [5,4,2,1]
Output: 6
Explanation:
Nodes 0 and 1 are the twins of nodes 3 and 2, respectively. All have twin sum = 6.
There are no other nodes with twins in the linked list.
Thus, the maximum twin sum of the linked list is 6.
|
Example 2:

1
2
3
4
5
6
7
| Input: head = [4,2,2,3]
Output: 7
Explanation:
The nodes with twins present in this linked list are:
- Node 0 is the twin of node 3 having a twin sum of 4 + 3 = 7.
- Node 1 is the twin of node 2 having a twin sum of 2 + 2 = 4.
Thus, the maximum twin sum of the linked list is max(7, 4) = 7.
|
Example 3:

1
2
3
4
| Input: head = [1,100000]
Output: 100001
Explanation:
There is only one node with a twin in the linked list having twin sum of 1 + 100000 = 100001.
|
Constraints:
- The number of nodes in the list is an even integer in the range
[2, 105]
. 1 <= Node.val <= 105
Solutions
Solution 1
Use the array directly to store the data for the corresponding node, and then look for the maximum twin sum.
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
| /**
* 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) {
int sum{};
ListNode* current = head;
std::vector<int> vec;
while (current) {
vec.push_back(current->val);
current = current->next;
}
int n = vec.size();
for (int i = 0; i < n; i++) {
auto re = vec[i] + vec[n - 1 - i];
sum = std::max(sum, re);
}
return sum;
}
};
|
Solution 2
Fast/slow pointer+reverse linked list
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
| class Solution {
public:
int pairSum(ListNode* head) {
ListNode* slow = head;
ListNode* fast = head->next;
while (fast->next) {
slow = slow->next;
fast = fast->next->next;
}
// 反转链表
ListNode* last = slow->next;
while (last->next) {
ListNode* cur = last->next;
last->next = cur->next;
cur->next = slow->next;
slow->next = cur;
}
int ans = 0;
ListNode* x = head;
ListNode* y = slow->next;
while (y) {
ans = max(ans, x->val + y->val);
x = x->next;
y = y->next;
}
return ans;
}
};
|