Leetcode 3710. Maximum Partition Factor

[Leetcode 3710. Maximum Partition Factor](#Leetcode 3710. Maximum Partition Factor)
- [1. 解题思路](#1. 解题思路)
- [2. 代码实现](#2. 代码实现)

题目链接：3710. Maximum Partition Factor

1. 解题思路

这一题思路上首先是一个二分法的思路，我们找到最大的临界距离，使得当任何大于该距离的情况下，无论怎么切分点集，都至少有一侧存在两个点之间的曼哈顿距离小于该给定距离。

此时，我们只需要构造一个函数is_possible(d)，表示在给定距离 d d d的情况下，是否存在一个分割方式，使得两侧的点集均满足两两之间不存在小于距离 d d d的点对。

而要做到这件事，我们首先需要两两求出所有点对之间的距离，然后将其顺序排列。对于任意给定的 d d d，要判断构造方式是否存在，我们只需要考虑所有距离小于 d d d的点对，看看是否存在一个分割方法使得所有这些点对中的点均不处于同一个集合当中即可，至于剩下的那些点，我们任意分配即可。

而要做到这件事，我们只需要做一个广度优先遍历即可，我们首先考察任意一个点，如果该点已经考察过了，那么直接跳过，否则我们就将其任意放到一个点集当中（不妨设为 a a a），那么与之相连的其他点都必然得放到另一个点集 b b b当中，同理这些点的相连点也同样必须得放到 a a a点集当中，往复循环，直至对所有的点均进行一次分配，或者遇到了矛盾情况即可。

2. 代码实现

给出python代码实现如下：

python 复制代码

class Solution:
    def maxPartitionFactor(self, points: List[List[int]]) -> int:
        n = len(points)
        if n == 2:
            return 0
        distances = []
        for i in range(n-1):
            for j in range(i+1, n):
                d = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])
                distances.append((d, i, j))
        distances = sorted(distances)

        def is_possible(d):
            graph = defaultdict(list)
            for _d, u, v in distances:
                if _d >= d:
                    break
                graph[u].append(v)
                graph[v].append(u)
            nodes = sorted(graph.keys(), key=lambda x: len(graph[x]), reverse=True)
            a, b = set(), set()
            for u in nodes:
                if u in a or u in b:
                    continue
                q = [(u, 0)]
                while q:
                    u, g = q.pop()
                    current, neighbor = (a, b) if g == 0 else (b, a)
                    if u in current:
                        continue
                    if u in neighbor:
                        return False
                    current.add(u)
                    for v in graph[u]:
                        if v in current:
                            return False
                        elif v in neighbor:
                            continue
                        q.append((v, 1-g))
            return True

        i, j = distances[0][0], distances[-1][0]+1
        while j > i+1:
            d = (i+j) // 2
            if is_possible(d):
                i = d
            else:
                j = d
        return i

提交代码评测得到：耗时1184ms，占用内存33.98MB。