企业官网建设流程全解析

1. 项目概述：从一道赛题看无线网络优化的实战价值

每年一到数学建模竞赛季，像MathorCup这样的题目总会成为圈内热议的焦点。今年A题“移动通信网络中PCI规划问题”一出来，我身边不少做通信算法和网络优化的朋友都眼前一亮。这题目出得相当“接地气”，它没有飘在纯理论的云端，而是直接把刀锋对准了现网运维中一个非常具体、且让工程师们头疼不已的痛点：PCI冲突与混淆。简单来说，PCI（物理小区标识）就像是每个蜂窝小区的“身份证号”，在有限的号码资源下，如何给成千上万个小区分配合适的、不冲突的“身份证”，直接关系到你的手机能不能快速、稳定地接入网络，会不会频繁掉线或网速骤降。

这道题的价值在于，它完美地架起了一座从数学模型到工程实践的桥梁。对于参赛学生而言，这是一个绝佳的机会，去触碰通信领域里一个经典的组合优化问题；而对于我们这些行业内的“老油条”来说，它则是一次对经典问题的重新审视和解题思路的梳理。题目提供的网络场景和数据（虽然通常是仿真或简化过的）非常贴近实际，你需要考虑同频邻区之间的PCI冲突、混淆，还要顾及模3干扰这种在LTE/5G网络中真实存在的物理层约束。解决它，不仅需要扎实的数学建模功底（图着色、整数规划、启发式算法），更需要你对移动通信的基础原理有清晰的理解。接下来，我就结合自己多年在网优领域摸爬滚打的经验，把这道题的解题思路、核心算法实现以及那些容易踩坑的细节，掰开揉碎了讲清楚。

2. 核心问题拆解：PCI规划到底在规划什么？

在直接撸起袖子写代码之前，我们必须把问题本身吃透。PCI规划不是一个凭空创造的问题，它的每一个约束都对应着现网中真实存在的干扰场景。题目通常会给出一个由多个基站（每个基站可能有多个扇区，即多个小区）构成的网络拓扑，以及小区之间的邻区关系列表。你的任务就是为每个小区分配一个范围在0到1007之间的PCI值（这是LTE标准定义的范围，共1008个），同时满足以下几个硬性约束：

2.1 冲突（Collision）约束：避免“身份证”完全重复

这是最严重的问题，绝对不允许发生。冲突是指两个同频且互为邻区的小区，被分配了相同的PCI。想象一下，你的手机同时收到了两个来自不同方向但“身份证号”一模一样的信号，它根本无法区分该接入哪一个，会导致接入失败、切换混乱。在模型中，这通常被表述为：对于任意一对同频邻区（i, j），必须满足 PCI(i) ≠ PCI(j)。这是一个非常直接的约束，在算法上需要优先保证。

2.2 混淆（Confusion）约束：避免“三角关系”混乱

混淆问题比冲突稍微隐蔽一些，但对网络性能影响同样恶劣。它指的是这样一种情况：小区A和小区B是邻区，小区B和小区C也是邻区，但小区A和小区C不是邻区。如果小区A和小区C被分配了相同的PCI，就会发生混淆。此时，如果手机在小区B中，它同时监听到A和C的信号且PCI相同，就无法正确判断该向哪个小区切换。题目约束通常要求：对于任何小区B，其所有邻区的PCI必须两两不同。也就是说，以任何一个小区为中心，看它周围一圈邻区的PCI，必须全部是独一无二的。

2.3 模3干扰约束：应对物理层的“先天缺陷”

这是通信原理层面的约束。在LTE/5G中，PCI值会直接影响下行参考信号在时频资源上的位置。具体来说，PCI mod 3 的值决定了参考信号在频率上的偏移。如果两个同频小区的PCI mod 3值相同，那么它们的参考信号会在相同的子载波上发送，造成持续的、严重的相互干扰，极大地降低信道估计精度，从而影响下载速率。因此，题目通常要求：对于任意一对同频邻区（i, j），必须满足 PCI(i) mod 3 ≠ PCI(j) mod 3。这相当于在1008个PCI资源中，先按模3余数（0，1，2）分成了3组，同频邻区不能分在同一组。

