LeetCode 2130. Maximum Twin Sum of a Linked List - 亚马逊高频题24

最新推荐文章于 2022-07-11 18:09:57 发布

CP Coding

最新推荐文章于 2022-07-11 18:09:57 发布

阅读量878

点赞数 1

分类专栏：亚马逊高频题 Leetcode刷题笔记链表Linked List 文章标签： leetcode 算法 python 链表

本文链接：https://blog.csdn.net/hgq522/article/details/123913278

版权

Leetcode刷题笔记同时被 3 个专栏收录

198 篇文章 1 订阅

订阅专栏

亚马逊高频题

31 篇文章 6 订阅

订阅专栏

链表Linked List

31 篇文章 0 订阅

订阅专栏

该博客讨论了一种特殊情况的链表问题，其中偶数长度的链表中的节点有双胞胎对应节点。双胞胎节点的和定义为它们的值之和，任务是找到最大的双胞胎和。解决方案涉及使用快慢指针分割链表，并通过栈来计算所有可能的双胞胎节点对的和，以找到最大值。

摘要由CSDN通过智能技术生成

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:

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:

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:

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

题目说一个链表含有n个节点，n一定为偶数，把第i个节点（链表头为第0个节点）与第(n/2) +i个节点称为双胞胎节点，两个双胞胎节点的和就称为双胞胎和。要求找出链表中最大的双胞胎和。

根据题意，其实就是把一个具有n个（n为偶数）的链表从正中间把链表分成两部分，即为两个节点个数相等的子链表，那么所有的双胞胎节点就是，第一个子链表从头到尾与第二个链表从尾到头一一对应构成一对对双胞胎节点，从这些匹配的双胞胎节点中找出和最大的那一对。

综上所述，这题的代码实现应该分为两个部分：

1）把链表中间分成两个长度相同的子链表，最快的方法就是链表Linked List系列里最常用的快慢指针法。用两个指针指向链表头，慢指针每次移动一步而快指针每次移动两步，当快指针走到链表尾时，慢指针刚好走一半即把整个链表分成了两个部分，慢指针所指的节点就是第二部分的开头节点。

2）求所有双胞胎节点和，找出最大值。第一步已经把链表分成了两部分，根据题目对双胞胎节点的定义，双胞胎节点就是：第一部分的最后一个节点与第二部分的第一个节点，第一部分的倒数第二个节点与第二部分的第二个节点，......，第一部分的第一个节点与第二部分的最后一个节点。很显然这里可以一个堆栈来实现，把第一部分的节点按从头到尾的顺序放入堆栈中，再依次取出与第二部分的节点从头到尾的顺序一一匹配构成双胞胎节点。

class Solution:
    def pairSum(self, head: Optional[ListNode])->int:
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        res = 0
        st = []
        while head != slow:
            st.append(head)
            head = head.next
        while st:
            res = max(res, st.pop().val + slow.val)
            slow = slow.next
        return res