图中要着色的最小节点，以便每个节点都有一个已着色的邻居

在图论中，一个节点的邻居是指其直接相连的其他节点。着色则是指给节点标记不同的颜色，通常用于图是为了强调节点之间的关系。

在一个无向图中，给每个节点着色，有一个常见的问题是要求每个节点都至少有一个已着色的邻居。这个问题可以用贪心算法求解。

贪心算法

贪心算法是一种不断做出当前最优选择的算法。在这个问题中，我们可以从任意一个节点开始，假设当前节点没有已着色的邻居，则给它着色，并向它的邻居中没有被着色的节点发送消息，令其也着色。考虑到每个节点只有与自己相邻的节点会对其造成影响，我们可以用广度优先搜索（BFS）实现这个过程：

def color_graph(graph):
    # 记录已经着色的节点
    colored = set()
    # 记录每个节点的颜色
    color_map = {}
    # BFS 遍历每个节点
    for node in graph.nodes:
        # 如果当前节点已着色，则跳过
        if node in colored:
            continue
        # 将当前节点着色，并标记其已着色
        color_map[node] = choose_color(color_map, node)
        colored.add(node)

        # 给所有没有被着色的邻居节点发送消息
        neighbors = [n for n in graph.neighbors(node) if n not in colored]
        for neighbor in neighbors:
            color_map[neighbor] = choose_color(color_map, neighbor)
            colored.add(neighbor)
    return color_map

def choose_color(color_map, node):
    # 选一个颜色，使它不同于已着色邻居
    used_colors = {color_map[n] for n in graph.neighbors(node) if n in color_map}
    for color in range(len(graph.nodes)):
        if color not in used_colors:
            return color
    raise Exception('Failed to color graph')

时间复杂度

使用 BFS 得到所有节点的信息的时间复杂度为 O(|E| + |V|)，其中 |E| 和 |V| 分别为边数和节点数。由于节点数不会超过边数的平方级别，所以时间复杂度为 O(|E|)。

使用示例

以下是一个使用示例，从标准输入读取一个无向图的边和节点数，然后依次读取每条边的起点和终点，最后输出节点着色结果。

from collections import defaultdict
from typing import List

class Graph:
    def __init__(self, nodes: List[int], edges: List[List[int]]):
        self.nodes = nodes
        self.edges = defaultdict(list)
        for u, v in edges:
            self.edges[u].append(v)
            self.edges[v].append(u)

    def neighbors(self, node):
        return self.edges[node]

n, m = map(int, input().split())
edges = [list(map(int, input().split())) for _ in range(m)]
graph = Graph(range(1, n+1), edges)
color_map = color_graph(graph)
print(color_map)

输入示例：

5 4
1 2
2 3
3 4
4 5

输出示例：

{1: 0, 2: 1, 3: 0, 4: 1, 5: 0}

以上结果表示节点 1, 3 和 5 被着成了 0 号颜色（比如红色），而节点 2 和 4 被着成了 1 号颜色（比如蓝色）。每个节点都有一个已着色的邻居。