2.4 优化目标：最小化全局冲突与混淆风险

在满足以上硬约束的前提下，题目往往会设定一个优化目标。最常见的是最小化所有小区对的“PCI复用距离”。这里的“复用距离”不是地理距离，而是指在分配PCI时，尽可能让相同PCI的小区在拓扑上隔得足够远（中间间隔的小区数足够多），从而降低未来因网络变动而产生潜在干扰的风险。另一种目标可能是最小化分配过程中使用的不同PCI的数量，以提高资源利用率。我们需要仔细审题，明确本次竞赛的具体优化目标是什么。

3. 解题思路与算法选型：从经典到智能的路径

面对这样一个典型的约束满足与组合优化问题，我们有多种武器可以选择。选择哪种算法，取决于你对问题规模、求解精度和编程复杂度的权衡。

3.1 思路一：转化为图着色问题（基础且直观）

这是最经典的建模思路，特别适合理解问题本质。

1. 构建冲突图：以每个小区为图的顶点。如果两个小区之间存在冲突约束（即它们是同频邻区），则在它们之间连一条边。那么，满足冲突约束的PCI分配，就等价于给这张图的顶点着色，且相连的顶点不能同色。这里的“颜色”就是PCI值。
2. 处理混淆约束：混淆约束可以转化为一种特殊的边。对于可能引发混淆的三角关系（A-B相邻，B-C相邻，A-C不相邻但同PCI），我们需要避免A和C同色。这可以在冲突图的基础上，为所有可能产生混淆的小区对（A， C）也添加一条边。这样，混淆约束也转化为了“相连顶点不同色”。
3. 处理模3约束：这相当于在着色时，不仅颜色不能相同，颜色所属的“色系”（模3余数）也不能相同。我们可以将其视为一种加强的冲突边。
4. 求解：问题转化为一个带有额外分组约束（模3）的图着色问题。可以直接使用贪心算法（如DSatur算法）、回溯搜索或调用整数规划求解器。

实操心得：对于规模不大的网络（几百个小区），转化为图着色并用DSatur算法求解，是快速获得可行解的可靠方法。DSatur算法会优先给“饱和度”高（即已着色邻居颜色种类多）的顶点着色，并选择可用的最小颜色编号，能在很多情况下得到接近最优的着色方案（使用较少PCI）。

3.2 思路二：建立整数线性规划模型（精确但吃资源）

如果你熟悉优化建模，并且问题规模允许，ILP（整数线性规划）能给你一个理论上最优的解答。

1. 定义决策变量：最常见的建模方式是定义0-1变量x_{i,p}，如果小区i被分配PCI p，则值为1，否则为0。每个小区必须且只能分配一个PCI。
2. 将约束转化为线性不等式：
   • 每个小区一个PCI：对每个小区i，∑_p x_{i,p} = 1。
   • 冲突约束：对每对冲突邻区(i, j)和每个PCI p，x_{i,p} + x_{j,p} ≤ 1。
   • 混淆约束：对每个小区B及其任意两个邻区A, C (A≠C)，和每个PCI p，x_{A,p} + x_{C,p} ≤ 1。这个约束数量会随着邻区关系激增，是模型复杂度的主要来源。
   • 模3约束：对每对冲突邻区(i, j)，令M3 = {p | p mod 3 = k}，对于k=0,1,2，分别有 ∑_{p in M3} (x_{i,p} + x_{j,p}) ≤ 1。
3. 定义目标函数：如最小化使用的最大PCI编号，或最小化∑_{i,j,p} D_{ij} * x_{i,p} * x_{j,p}（其中D_{ij}是某种距离，这个目标是非线性的，需要线性化处理，复杂度较高）。
4. 求解：使用专业的优化求解器如Gurobi, CPLEX或开源的OR-Tools、SCIP进行求解。

