用Python+NetworkX复刻PTA天梯赛‘红色警报’题：从图论到实战的保姆级教程

当城市间的道路成为战火中的生命线，如何用代码守护国家的连通性？这个来自PTA天梯赛的经典题目，将带我们走进图论的实战世界。不同于枯燥的算法理论，我们将用Python的NetworkX库构建可视化战场，通过深度优先搜索(DFS)算法动态监测城市沦陷对国家连通性的影响。本文不仅会还原题目解法，更会带你体验从竞赛代码到工程实践的思维跃迁。

1. 理解问题本质：战争中的图论模型

题目描述了一个典型的连通性监控场景：给定N个城市和M条道路构成的无向图，当某个城市被攻占时，需要判断是否会破坏整个国家的连通性。这本质上是在考察图的连通分量概念——即图中互相连通的子图数量。

关键判定条件：

• 初始连通分量数为k
• 删除城市后连通分量数>k：发出红色警报
• 删除城市后连通分量数≤k：普通警报

注意：即使原本国家就不完全连通（k>1），只要删除城市没有增加连通分量数，就不触发红色警报

用邻接表表示的城市网络示例：

python复制cities = {
    0: [1, 3, 4],
    1: [0, 3],
    2: [],
    3: [0, 1],
    4: [0]
}

2. 环境搭建与数据准备

2.1 安装必要库

bash复制pip install networkx matplotlib

2.2 输入数据解析

PTA的输入格式需要特殊处理：

python复制def parse_input():
    import sys
    data = sys.stdin.read().split()
    ptr = 0
    N, M = int(data[ptr]), int(data[ptr+1])
    ptr +=2
    
    edges = []
    for _ in range(M):
        u, v = int(data[ptr]), int(data[ptr+1])
        edges.append((u, v))
        ptr +=2
    
    K = int(data[ptr])
    ptr +=1
    lost_cities = [int(data[ptr+i]) for i in range(K)]
    return N, edges, lost_cities

2.3 构建图结构

使用NetworkX创建无向图：

python复制import networkx as nx

def build_graph(N, edges):
    G = nx.Graph()
    G.add_nodes_from(range(N))
    G.add_edges_from(edges)
    return G

3. 连通分量计算的双重实现

3.1 手写DFS实现

经典的递归深度优先搜索：

python复制def count_components_dfs(N, edges, removed=None):
    if removed is None:
        removed = set()
    
    adj = [[] for _ in range(N)]
    for u, v in edges:
        if u not in removed and v not in removed:
            adj[u].append(v)
            adj[v].append(u)
    
    visited = [False] * N
    count = 0
    
    def dfs(node):
        visited[node] = True
        for neighbor in adj[node]:
            if not visited[neighbor]:
                dfs(neighbor)
    
    for i in range(N):
        if i not in removed and not visited[i]:
            dfs(i)
            count +=1
    
    return count

3.2 NetworkX内置方法

利用库函数快速验证：

python复制def count_components_nx(G, removed):
    H = G.copy()
    H.remove_nodes_from(removed)
    return nx.number_connected_components(H)

性能对比：

4. 动态可视化监控系统实现

4.1 实时绘图函数

python复制import matplotlib.pyplot as plt

def visualize_graph(G, removed=None, alert=False):
    plt.clf()
    pos = nx.spring_layout(G)
    
    if removed is None:
        removed = set()
    
    active_nodes = [n for n in G.nodes() if n not in removed]
    nx.draw_networkx_nodes(G, pos, nodelist=active_nodes, node_color='skyblue')
    nx.draw_networkx_nodes(G, pos, nodelist=removed, node_color='red')
    
    active_edges = [e for e in G.edges() if e[0] not in removed and e[1] not in removed]
    nx.draw_networkx_edges(G, pos, edgelist=active_edges)
    
    labels = {n: str(n) for n in G.nodes()}
    nx.draw_networkx_labels(G, pos, labels)
    
    title = "Normal"
    if alert:
        title = "RED ALERT!"
    plt.title(f"City Connectivity - {title}")
    plt.axis('off')
    plt.pause(0.5)

4.2 主监控流程

python复制def monitor_system(N, edges, lost_cities):
    G = build_graph(N, edges)
    plt.ion()
    visualize_graph(G)
    
    removed = set()
    initial_components = count_components_dfs(N, edges)
    
    for city in lost_cities:
        removed.add(city)
        current_components = count_components_dfs(N, edges, removed)
        
        if current_components > initial_components:
            print(f"Red Alert: City {city} is lost!")
            visualize_graph(G, removed, alert=True)
        else:
            print(f"City {city} is lost.")
            visualize_graph(G, removed)
        
        initial_components = current_components
    
    if len(removed) == N:
        print("Game Over.")
    
    plt.ioff()
    plt.show()

5. 工程化改进与性能优化

5.1 增量式连通计算

每次重新计算全图连通分量效率低下，可采用以下优化：

python复制def incremental_component_count(G, removed, prev_components):
    # 检查被删除节点是否为割点
    city = list(removed)[-1]  # 最新删除的
    neighbors = list(G.neighbors(city))
    
    # 构建子图检查连通性
    subgraph_nodes = set(G.nodes()) - removed
    H = G.subgraph(subgraph_nodes)
    
    # 检查邻居是否仍然连通
    if len(neighbors) <= 1:
        return prev_components
    
    test_node = neighbors[0]
    reachable = set(nx.node_connected_component(H, test_node))
    
    for node in neighbors[1:]:
        if node not in reachable:
            return prev_components + 1
    
    return prev_components

5.2 并行计算方案

对于大规模图（N>10000），可使用多进程：

python复制from concurrent.futures import ProcessPoolExecutor

def parallel_component_count(args):
    N, edges, removed = args
    return count_components_dfs(N, edges, removed)

with ProcessPoolExecutor() as executor:
    futures = [executor.submit(parallel_component_count, (N, edges, removed))]
    result = futures[0].result()

6. 测试用例设计与边界处理

6.1 典型测试场景

python复制test_cases = [
    {
        "input": (5, [(0,1),(1,3),(3,0),(0,4)], [1,2,0,4,3]),
        "expected": [
            "City 1 is lost.",
            "City 2 is lost.",
            "Red Alert: City 0 is lost!",
            "City 4 is lost.",
            "City 3 is lost.",
            "Game Over."
        ]
    },
    {
        "input": (3, [(0,1)], [2]),
        "expected": ["City 2 is lost."]
    }
]

6.2 异常处理增强

python复制def safe_monitor(N, edges, lost_cities):
    try:
        if N <=0 or len(lost_cities)==0:
            raise ValueError("Invalid input parameters")
        
        # 检查城市编号范围
        if any(city <0 or city >=N for city in lost_cities):
            raise ValueError("City index out of range")
            
        return monitor_system(N, edges, lost_cities)
    except Exception as e:
        print(f"Monitoring failed: {str(e)}")
        return None

在实际项目中处理这类连通性问题时，最容易被忽视的是边界条件——比如当第一个被攻占的城市就是关键枢纽时，系统能否正确识别？我们通过可视化可以直观看到，删除城市0后，原本连通的图确实分裂成了两个孤立部分，这正是红色警报应该触发的情形。