和402一脉相承，单调栈+贪心。原理来源于高位的字符越小整体的字典序越小,所以对于存在重复的字符，只要该字符在栈尾，且新的元素比它更小，就自动pop

有效括号的升级版。计算最长的连续有效括号，计算括号是否有效通过左括号入栈，右括号弹出的操作可以实现，但是最长连续这里又一点tricky。其实是通过右括号也入栈来对有效的括号进行隔断。如果只有右括号，则右括号自动隔断前面的所有有效括号，这里stack=[-1]的初始位置是精髓

- 460 LFU：

- 160 相交链表：

- 382 链表随机节点：蓄水池算法，第K个节点有1/K的概率overwrite之前sample的元素

return

middle= self.find_middle(head)

l2 = middle.next

l1 = head

middle.next = None

l2 = self.reverse(l2)

result = self.merge_linklist(l1, l2)

@staticmethod

def find_middle(head):

slow =head

fast = head

while fast.next and fast.next.next:

fast = fast.next.next

slow = slow.next

return slow

@staticmethod

def reverse(head):

cur = head

newnode = None

while cur:

tmp = cur.next

cur.next = newnode

newnode = cur

cur = tmp

return newnode

@staticmethod

def merge_linklist(head1, head2):

while head1 and head2:

tmp1 = head1.next

tmp2 = head2.next

head1.next = head2

head1 = tmp1

head2 = tmp2

1. 这道题融合了三道题，快慢指针找中点，反转链表，合并两个链表

N个候选，第K个候选被采用的概率是1/K，

- K=3, p=1/3, 覆盖之前的概率是2/3，所以K=2的元素被选择的概率变成1/2 * 2/3 = 1/3

- 460 LFU：

- 160 相交链表：可以用常规接发， 找到长度，拼接成相同长度，然后遍历判断是否有相交节点

- 382 链表随机节点：蓄水池算法，第K个节点有1/K的概率overwrite之前sample的元素

class ListNode:

def __init__(self, val=0, next=None):

self.val = val

self.next = next

def __str__(self):

res = []

cur = self

while cur:

res.append(str(cur.val))

cur = cur.next

return '->'.join(res)

return

middle= self.find_middle(head)

l2 = middle.next

l1 = head

middle.next = None

l2 = self.reverse(l2)

result = self.merge_linklist(l1, l2)

@staticmethod

def find_middle(head):

slow =head

fast = head

while fast.next and fast.next.next:

fast = fast.next.next

slow = slow.next

return slow

@staticmethod

def reverse(head):

cur = head

newnode = None

while cur:

tmp = cur.next

cur.next = newnode

newnode = cur

cur = tmp

return newnode

@staticmethod

def merge_linklist(head1, head2):

while head1 and head2:

tmp1 = head1.next

tmp2 = head2.next

head1.next = head2

head1 = tmp1

head2 = tmp2

N个候选，第K个候选被采用的概率是1/K，

- K=3, p=1/3, 覆盖之前的概率是2/3，所以K=2的元素被选择的概率变成1/2 * 2/3 = 1/3

请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象

int get(int key) - 如果键存在于缓存中，则获取键的值，否则返回 -1。

void put(int key, int value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最近最久未使用 的键。

注意「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。

为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

示例：

输入：

["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]

[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]

输出：

[null, null, null, 1, null, -1, 3, null, -1, 3, 4]

解释：

// cnt(x) = 键 x 的使用计数

// cache=[] 将显示最后一次使用的顺序（最左边的元素是最近的）

LFUCache lFUCache = new LFUCache(2);

lFUCache.put(1, 1); // cache=[1,_], cnt(1)=1

lFUCache.put(2, 2); // cache=[2,1], cnt(2)=1, cnt(1)=1

lFUCache.get(1); // 返回 1

// cache=[1,2], cnt(2)=1, cnt(1)=2

lFUCache.put(3, 3); // 去除键 2 ，因为 cnt(2)=1 ，使用计数最小

// cache=[3,1], cnt(3)=1, cnt(1)=2

lFUCache.get(2); // 返回 -1（未找到）

lFUCache.get(3); // 返回 3

// cache=[3,1], cnt(3)=2, cnt(1)=2

lFUCache.put(4, 4); // 去除键 1 ，1 和 3 的 cnt 相同，但 1 最久未使用

// cache=[4,3], cnt(4)=1, cnt(3)=2

lFUCache.get(1); // 返回 -1（未找到）

lFUCache.get(3); // 返回 3

// cache=[3,4], cnt(4)=1, cnt(3)=3

lFUCache.get(4); // 返回 4

// cache=[3,4], cnt(4)=2, cnt(3)=3

提示：

0 <= capacity, key, value <= 104

最多调用 105 次 get 和 put 方法

进阶：你可以为这两种操作设计时间复杂度为 O(1) 的实现吗？