注意事项：ILP模型虽然精确，但混淆约束会产生海量的不等式（O(N * neighbor^2)），对于大规模网络（几千个小区），模型可能无法在有限时间内构建或求解。通常只用于小规模案例验证算法正确性，或作为其他启发式算法效果的对比基准。

3.3 思路三：启发式与元启发式算法（实战主流）

对于竞赛和实际工程中常见的大规模网络，启发式算法是更实用的选择。

1. 贪婪算法及其改进：从第一个小区开始，按某种顺序（如小区度降序、随机顺序），依次为其分配一个能满足所有已分配邻区约束的最小PCI值。这种方法速度极快，但解的质量严重依赖处理顺序。可以尝试多种随机顺序，取最优解。
2. 局部搜索：从一个初始解（即使是随机生成的或贪婪算法得到的）开始，通过“微调”来改进。最常见的操作是“交换”（Swap）：随机选择两个小区，尝试交换它们的PCI，如果交换后目标函数更优且满足约束，则接受交换。可以加入模拟退火（SA）的机制，以一定概率接受劣解，避免陷入局部最优。
3. 遗传算法：将PCI分配方案编码为染色体（一个长度为小区数的数组，基因值即PCI）。随机初始化种群，通过选择、交叉、变异操作迭代进化。适应度函数是优化目标的倒数（或负值），并加入对约束违反的惩罚项（罚函数法）。遗传算法能全局搜索，适合复杂优化目标，但参数调优（种群大小、交叉变异概率）需要经验。
4. 禁忌搜索：也是一种高效的元启发式算法。它通过局部搜索移动，并利用一个“禁忌表”记录近期移动历史，禁止在短期内回退，从而引导搜索走向新的区域。

实操心得：在数学建模竞赛中，我推荐采用“贪婪初始化 + 模拟退火局部搜索”的组合策略。贪婪算法能在秒级给出一个不错的可行解作为起点，模拟退火则负责在这个基础上“精雕细琢”。这种组合在效果和耗时上取得了很好的平衡。编码时，务必把冲突、混淆、模3这三种约束的检查函数写得高效且独立，因为它们在迭代中会被调用成千上万次。

4. 核心代码实现与关键技巧

这里我以一个基于“冲突图DSatur算法 + 模3约束处理”的Python实现为例，展示核心框架。我们假设输入数据是一个邻区关系列表neighbor_pairs（每个元素是(cell_i, cell_j, is_same_freq)），以及小区列表cells。

4.1 数据结构设计与约束检查

高效的检查函数是算法速度的基石。

import numpy as np from collections import defaultdict, deque class PCIPlanner: def __init__(self, cells, neighbor_pairs): self.cells = cells self.n = len(cells) self.cell_to_idx = {cell: i for i, cell in enumerate(cells)} self.idx_to_cell = cells # 构建邻接关系：冲突邻区、所有邻区 self.conflict_adj = defaultdict(set) # 同频邻区，需满足冲突和模3约束 self.all_adj = defaultdict(set) # 所有邻区（用于混淆约束检查） for a, b, same_freq in neighbor_pairs: idx_a, idx_b = self.cell_to_idx[a], self.cell_to_idx[b] self.all_adj[idx_a].add(idx_b) self.all_adj[idx_b].add(idx_a) if same_freq: # 同频才构成冲突关系 self.conflict_adj[idx_a].add(idx_b) self.conflict_adj[idx_b].add(idx_a) # 初始化PCI分配结果，-1表示未分配 self.pci_assignment = np.full(self.n, -1, dtype=int) self.used_pcis = set() def check_collision(self, cell_idx, pci): """检查为cell_idx分配pci是否与已分配的冲突邻区冲突""" for neighbor in self.conflict_adj[cell_idx]: if self.pci_assignment[neighbor] == pci: return False return True def check_mod3(self, cell_idx, pci): """检查模3约束""" mod_val = pci % 3 for neighbor in self.conflict_adj[cell_idx]: neighbor_pci = self.pci_assignment[neighbor] if neighbor_pci != -1 and neighbor_pci % 3 == mod_val: return False return True def check_confusion_for_neighbor(self, center_cell_idx, candidate_pci): """ 检查为center_cell_idx的某个邻区分配candidate_pci是否会引起混淆。 更高效的写法：在分配一个PCI时，检查其所有已分配邻区的PCI是否互不相同。 这里我们实现一个分配时的检查：假设要为小区A分配PCI，检查A的所有已分配邻区的PCI是否两两不同。 """ neighbors = self.all_adj[center_cell_idx] assigned_neighbor_pcis = [] for nb in neighbors: nb_pci = self.pci_assignment[nb] if nb_pci != -1: assigned_neighbor_pcis.append(nb_pci) # 如果candidate_pci已经在已分配的邻区PCI列表中，则分配会导致混淆 if candidate_pci in assigned_neighbor_pcis: return False # 此外，还需要检查已分配的邻区PCI列表自身是否有重复（这是之前分配可能遗留的问题） if len(assigned_neighbor_pcis) != len(set(assigned_neighbor_pcis)): # 理论上，我们的分配过程应保证不会出现这种情况。这里可作为完整性检查。 return False return True

4.2 DSatur算法核心实现

DSatur算法在贪心着色中效果拔群，核心是维护一个“饱和度”列表。

def dsatur_allocate(self): """基于DSatur算法进行PCI分配""" # 初始化：所有小区未着色，饱和度为0，度为冲突图的度 saturation = np.zeros(self.n, dtype=int) # 饱和度：已分配邻区使用的不同PCI数 degree = np.array([len(self.conflict_adj[i]) for i in range(self.n)]) unassigned = set(range(self.n)) # 用于快速查询某个PCI是否被某个小区的邻区使用 neighbor_pci_sets = [set() for _ in range(self.n)] while unassigned: # 选择饱和度最大，如果相同则选择度最大的未分配小区 candidate = -1 max_sat = -1 max_deg = -1 for cell in unassigned: if saturation[cell] > max_sat or (saturation[cell] == max_sat and degree[cell] > max_deg): max_sat = saturation[cell] max_deg = degree[cell] candidate = cell # 为选中的小区candidate寻找可用的最小PCI allocated = False for pci in range(1008): # PCI范围0-1007 # 检查冲突、模3、混淆 if (self.check_collision(candidate, pci) and self.check_mod3(candidate, pci) and self.check_confusion_for_neighbor(candidate, pci)): # 分配PCI self.pci_assignment[candidate] = pci self.used_pcis.add(pci) allocated = True # 更新邻居的饱和度 for neighbor in self.all_adj[candidate]: if pci not in neighbor_pci_sets[neighbor]: neighbor_pci_sets[neighbor].add(pci) saturation[neighbor] += 1 break if not allocated: # 如果找不到可用的PCI，说明在严格约束下无解，可能需要放松约束或报告失败 # 在实际中，可能会尝试分配一个违反某条约束但惩罚最小的PCI，这里简单处理为报错 raise RuntimeError(f"无法为小区 {self.idx_to_cell[candidate]} 分配PCI，可能约束过紧或无解。") unassigned.remove(candidate) return self.pci_assignment, self.used_pcis

4.3 模拟退火局部搜索优化

在DSatur得到一个可行解后，我们可以用模拟退火来优化目标（例如最小化最大PCI编号，或最小化复用距离成本）。

def simulated_annealing_optimize(self, initial_assignment, initial_temp=100.0, cooling_rate=0.995, min_temp=1e-3, iterations_per_temp=100): """ 模拟退火优化：尝试交换两个小区的PCI以优化目标。 这里以最小化使用的PCI编号最大值（即最大PCI值）为例。 """ current_assignment = initial_assignment.copy() current_cost = max(current_assignment) # 目标：最小化最大PCI值 best_assignment = current_assignment.copy() best_cost = current_cost temp = initial_temp while temp > min_temp: for _ in range(iterations_per_temp): # 随机选择两个不同的小区 i, j = np.random.choice(self.n, size=2, replace=False) pci_i, pci_j = current_assignment[i], current_assignment[j] # 如果PCI相同，交换无意义 if pci_i == pci_j: continue # 尝试交换：检查交换后两个小区是否都满足所有约束 current_assignment[i], current_assignment[j] = pci_j, pci_i feasible = (self.check_collision(i, pci_j) and self.check_mod3(i, pci_j) and self.check_confusion_for_neighbor(i, pci_j) and self.check_collision(j, pci_i) and self.check_mod3(j, pci_i) and self.check_confusion_for_neighbor(j, pci_i)) if feasible: new_cost = max(current_assignment) delta_cost = new_cost - current_cost # 接受更优解，或以一定概率接受劣解 if delta_cost < 0 or np.random.rand() < np.exp(-delta_cost / temp): current_cost = new_cost if current_cost < best_cost: best_cost = current_cost best_assignment = current_assignment.copy() else: # 拒绝交换，换回来 current_assignment[i], current_assignment[j] = pci_i, pci_j else: # 交换不可行，换回来 current_assignment[i], current_assignment[j] = pci_i, pci_j temp *= cooling_rate # 降温 self.pci_assignment = best_assignment self.used_pcis = set(best_assignment) return best_assignment, best_cost

关键技巧：模拟退火中的“交换”操作比“随机重分配”更容易保持解的可行性。iterations_per_temp（每个温度的迭代次数）和cooling_rate（冷却率）是需要仔细调参的关键。通常，初始温度要设得足够高，使得前期有较大概率接受劣解；冷却率不宜过快，否则容易陷入局部最优。可以设计一个简单的循环来尝试多组参数。

5. 结果验证与性能评估

算法跑完了，但工作只完成了一半。如何验证你的PCI规划方案是正确且优质的呢？

5.1 约束满足性验证

这是最基本的检查，必须自动化进行。

def validate_assignment(self, assignment): """全面验证分配方案是否满足所有约束""" violations = [] # 1. 检查冲突约束 for i in range(self.n): for j in self.conflict_adj[i]: if j > i and assignment[i] == assignment[j]: violations.append(f"冲突约束违反: 小区 {self.idx_to_cell[i]}(PCI={assignment[i]}) 与 小区 {self.idx_to_cell[j]}(PCI={assignment[j]})") # 2. 检查模3约束 for i in range(self.n): for j in self.conflict_adj[i]: if j > i and (assignment[i] % 3) == (assignment[j] % 3): violations.append(f"模3约束违反: 小区 {self.idx_to_cell[i]}(PCI={assignment[i]}) 与 小区 {self.idx_to_cell[j]}(PCI={assignment[j]})") # 3. 检查混淆约束 for i in range(self.n): neighbor_pcis = set() for j in self.all_adj[i]: if assignment[j] != -1: if assignment[j] in neighbor_pcis: violations.append(f"混淆约束违反: 小区 {self.idx_to_cell[i]} 的邻区中，PCI {assignment[j]} 重复出现") else: neighbor_pcis.add(assignment[j]) if not violations: print("验证通过：所有约束均满足。") return True else: print(f"发现 {len(violations)} 处约束违反：") for v in violations[:10]: # 只打印前10条避免刷屏 print(v) return False

5.2 优化目标评估与可视化

根据题目要求计算目标函数值。例如，计算PCI复用距离：

def calculate_reuse_distance(self, assignment): """ 计算一个简化的复用距离成本。 假设我们定义成本为：对于所有使用相同PCI的小区对，其拓扑最短路径跳数的倒数之和。 路径越短，成本越高。 """ from collections import deque # 首先需要构建用于计算最短路径的全局邻接图（通常使用所有邻区关系） adj_for_path = self.all_adj # 按PCI分组 pci_to_cells = defaultdict(list) for idx, pci in enumerate(assignment): pci_to_cells[pci].append(idx) total_cost = 0.0 for pci, cell_list in pci_to_cells.items(): if len(cell_list) < 2: continue # 计算该PCI组内所有小区对之间的最短路径长度 for i in range(len(cell_list)): for j in range(i+1, len(cell_list)): dist = self.bfs_shortest_path(cell_list[i], cell_list[j], adj_for_path) if dist != -1: # 如果连通 total_cost += 1.0 / dist # 距离越近，惩罚越大 return total_cost def bfs_shortest_path(self, start, end, adj): """BFS计算两个小区在拓扑上的最短跳数""" if start == end: return 0 visited = set([start]) queue = deque([(start, 0)]) while queue: node, steps = queue.popleft() for neighbor in adj[node]: if neighbor == end: return steps + 1 if neighbor not in visited: visited.add(neighbor) queue.append((neighbor, steps + 1)) return -1 # 不连通

可视化能直观展示规划效果。使用networkx和matplotlib可以绘制网络拓扑图，并用颜色表示PCI或模3余数，直观检查同色小区是否离得太近。

import networkx as nx import matplotlib.pyplot as plt def visualize_pci_assignment(cells, neighbor_pairs, pci_assignment): G = nx.Graph() G.add_nodes_from(cells) for a, b, _ in neighbor_pairs: G.add_edge(a, b) pos = nx.spring_layout(G, seed=42) # 布局算法 # 用PCI值映射颜色 colors = [pci_assignment[cell] for cell in cells] plt.figure(figsize=(12, 8)) nx.draw(G, pos, node_color=colors, with_labels=True, node_size=500, cmap=plt.cm.tab20, edge_color='gray') plt.title("PCI分配可视化（颜色代表PCI值）") plt.show() # 也可以绘制模3余数分布图 mod3_colors = [pci_assignment[cell] % 3 for cell in cells] plt.figure(figsize=(12, 8)) nx.draw(G, pos, node_color=mod3_colors, with_labels=True, node_size=500, cmap=plt.cm.Set3, edge_color='gray') plt.title("PCI Mod 3 余数分布（颜色代表余数0/1/2）") plt.show()

5.3 与基准方法对比

在论文中，为了体现你算法的优越性，需要设计对比实验。

• 基准1：随机分配：随机分配PCI，仅满足不冲突约束（或完全随机），作为最差情况基线。
• 基准2：顺序贪婪分配：按小区ID顺序，分配可用最小PCI。
• 基准3：仅DSatur算法：与你提出的“DSatur+模拟退火”进行对比。
• 评估指标：
  1. 约束违反数：必须为0。
  2. 目标函数值：如最大PCI、复用距离成本等。
  3. 算法运行时间。
  4. PCI资源利用率：使用的不同PCI数量 / 总小区数。越低说明复用效率越高。

报告撰写心得：在论文中展示结果时，不要只扔出一个最终数字。要用表格清晰对比不同算法在不同规模数据集（小、中、大）上的性能指标。用图表（如收敛曲线图、PCI分布直方图）来直观展示你的算法如何优化过程。对关键参数（如模拟退火的初始温度、冷却率）做敏感性分析，说明你的参数选择是合理的。

6. 常见问题与实战避坑指南

在实际编码和调试过程中，你几乎一定会遇到下面这些问题。

6.1 算法找不到可行解怎么办？

这是最令人头疼的情况。DSatur算法报告无法分配PCI。

• 原因1：约束过紧，问题本身无解。特别是在小区密度极高、邻区关系极其稠密的极端场景下，1008个PCI资源可能确实不够用。你需要检查输入数据。一个快速判断的方法是计算冲突图的“色数”下界（最大团的大小），如果下界已经超过1008，那肯定无解。
• 原因2：算法陷入死胡同。DSatur是贪心算法，早期一个“坏”的分配可能导致后续无法分配。解决方案：
  1. 引入随机性：当有多个PCI可选时，不总是选最小的，而是以一定概率随机选择一个，多运行几次算法。
  2. 回溯搜索：当分配失败时，回退到上一步，尝试另一个PCI选择。这其实就是将DSatur与回溯法结合，虽然耗时增加，但能提高找到解的概率。
  3. 放松约束，使用启发式修复：先分配，允许暂时违反混淆或模3约束，但记录违反的严重程度。在后续的局部搜索（如模拟退火）阶段，将约束违反作为惩罚项加入目标函数，引导算法向可行域移动。

6.2 混淆约束检查效率太低

混淆约束检查是性能瓶颈，因为最坏情况下需要检查一个小区所有邻区对的两两关系。

• 优化技巧：不必在每次分配时都做全量检查。可以维护一个数据结构，例如confusion_check_dict。对于每个小区B，维护一个集合used_pcis_by_my_neighbors。当为小区A分配PCI p时，对于A的每一个邻区B，将p加入到B的used_pcis_by_my_neighbors集合中。在为任何小区分配PCI前，检查目标PCI是否已在其任一邻区的used_pcis_by_my_neighbors集合中。这样就将O(N^2)的检查分摊到了每次分配的O(度)操作中。

6.3 模拟退火优化效果不明显

迭代了很久，目标函数值下降缓慢或震荡。

• 调参：增大initial_temp，让算法前期有更强的“爬山”能力；增大iterations_per_temp，让每个温度下搜索更充分；减缓cooling_rate（例如从0.995改为0.998），让退火过程更平缓。
• 设计更高效的邻域动作：“交换”操作是保守的。可以尝试“重分配”操作：随机选择一个小区域，将其PCI随机重分配为一个满足约束的值。这能带来更大的变化，但接受率可能更低。可以混合使用多种邻域动作。
• 目标函数设计：如果目标是“最小化最大PCI”，这个目标本身比较“陡峭”，优化空间可能有限。可以尝试优化“PCI复用距离”，这个目标更平滑，更容易引导搜索。

6.4 如何应对超大规模网络？

当小区数量达到数千甚至上万时，上述算法的内存和计算时间可能成为问题。

• 分而治之：利用网络拓扑通常具有的簇状或层次化结构。先将网络按地理位置或逻辑关系划分为多个区域（Clusters），确保区域间耦合度低（即跨区域的邻区关系少）。先在每个区域内独立进行PCI规划，然后再处理区域边界的少量冲突和混淆问题。这是现网规划中最常用的工程方法。
• 使用更高效的启发式算法：考虑蚁群算法、粒子群算法等，它们在处理大规模组合优化问题时有时有奇效。也可以考虑使用强化学习来学习分配策略，但这对于竞赛而言可能过于复杂。
• 代码层面优化：使用numpy向量化操作，用numba加速关键循环，使用更高效的数据结构（如bitset表示PCI使用情况）。

6.5 模型与现实的差距

竞赛题目是现实的简化。真正的现网PCI规划还要考虑：

• 多层网络：2G/4G/5G多层网共存，每层都有自己的PCI空间和约束，层间还有可能产生干扰。
• PCI预留：为未来扩容、网络调整预留一部分PCI资源。
• 工程约束：某些基站设备可能有特定的PCI范围限制。
• 优化目标多元化：不仅要考虑静态干扰，还要考虑切换性能、负载均衡等。

在论文的“模型评价与推广”部分，可以讨论这些现实因素，并简要说明你的模型如何扩展以适应它们，这能体现你对问题的深入思考。