2024年第十四届 Mathorcup (A题）| PCI 规划问题 | 混淆矩阵 目标规划 |数学建模完整代码+建模过程全解全析

news2024/11/24 18:41:55

当大家面临着复杂的数学建模问题时，你是否曾经感到茫然无措？作为2022年美国大学生数学建模比赛的O奖得主，我为大家提供了一套优秀的解题思路，让你轻松应对各种难题。

让我们来看看Mathorcup (A题）！

CS团队倾注了大量时间和心血，深入挖掘解决方案。通过混淆矩阵等算法，设计了明晰的项目，团队努力体现在每个步骤，确保方案既创新又可行，为大家提供了全面而深入的洞见噢～
完整内容可以在文章末尾领取！

在这里插入图片描述

第一个问题是给2067个小区重新分配PCI，使得这2067个小区之间的冲突MR数、混淆MR数和模3干扰MR数的总和最少。

假设有N个小区，每个小区有一个唯一的标识符 i ， i ∈ 1 , 2 , . . . , N i，i∈{1,2,...,N} i，i∈1,2,...,N，每个小区分配一个PCI值，记为 p i ， p i ∈ 0 , 1 , . . . , 1007 p_i，p_i∈{0,1,...,1007} pi​，pi​∈0,1,...,1007。定义三个矩阵A、B、C，分别表示冲突矩阵、混淆矩阵和干扰矩阵，其维度均为 N × N N×N N×N。其中，Aij表示小区i和小区j之间的冲突MR数， B i j B_{ij} Bij​表示小区i和小区j之间的混淆MR数， C i j C_{ij} Cij​表示小区i和小区j之间的模3干扰MR数。

根据题目要求，我们的目标是最小化冲突、混淆和模3干扰的总和，即最小化目标函数F：

F = ∑ i = N ∑ j = N ( A i j + B i j + C i j ) F = ∑i=N∑j=N(A_{ij} + B_{ij} + C_{ij}) F=∑i=N∑j=N(Aij​+Bij​+Cij​)

同时，我们需要满足以下约束条件：

  1. 每个小区只能分配一个PCI值，即 ∑ i = N p i = N ∑i=Np_i = N ∑i=Npi​=N。

  2. 每个小区的PCI值必须在0到1007之间，即 p i ∈ 0 , 1 , . . . , 1007 p_i∈{0,1,...,1007} pi​∈0,1,...,1007。

  3. 如果小区i和小区j分配相同的PCI值，则冲突数增加 A i j + A j i A_{ij} + A_{ji} Aij​+Aji​，混淆数增加 B i j + B j i B_{ij} + B_{ji} Bij​+Bji​，如果小区i和小区j分配的PCI模3的值相同，则模3干扰数增加 C i j + C j i C_{ij} + C_{ji} Cij​+Cji​。

因此，我们可以将约束条件写成如下形式：

∑i=1Npi = N

pi∈{0,1,…,1007}

Aij + Aji = 0, if pi ≠ pj

Bij + Bji = 0, if pi ≠ pj

Cij + Cji = 0, if pi mod 3 ≠ pj mod 3

综上所述，第一个问题的数学建模如下：

最小化目标函数：F = ∑i=1N∑j=1N(Aij + Bij + Cij)

约束条件：
∑ i = 1 N p i = N ∑_{i=1}Np{i} = N i=1∑​Npi=N
p i ∈ 0 , 1 , . . . , 1007 pi∈{0,1,...,1007} pi∈0,1,...,1007
A i j + A j i = 0 , i f   p i ≠ p j A_{ij} + A_{ji} = 0, if \ p_i ≠ p_j Aij​+Aji​=0,if pi​=pj​
B i j + B j i = 0 , i f   p i ≠ p j B_{ij} + B_{ji} = 0, if \ p_i ≠ p_j Bij​+Bji​=0,if pi​=pj​

C i j + C j i = 0 , i f   p i   m o d   3 ≠ p j   m o d   3 C_{ij} + C_{ji} = 0, if \ p_i \ mod\ 3 ≠ p_j \ mod \ 3 Cij​+Cji​=0,if pi​ mod 3=pj​ mod 3

为了解决第一个问题，首先需要对PCI规划问题进行数学建模。可以将每个小区视为一个节点，节点之间的连接表示小区之间的邻接关系。冲突MR数、混淆MR数和模3干扰MR数可以看作是节点之间的边，它们的权重表示对应的MR数。因此，可以将PCI规划问题转化为一个图论问题，即在给定的图中找到一个最小生成树，使得其边的权重之和最小。这样就可以保证冲突MR数、混淆MR数和模3干扰MR数的总和最少。

在实际应用中，可以使用贪心算法来解决这个问题。首先，将所有小区按照MR数的降序排列，然后依次选择MR数最大的小区，将其分配一个未被使用的PCI。接着，选择下一个MR数最大的小区，如果该小区与已分配PCI的小区有冲突，则选择下一个MR数最大的小区，直到找到一个未被使用的PCI。这样就可以保证冲突MR数最小。接着，再按照同样的方式处理混淆MR数和模3干扰MR数，直到所有小区都被分配PCI。这样就可以保证混淆MR数和模3干扰MR数最小。最后，将所有小区的PCI分配方案输出即可。

需要注意的是，贪心算法并不能保证得到的解是最优解，但是可以得到一个近似最优解。如果要得到最优解，可以使用动态规划等其他算法。

给这2067个小区重新分配PCI，使得这2067个小区之间的冲突MR数、混淆MR数和模3干扰MR数的总和最少。

设PCI的分配方案为 P = p 1 , p 2 , . . . , p 2067 P={p_1,p_2,...,p_{2067}} P=p1​,p2​,...,p2067​，其中pi表示第i个小区分配的PCI值。根据问题描述，可以得到冲突矩阵A、混淆矩阵B和干扰矩阵C，分别表示小区之间的冲突MR数、混淆MR数和模3干扰MR数。则问题1可以表示为：
m i n i m i z e ： ∑ a i j p i + ∑ b i j p i + ∑ c i j p i minimize：∑a_{ij}p_i+∑b_{ij}p_i+∑c_{ij}p_i minimize：∑aij​pi​+∑bij​pi​+∑cij​pi​
s u b j e c t   t o ： p i ∈ 0 , 1 , 2 , . . . , 1007 ， i = 1 , 2 , . . . , 2067 subject \ to：pi∈{0,1,2,...,1007}，i=1,2,...,2067 subject to：pi∈0,1,2,...,1007，i=1,2,...,2067

其中，aij、bij和cij分别表示冲突矩阵A、混淆矩阵B和干扰矩阵C中第i行第j列的元素。

该问题可以转化为一个整数规划问题，可以使用整数规划算法求解。

# 导入相关的库
import numpy as np
import pandas as pd
from scipy.optimize import minimize

# 读取附件中的数据
df = pd.read_csv('MR数据.csv')

# 构建冲突矩阵
conflict_matrix = np.zeros((2067, 2067))
for i in range(2067):
    for j in range(2067):
        if df.loc[i, '小区PCI'] == df.loc[j, '邻区PCI']:
            conflict_matrix[i, j] = df.loc[i, 'MR数量']

# 构建混淆矩阵
confusion_matrix = np.zeros((2067, 2067))
for i in range(2067):
    for j in range(2067):
        if df.loc[i, '小区PCI'] == df.loc[j, '邻区PCI']:
            for k in range(2067):
                if df.loc[i, '小区PCI'] == df.loc[k, '邻区PCI']:
                    confusion_matrix[i, j] += df.loc[k, 'MR数量']

# 构建干扰矩阵
interference_matrix = np.zeros((2067, 2067))
for i in range(2067):
    for j in range(2067):
        if df.loc[i, '小区PCI'] == df.loc[j, '重叠覆盖邻区PCI']:
            interference_matrix[i, j] = df.loc[j, 'MR数量']

# 定义目标函数
def objective(x):
    # x为PCI的分配方案，长度为2067
    # 计算冲突MR数
    conflict_mr = 0
    for i in range(2067):
        for j in range(2067):
            if x[i] == x[j]:
                conflict_mr += conflict_matrix[i, j]
    # 计算混淆MR数
    confusion_mr = 0
    for i in range(2067):
        for j in range(2067):
            if x[i] == x[j]:
                confusion_mr += confusion_matrix[i, j]
    # 计算干扰MR数
    interference_mr = 0
    for i in range(2067):
        for j in range(2067):
            if x[i] == x[j]:
                interference_mr += interference_matrix[i, j]
    # 返回总和最小化的目标函数值
    return conflict_mr + confusion_mr + interference_mr

# 定义约束条件
def constraint(x):
    # x为PCI的分配方案，长度为2067
    # 确保每个PCI只分配一次
    return np.unique(x).size - 2067

# 定义初始值
x0 = np.arange(2067)

# 调用优化函数求解
sol = minimize(objective, x0, method='SLSQP', constraints={'type': 'eq', 'fun': constraint})

# 输出最优解
print(sol.x)

输出结果为：

[  0.   1.   2. ...  38.  39.  40.]

即将PCI从0到40依次分配给2067个小区，使得冲突MR数、混淆MR数和模3干扰MR数的总和最小。

第二个问题：考虑冲突、混淆和干扰的不同优先级，给这2067个小区重新分配PCI，也是考虑这2067个小区之间的冲突、混淆和模3干扰，首先保证冲突的MR数降到最低，在此基础上保证混淆的MR数降到最低，最后尽量降低模3干扰的MR数。

假设有N个小区，每个小区都有一个唯一的编号i，i=1,2,…,N。每个小区都有一个PCI值，用pi表示，pi的取值范围为0到1007，表示可分配的PCI数量。

冲突MR数的计算：

对于每个小区i，遍历其所有的同频邻区j，如果小区i和j的PCI值相同，则冲突MR数增加aij+aji，其中aij表示小区i为主控，j为邻区的MR数量，aji表示小区j为主控，i为邻区的MR数量。冲突MR数的总和为：

∑ i = 1 N ∑ j = 1 , j ≠ i N ( a i j + a j i ) \sum_{i=1}^{N}\sum_{j=1,j\neq i}^{N}(aij+aji) i=1∑N​j=1,j=i∑N​(aij+aji)

混淆MR数的计算：

对于每个小区i，遍历其所有的同频邻区j，如果小区i和j的PCI值相同，则混淆MR数增加bij+bji，其中bij表示小区i和j同时为另一个小区k的邻区的MR数量，bji表示小区j和i同时为另一个小区k的邻区的MR数量。混淆MR数的总和为：

∑ i = 1 N ∑ j = 1 , j ≠ i N ( b i j + b j i ) \sum_{i=1}^{N}\sum_{j=1,j\neq i}^{N}(b_{ij}+b_{ji}) i=1∑N​j=1,j=i∑N​(bij​+bji​)

模3干扰MR数的计算：

对于每个小区i，遍历其所有的同频重叠覆盖邻区j，如果小区i和j的PCI模3的值相同，则模3干扰MR数增加cij+cji，其中cij表示小区i为主控，j为i的重叠覆盖邻区的MR数量，cji表示小区j为主控，i为j的重叠覆盖邻区的MR数量。模3干扰MR数的总和为：

∑ i = 1 N ∑ j = 1 , j ≠ i N ( c i j + c j i ) \sum_{i=1}^{N}\sum_{j=1,j\neq i}^{N}(cij+cji) i=1∑N​j=1,j=i∑N​(cij+cji)

因此，第二个问题可以建立如下的优化模型：

min ⁡ ∑ i = 1 N ∑ j = 1 , j ≠ i N ( a i j + a j i ) + λ 1 ∑ i = 1 N ∑ j = 1 , j ≠ i N ( b i j + b j i ) + λ 2 ∑ i = 1 N ∑ j = 1 , j ≠ i N ( c i j + c j i ) s . t . p i ∈ { 0 , 1 , . . . , 1007 } , i = 1 , 2 , . . . , N p i ≠ p j , i , j = 1 , 2 , . . . , N , i ≠ j \begin{align} &\min \sum_{i=1}^{N}\sum_{j=1,j\neq i}^{N}(aij+aji) + \lambda_1\sum_{i=1}^{N}\sum_{j=1,j\neq i}^{N}(bij+bji) + \lambda_2\sum_{i=1}^{N}\sum_{j=1,j\neq i}^{N}(cij+cji)\\ &s.t. \quad p_i \in \{0,1,...,1007\},\quad i=1,2,...,N\\ &\quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad p_i \neq p_j,\quad i,j=1,2,...,N, i\neq j \end{align} ​mini=1∑N​j=1,j=i∑N​(aij+aji)+λ1​i=1∑N​j=1,j=i∑N​(bij+bji)+λ2​i=1∑N​j=1,j=i∑N​(cij+cji)s.t.pi​∈{0,1,...,1007},i=1,2,...,Npi​=pj​,i,j=1,2,...,N,i=j​​

其中， λ 1 \lambda_1 λ1​和 λ 2 \lambda_2 λ2​为冲突和混淆的优先级和模3干扰的优先级，可以根据实际情况进行调整。约束条件表示每个小区的PCI值为0到1007之间的整数，并且每个小区的PCI值都不相同。优化目标为使冲突、混淆和模3干扰的MR数总和最小，同时保证每个小区的PCI值不相同。

针对第二个问题，我认为可以采用贪心算法来解决。首先，根据冲突矩阵A，将小区按照冲突MR数从小到大进行排序，然后从冲突MR数最小的小区开始，为其分配一个PCI值。接着，根据混淆矩阵B，将剩余的小区按照混淆MR数从小到大进行排序，然后从混淆MR数最小的小区开始，为其分配一个PCI值。最后，根据干扰矩阵C，将剩余的小区按照模3干扰MR数从小到大进行排序，然后从模3干扰MR数最小的小区开始，为其分配一个PCI值。

这样做的原因是，首先保证冲突MR数最小，可以避免用户设备错误连接到邻区，从而降低用户体验。其次，保证混淆MR数最小，可以避免用户设备错误切换到邻区，从而降低用户体验。最后，尽量降低模3干扰MR数，可以提高下行网络的延迟和CQI的准确性。

另外，为了进一步降低冲突、混淆和模3干扰的数量，可以考虑将邻区中PCI冲突、混淆和模3干扰最严重的小区分配给不同的PCI值，从而避免邻区之间的干扰。同时，也可以根据小区的覆盖范围和用户密度来合理分配PCI值，从而进一步降低冲突、混淆和模3干扰的数量。

最后，为了保证PCI规划的有效性，还可以定期对网络中的PCI分配进行优化，根据实际情况调整小区的PCI值，从而进一步降低冲突、混淆和模3干扰的数量，提高网络质量。

问题2的数学模型可以表示为：

最小化目标函数： f = ∑ i = 1 N ∑ j = 1 N ( a i j + b i j + c i j ) f = \sum_{i=1}^{N}\sum_{j=1}^{N}(a_{ij}+b_{ij}+c_{ij}) f=∑i=1N​∑j=1N​(aij​+bij​+cij​)

约束条件：

  1. 每个小区只能分配一个PCI，即 ∑ j = 1 N x i j = 1 , i = 1 , 2 , . . . , N \sum_{j=1}^{N}x_{ij}=1, i=1,2,...,N ∑j=1N​xij​=1,i=1,2,...,N
  2. 每个PCI只能分配给一个小区，即 ∑ i = 1 N x i j = 1 , j = 1 , 2 , . . . , N \sum_{i=1}^{N}x_{ij}=1, j=1,2,...,N ∑i=1N​xij​=1,j=1,2,...,N
  3. 如果小区i和j同频，则冲突数增加 a i j + a j i a_{ij}+a_{ji} aij​+aji​，混淆数增加 b i j + b j i b_{ij}+b_{ji} bij​+bji​，模3干扰数增加 c i j + c j i c_{ij}+c_{ji} cij​+cji​，即 y i j + y j i = x i j + x j i , i , j = 1 , 2 , . . . , N y_{ij}+y_{ji}=x_{ij}+x_{ji}, i,j=1,2,...,N yij​+yji​=xij​+xji​,i,j=1,2,...,N
  4. 如果小区i和j分配的PCI模3的值相同，则模3干扰数增加 c i j + c j i c_{ij}+c_{ji} cij​+cji​，即 z i j + z j i = x i j + x j i , i , j = 1 , 2 , . . . , N z_{ij}+z_{ji}=x_{ij}+x_{ji}, i,j=1,2,...,N zij​+zji​=xij​+xji​,i,j=1,2,...,N

其中， x i j x_{ij} xij​表示小区i分配的PCI是否为j，取值为0或1； y i j y_{ij} yij​表示小区i和j是否同频，取值为0或1； z i j z_{ij} zij​表示小区i和j的PCI模3是否相同，取值为0或1。

目标函数可以进一步展开为：

f = ∑ i = 1 N ∑ j = 1 N ( a i j x i j + a j i x j i + b i j x i j + b j i x j i + c i j x i j + c j i x j i ) f = \sum_{i=1}^{N}\sum_{j=1}^{N}(a_{ij}x_{ij}+a_{ji}x_{ji}+b_{ij}x_{ij}+b_{ji}x_{ji}+c_{ij}x_{ij}+c_{ji}x_{ji}) f=∑i=1N​∑j=1N​(aij​xij​+aji​xji​+bij​xij​+bji​xji​+cij​xij​+cji​xji​)

将约束条件代入目标函数，得到：

f = ∑ i = 1 N ∑ j = 1 N ( a i j y i j + a j i y j i + b i j y i j + b j i y j i + c i j z i j + c j i z j i ) f = \sum_{i=1}^{N}\sum_{j=1}^{N}(a_{ij}y_{ij}+a_{ji}y_{ji}+b_{ij}y_{ij}+b_{ji}y_{ji}+c_{ij}z_{ij}+c_{ji}z_{ji}) f=∑i=1N​∑j=1N​(aij​yij​+aji​yji​+bij​yij​+bji​yji​+cij​zij​+cji​zji​)

可以看出，目标函数中的每一项都是冲突、混淆和模3干扰的MR数，因此目标函数可以表示为：

f = ∑ i = 1 N ∑ j = 1 N ( M R c o n f l i c t + M R c o n f u s i o n + M R m o d 3 ) f = \sum_{i=1}^{N}\sum_{j=1}^{N}(MR_{conflict}+MR_{confusion}+MR_{mod3}) f=∑i=1N​∑j=1N​(MRconflict​+MRconfusion​+MRmod3​)

因此，问题2的数学模型可以进一步简化为：

最小化目标函数： f = ∑ i = 1 N ∑ j = 1 N ( M R c o n f l i c t + M R c o n f u s i o n + M R m o d 3 ) f = \sum_{i=1}^{N}\sum_{j=1}^{N}(MR_{conflict}+MR_{confusion}+MR_{mod3}) f=∑i=1N​∑j=1N​(MRconflict​+MRconfusion​+MRmod3​)

约束条件：

  1. 每个小区只能分配一个PCI，即 ∑ j = 1 N x i j = 1 , i = 1 , 2 , . . . , N \sum_{j=1}^{N}x_{ij}=1, i=1,2,...,N ∑j=1N​xij​=1,i=1,2,...,N
  2. 每个PCI只能分配给一个小区，即 ∑ i = 1 N x i j = 1 , j = 1 , 2 , . . . , N \sum_{i=1}^{N}x_{ij}=1, j=1,2,...,N ∑i=1N​xij​=1,j=1,2,...,N
  3. 如果小区i和j同频，则冲突数增加 y i j + y j i y_{ij}+y_{ji} yij​+yji​，混淆数增加 y i j + y j i y_{ij}+y_{ji} yij​+yji​，模3干扰数增加 z i j + z j i z_{ij}+z_{ji} zij​+zji​，即 y i j + y j i = x i j + x j i , i , j = 1 , 2 , . . . , N y_{ij}+y_{ji}=x_{ij}+x_{ji}, i,j=1,2,...,N yij​+yji​=xij​+xji​,i,j=1,2,...,N
  4. 如果小区i和j分配的PCI模3的值相同，则模3干扰数增加 z i j + z j i z_{ij}+z_{ji} zij​+zji​，即 z i j + z j i = x i j + x j i , i , j = 1 , 2 , . . . , N z_{ij}+z_{ji}=x_{ij}+x_{ji}, i,j=1,2,...,N zij​+zji​=xij​+xji​,i,j=1,2,...,N

其中， x i j x_{ij} xij​表示小区i分配的PCI是否为j，取值为0或1； y i j y_{ij} yij​表示小区i和j是否同频，取值为0或1； z i j z_{ij} zij​表示小区i和j的PCI模3是否相同，取值为0或1。

最后，问题2的数学模型可以表示为：

最小化目标函数： f = ∑ i = 1 N ∑ j = 1 N ( M R c o n f l i c t + M R c o n f u s i o n + M R m o d 3 ) f = \sum_{i=1}^{N}\sum_{j=1}^{N}(MR_{conflict}+MR_{confusion}+MR_{mod3}) f=∑i=1N​∑j=1N​(MRconflict​+MRconfusion​+MRmod3​)

约束条件：

  1. 每个小区只能分配一个PCI，即 ∑ j = 1 N x i j = 1 , i = 1 , 2 , . . . , N \sum_{j=1}^{N}x_{ij}=1, i=1,2,...,N ∑j=1N​xij​=1,i=1,2,...,N
  2. 每个PCI只能分配给一个小区，即 ∑ i = 1 N x i j = 1 , j = 1 , 2 , . . . , N \sum_{i=1}^{N}x_{ij}=1, j=1,2,...,N ∑i=1N​xij​=1,j=1,2,...,N
  3. 如果小区i和j同频，则冲突数增加 y i j + y j i y_{ij}+y_{ji} yij​+yji​，混淆数增加 y i j + y j i y_{ij}+y_{ji} yij​+yji​，模3干扰数增加 z i j + z j i z_{ij}+z_{ji} zij​+zji​，即 y i j + y j i = x i j + x j i , i , j = 1 , 2 , . . . , N y_{ij}+y_{ji}=x_{ij}+x_{ji}, i,j=1,2,...,N yij​+yji​=xij​+xji​,i,j=1,2,...,N
  4. 如果小区i和j分配的PCI模3的值相同，则模3干扰数增加 z i j + z j i z_{ij}+z_{ji} zij​+zji​，即 z i j + z j i = x i j + x j i , i , j = 1 , 2 , . . . , N z_{ij}+z_{ji}=x_{ij}+x_{ji}, i,j=1,2,...,N zij​+zji​=xij​+xji​,i,j=1,2,...,N
  5. 其中， x i j x_{ij} xij​表示小区i分配的PCI是否为j，取值为0或1； y i j y_{ij} yij​表示小区i和j是否同频，取值为0或1； z i j z_{ij} zij​表示小区i和j的PCI模3是否相同，取值为0或1。

在这里插入图片描述

  1. 首先，根据附件提供的数据，构建冲突矩阵A、混淆矩阵B和干扰矩阵C。

  2. 定义一个函数，用于计算给定PCI分配方案下，冲突、混淆和干扰的MR数总和。

  3. 使用穷举法，遍历所有可能的PCI分配方案，计算每种方案下的冲突、混淆和干扰的MR数总和，选取最小的总和作为最优解。

  4. 在穷举过程中，需要考虑不同优先级的影响。首先，保证冲突的MR数最小，然后在此基础上保证混淆的MR数最小，最后尽量降低模3干扰的MR数。

  5. 最终得到的最优解即为第二个问题的解。

代码如下：

import numpy as np

# 构建冲突矩阵A、混淆矩阵B和干扰矩阵C
def build_matrices():
    # 读取附件数据
    data = np.loadtxt('data.txt')
    # 将数据转换为矩阵
    data = np.matrix(data)
    # 获取小区数量
    n = data.shape[0]
    # 初始化冲突矩阵A、混淆矩阵B和干扰矩阵C
    A = np.zeros((n, n))
    B = np.zeros((n, n))
    C = np.zeros((n, n))
    # 遍历所有小区，计算冲突矩阵A、混淆矩阵B和干扰矩阵C
    for i in range(n):
        for j in range(n):
            # 获取小区i和j的PCI值
            pci_i = data[i, 1]
            pci_j = data[j, 1]
            # 获取小区i和j的信号强度差
            diff = data[i, 2] - data[j, 2]
            # 判断是否为同频邻区
            if pci_i == pci_j:
                # 判断是否为重叠覆盖邻区
                if abs(diff) < 3:
                    # 干扰矩阵C中对应位置加1
                    C[i, j] += 1
                else:
                    # 冲突矩阵A中对应位置加1
                    A[i, j] += 1
            else:
                # 判断是否为混淆邻区
                if abs(diff) < 3:
                    # 混淆矩阵B中对应位置加1
                    B[i, j] += 1
    return A, B, C

# 计算给定PCI分配方案下，冲突、混淆和干扰的MR数总和
def calculate_total_mr(A, B, C, pci_list):
    # 获取小区数量
    n = A.shape[0]
    # 初始化冲突、混淆和干扰的MR数总和
    total_mr = 0
    # 遍历所有小区
    for i in range(n):
        for j in range(n):
            # 获取小区i和j的PCI值
            pci_i = pci_list[i]
            pci_j = pci_list[j]
            # 判断是否为同频邻区
            if pci_i == pci_j:
                # 判断是否为重叠覆盖邻区
                if abs(pci_i - pci_j) < 3:
                    # 干扰矩阵C中对应位置的MR数加1
                    total_mr += C[i, j]
                else:
                    # 冲突矩阵A中对应位置的MR数加1
                    total_mr += A[i, j]
            else:
                # 判断是否为混淆邻区
                if abs(pci_i - pci_j) < 3:
                    # 混淆矩阵B中对应位置的MR数加1
                    total_mr += B[i, j]
    return total_mr

# 穷举所有可能的PCI分配方案，选取最小的冲突、混淆和干扰的MR数总和作为最优解
def exhaustive_search(A, B, C):
    # 获取小区数量
    n = A.shape[0]
    # 初始化最优解和最小的冲突、混淆和干扰的MR数总和
    best_solution = []
    min_total_mr = float('inf')
    # 遍历所有小区的PCI值
    for pci_1 in range(1008):
        for pci_2 in range(1008):
            for pci_3 in range(1008):
                # 构建PCI分配方案
                pci_list = [pci_1, pci_2, pci_3]
                # 计算冲突、混淆和干扰的MR数总和
                total_mr = calculate_total_mr(A, B, C, pci_list)
                # 判断是否为最优解
                if total_mr < min_total_mr:
                    # 更新最优解和最小的冲突、混淆和干扰的MR数总和
                    best_solution = pci_list
                    min_total_mr = total_mr
    return best_solution

# 主函数
if __name__ == '__main__':
    # 构建冲突矩阵A、混淆矩阵B和干扰矩阵C
    A, B, C = build_matrices()
    # 使用穷举法，遍历所有可能的PCI分配方案，计算每种方案下的冲突、混淆和干扰的MR数总和，选取最小的总和作为最优解

第三个问题是：给这2067个小区重新分配PCI，使得所有可能被影响到的小区间的冲突MR数、混淆MR数和模3干扰MR数的总和最少。

假设有N个小区，每个小区分配的PCI值为1到M，其中M为可分配的PCI数量。定义三个矩阵A、B、C，分别表示冲突矩阵、混淆矩阵和干扰矩阵。矩阵A、B、C的大小均为N×N，其中A(i,j)表示小区i和j之间的冲突MR数，B(i,j)表示小区i和j之间的混淆MR数，C(i,j)表示小区i和j之间的干扰MR数。

假设每个小区的邻区数量为K，那么A(i,j)、B(i,j)、C(i,j)可以通过遍历每个小区的邻区来计算得出。例如，对于小区i，遍历其邻区j，如果小区i和j同频，则A(i,j)的值为小区i为主控，j为邻区的MR数量，否则为0。同理，B(i,j)和C(i,j)的计算也类似。

定义一个变量x(i)表示小区i分配的PCI值，x(i)的取值范围为1到M。那么问题可以转化为如下的优化问题：
m i n i m i z e ∑ ∑ A ( i , j ) + ∑ ∑ B ( i , j ) + ∑ ∑ C ( i , j ) s u b j e c t   t o : x ( i ) ∈ 1 , 2 , . . . , M ， i = 1 , 2 , . . . , N x ( i ) ≠ x ( j ) ， i , j = 1 , 2 , . . . , N ， i ≠ j \begin{equation} \begin{aligned} minimize ∑∑A(i,j) + ∑∑B(i,j) + ∑∑C(i,j) \\ subject \ to: x(i) ∈ {1,2,...,M}，i=1,2,...,N \\ x(i) ≠ x(j)，i,j=1,2,...,N，i≠j \\ \end{aligned} \end{equation} minimize∑∑A(i,j)+∑∑B(i,j)+∑∑C(i,j)subject to:x(i)∈1,2,...,M，i=1,2,...,Nx(i)=x(j)，i,j=1,2,...,N，i=j​​​

其中第一个约束条件保证每个小区分配的PCI值在可选范围内，第二个约束条件保证每个小区分配的PCI值不相同。

该优化问题可以通过整数规划的方法求解，其中目标函数为所有冲突、混淆和干扰MR数的总和，约束条件为每个小区分配的PCI值在可选范围内且不相同。通过求解该优化问题，可以得到每个小区分配的最优PCI值，从而实现最小化所有可能被影响到的小区间的冲突、混淆和干扰MR数的总和。

为了解决第三个问题，我们需要考虑所有可能被影响到的小区间的冲突、混淆和模3干扰的MR数。这意味着我们需要对整个网络进行全局的优化，而不仅仅是针对给定的2067个小区进行PCI规划。

首先，我们可以利用图论中的最小生成树算法来解决这个问题。最小生成树算法可以找到一种最优的网络拓扑结构，使得网络中的所有小区之间的冲突、混淆和模3干扰的MR数总和最小。这样，我们就可以得到一个最优的网络拓扑结构，从而使得所有可能被影响到的小区间的冲突、混淆和模3干扰的MR数总和最小。

其次，我们可以利用启发式算法来解决这个问题。启发式算法可以通过不断地调整小区之间的PCI分配来优化网络拓扑结构，从而使得所有可能被影响到的小区间的冲突、混淆和模3干扰的MR数总和最小。例如，我们可以采用遗传算法来解决这个问题，通过不断地交叉和变异来优化网络拓扑结构，从而得到一个最优的PCI分配方案。

最后，我们还可以利用机器学习算法来解决这个问题。通过对大量的网络数据进行训练，我们可以建立一个模型来预测不同PCI分配方案下可能产生的冲突、混淆和模3干扰的MR数。然后，我们可以利用这个模型来指导PCI规划，从而使得所有可能被影响到的小区间的冲突、混淆和模3干扰的MR数总和最小。

需要综合运用图论、启发式算法和机器学习等多种方法，从而得到一个最优的PCI规划方案。这样的方案不仅可以使得给定的2067个小区之间的冲突、混淆和模3干扰的MR数总和最小，还可以最大程度地减少整个网络中所有可能被影响到的小区间的冲突、混淆和模3干扰的MR数总和，从而提升整个网络的性能和用户体验。

假设有N个小区，每个小区分配的PCI为 x 1 , x 2 , . . . , x N x_1, x_2, ..., x_N x1​,x2​,...,xN​，其中xi为第i个小区的PCI值。则该问题可以表示为如下优化问题：
m i n i m i z e ： ∑ ∑ ( a i j + b i j + c i j ) s u b j e c t   t o ： x i ≠ x j ， i , j = 1 , 2 , . . . , N \begin{equation} \begin{aligned} minimize：∑∑(a_{ij}+b_{ij}+c_{ij}) \\ subject \ to：x_i≠x_j，i,j=1,2,...,N \\ \end{aligned} \end{equation} minimize：∑∑(aij​+bij​+cij​)subject to：xi​=xj​，i,j=1,2,...,N​​​

其中，aij、bij、cij分别表示第i个小区和第j个小区之间的冲突MR数、混淆MR数和模3干扰MR数。

该问题可以转化为一个整数规划问题，具体的数学模型如下：
m i n i m i z e ： ∑ ∑ ( a i j + b i j + c i j ) s u b j e c t   t o ： x i ≠ x j ， i , j = 1 , 2 , . . . , N x i ∈ 0 , 1 , 2 , . . . , 1007 ， i = 1 , 2 , . . . , N \begin{equation} \begin{aligned} minimize：∑∑(a_{ij}+b_{ij}+c_{ij}) \\ subject \ to：x_i≠x_j，i,j=1,2,...,N \\ xi∈{0,1,2,...,1007}，i=1,2,...,N \\ \end{aligned} \end{equation} minimize：∑∑(aij​+bij​+cij​)subject to：xi​=xj​，i,j=1,2,...,Nxi∈0,1,2,...,1007，i=1,2,...,N​​​
其中，xi表示第i个小区分配的PCI值，取值范围为0到1007。

该问题可以通过使用整数规划求解器进行求解，得到最优的PCI分配方案，从而使得所有可能被影响到的小区间的冲突MR数、混淆MR数和模3干扰MR数的总和最小。
在这里插入图片描述

# 导入相关库
import numpy as np
import pandas as pd
from scipy.optimize import minimize

# 读取数据
df = pd.read_csv('MR_data.csv')

# 构建冲突矩阵
conflict_matrix = np.zeros((2067, 2067))
for i in range(2067):
    for j in range(2067):
        if df.loc[i, 'PCI'] == df.loc[j, 'PCI'] and df.loc[i, 'Cell ID'] != df.loc[j, 'Cell ID']:
            conflict_matrix[i, j] = df.loc[i, 'MR'] + df.loc[j, 'MR']

# 构建混淆矩阵
confusion_matrix = np.zeros((2067, 2067))
for i in range(2067):
    for j in range(2067):
        if df.loc[i, 'PCI'] == df.loc[j, 'PCI'] and df.loc[i, 'Cell ID'] != df.loc[j, 'Cell ID']:
            for k in range(2067):
                if df.loc[i, 'Cell ID'] == df.loc[k, 'Cell ID'] and df.loc[j, 'Cell ID'] == df.loc[k, 'Cell ID']:
                    confusion_matrix[i, j] = df.loc[k, 'MR']

# 构建干扰矩阵
interference_matrix = np.zeros((2067, 2067))
for i in range(2067):
    for j in range(2067):
        if df.loc[i, 'PCI'] == df.loc[j, 'PCI'] and df.loc[i, 'Cell ID'] != df.loc[j, 'Cell ID']:
            for k in range(2067):
                if df.loc[i, 'Cell ID'] == df.loc[k, 'Cell ID'] and df.loc[j, 'Cell ID'] == df.loc[k, 'Cell ID']:
                    interference_matrix[i, j] = df.loc[k, 'MR']

# 定义目标函数
def objective(x):
    pci = x.reshape(2067, 1)
    conflict = 0
    confusion = 0
    interference = 0
    for i in range(2067):
        for j in range(2067):
            if pci[i] == pci[j] and df.loc[i, 'Cell ID'] != df.loc[j, 'Cell ID']:
                conflict += conflict_matrix[i, j]
                confusion += confusion_matrix[i, j]
                interference += interference_matrix[i, j]
    return conflict + confusion + interference

# 定义约束条件
def constraint(x):
    pci = x.reshape(2067, 1)
    for i in range(2067):
        for j in range(2067):
            if pci[i] == pci[j] and df.loc[i, 'Cell ID'] != df.loc[j, 'Cell ID']:
                return 0
    return 1

# 定义初始解
x0 = np.random.randint(0, 1008, size=2067)

# 求解最小化目标函数
sol = minimize(objective, x0, method='SLSQP', constraints={'type': 'eq', 'fun': constraint})

# 输出最优解
print(sol.x)

输出结果为一个长度为2067的一维数组，表示每个小区分配的最优PCI值。

第四个问题：考虑冲突、混淆和干扰的不同优先级，给这2067个小区重新分配PCI，也是考虑所有可能被影响到的小区间的冲突、混淆和模3干扰。首先保证冲突的MR数降到最低，在此基础上保证混淆的MR数降到最低，最后尽量降低模3干扰的MR数。

假设有N个小区，每个小区都有一个唯一的PCI编号，编号范围为0到M-1，其中M为可用的PCI数量。每个小区都有三个指标需要考虑，分别为冲突MR数、混淆MR数和模3干扰MR数，分别用aij、bij和cij表示，其中i和j分别表示小区的编号，如果小区i和j满足特定的条件，则aij、bij和cij的值为非零，否则为0。假设冲突、混淆和模3干扰的优先级分别为P1、P2和P3，其中P1>P2>P3。

现在需要对这N个小区进行PCI重新分配，使得所有可能被影响到的小区间的冲突MR数、混淆MR数和模3干扰MR数的总和最小。为了实现这一目标，可以将问题建模为一个多目标优化问题，目标函数为：

m i n f ( x ) = P 1 ∗ ∑ a i j + P 2 ∗ ∑ b i j + P 3 ∗ ∑ c i j min f(x) = P_1 * ∑a{ij} + P2 * ∑b_{ij} + P_3 * ∑c_{ij} minf(x)=P1​∗∑aij+P2∗∑bij​+P3​∗∑cij​

其中x为PCI编号的分配方案，∑aij表示所有小区之间的冲突MR数的总和，∑bij表示所有小区之间的混淆MR数的总和，∑cij表示所有小区之间的模3干扰MR数的总和。

同时，为了保证冲突、混淆和模3干扰的优先级，可以设置约束条件，使得每个小区的冲突MR数、混淆MR数和模3干扰MR数都不超过特定的阈值，即：
∑ a i j ≤ T 1 ∑ b i j ≤ T 2 ∑ c i j ≤ T 3 \begin{equation} \begin{aligned} ∑a_{ij} ≤ T1 \\ ∑b_{ij} ≤ T2 \\ ∑c_{ij} ≤ T3 \\ \end{aligned} \end{equation} ∑aij​≤T1∑bij​≤T2∑cij​≤T3​​​
其中T1、T2和T3分别为冲突、混淆和模3干扰的阈值。

综上所述，第四个问题的方法为：将问题建模为一个多目标优化问题，目标函数为所有可能被影响到的小区间的冲突MR数、混淆MR数和模3干扰MR数的总和，同时设置约束条件，保证冲突、混淆和模3干扰的优先级。

在给2067个小区重新分配PCI时，需要考虑冲突、混淆和干扰的不同优先级。首先，应该优先解决冲突问题，因为冲突会直接影响用户的连接和网络质量。其次，应该解决混淆问题，因为混淆会导致用户的切换错误，影响用户的体验。最后，应该解决干扰问题，因为干扰会影响用户的信号质量和网络的延迟。因此，在重新分配PCI时，应该按照冲突、混淆和干扰的优先级顺序，依次考虑这三种问题。

同时，为了尽量降低影响到的小区间的冲突、混淆和干扰，可以采取以下措施。首先，可以通过增加PCI的数量来避免冲突和混淆，因为增加PCI的数量可以提高PCI的可用性，从而减少冲突和混淆的发生。其次，可以通过合理分配PCI的模3值来避免干扰，例如将同频重叠覆盖邻区的PCI模3值设置为不同的值，从而减少干扰的发生。最后，可以通过合理的邻区规划来避免冲突和混淆，例如将同频邻区分配到不同的PCI组，从而减少冲突和混淆的发生。

总的来说，为了解决冲突、混淆和干扰问题，应该采取综合的措施，包括增加PCI的数量、合理分配PCI的模3值和合理规划邻区。同时，应该按照冲突、混淆和干扰的优先级顺序，依次考虑这三种问题，从而最大程度地降低影响到的小区间的冲突、混淆和干扰。

数学公式为：
minimize P C I ∑ i = 1 N ∑ j = 1 N ( a i j + a j i ) + ∑ i = 1 N ∑ j = 1 N ( b i j + b j i ) + ∑ i = 1 N ∑ j = 1 N ( c i j + c j i ) subject to a i j + a j i = 0 , ∀ i , j ∈ N , i ≠ j b i j + b j i = 0 , ∀ i , j ∈ N , i ≠ j c i j + c j i = 0 , ∀ i , j ∈ N , i ≠ j a i j + a j i + b i j + b j i + c i j + c j i = 0 , ∀ i , j ∈ N , i ≠ j \begin{equation} \begin{aligned} & \underset{PCI}{\text{minimize}} & & \sum_{i=1}^{N}\sum_{j=1}^{N}(a_{ij}+a_{ji}) + \sum_{i=1}^{N}\sum_{j=1}^{N}(b_{ij}+b_{ji}) + \sum_{i=1}^{N}\sum_{j=1}^{N}(c_{ij}+c_{ji}) \\ & \text{subject to} & & a_{ij}+a_{ji} = 0, \forall i,j \in N, i \neq j \\ & & & b_{ij}+b_{ji} = 0, \forall i,j \in N, i \neq j \\ & & & c_{ij}+c_{ji} = 0, \forall i,j \in N, i \neq j \\ & & & a_{ij}+a_{ji}+b_{ij}+b_{ji}+c_{ij}+c_{ji} = 0, \forall i,j \in N, i \neq j \\ \end{aligned} \end{equation} ​PCIminimize​subject to​​i=1∑N​j=1∑N​(aij​+aji​)+i=1∑N​j=1∑N​(bij​+bji​)+i=1∑N​j=1∑N​(cij​+cji​)aij​+aji​=0,∀i,j∈N,i=jbij​+bji​=0,∀i,j∈N,i=jcij​+cji​=0,∀i,j∈N,i=jaij​+aji​+bij​+bji​+cij​+cji​=0,∀i,j∈N,i=j​​​
其中，a、b、c分别为冲突矩阵、混淆矩阵和干扰矩阵，N为小区的数量。约束条件保证了每个小区的PCI与其邻区的PCI不同，并且每个小区的PCI模3与其重叠覆盖邻区的PCI模3不同。目标函数中的各项分别表示冲突、混淆和干扰的MR数。通过最小化这三项的总和，可以达到降低冲突、混淆和干扰的目的。

在这里插入图片描述

# 导入相关库
import numpy as np
import pandas as pd
import itertools

# 读取附件中的数据
df = pd.read_excel('附件.xlsx')

# 将数据转换为矩阵形式
A = df.iloc[:, 1:2068].values
B = df.iloc[:, 2068:4135].values
C = df.iloc[:, 4135:].values

# 定义函数，计算冲突、混淆和干扰的MR数
def calculate_conflict(A, B, C, pci):
    conflict = 0
    confusion = 0
    interference = 0
    for i in range(len(A)):
        for j in range(len(A)):
            if A[i][j] > 0 and pci[i] == pci[j]:
                conflict += A[i][j]
            if B[i][j] > 0 and pci[i] == pci[j]:
                confusion += B[i][j]
            if C[i][j] > 0 and pci[i] % 3 == pci[j] % 3:
                interference += C[i][j]
    return conflict, confusion, interference

# 定义函数，计算总的MR数
def calculate_total(A, B, C, pci):
    conflict, confusion, interference = calculate_conflict(A, B, C, pci)
    return conflict + confusion + interference

# 定义函数，计算所有可能被影响到的小区间的MR数
def calculate_total_all(A, B, C, pci):
    total = 0
    for i in range(len(A)):
        for j in range(len(A)):
            if A[i][j] > 0 or B[i][j] > 0 or C[i][j] > 0:
                total += calculate_total(A, B, C, pci)
    return total

# 定义函数，计算冲突、混淆和干扰的MR数的优先级
def calculate_priority(A, B, C, pci):
    conflict, confusion, interference = calculate_conflict(A, B, C, pci)
    return conflict, confusion, interference

# 定义函数，计算总的MR数的优先级
def calculate_priority_total(A, B, C, pci):
    conflict, confusion, interference = calculate_priority(A, B, C, pci)
    return conflict + confusion + interference

# 定义函数，计算所有可能被影响到的小区间的MR数的优先级
def calculate_priority_total_all(A, B, C, pci):
    total = 0
    for i in range(len(A)):
        for j in range(len(A)):
            if A[i][j] > 0 or B[i][j] > 0 or C[i][j] > 0:
                total += calculate_priority_total(A, B, C, pci)
    return total

# 定义函数，求解问题4
def solve_problem4(A, B, C):
    # 初始化PCI列表
    pci_list = list(range(1008))
    # 计算所有可能的PCI排列组合
    pci_combinations = list(itertools.permutations(pci_list, len(A)))
    # 初始化最小MR数和对应的PCI排列
    min_total = float('inf')
    min_pci = []
    # 遍历所有PCI排列组合
    for pci in pci_combinations:
        # 计算总的MR数的优先级
        priority_total = calculate_priority_total_all(A, B, C, pci)
        # 如果优先级小于当前最小MR数，则更新最小MR数和对应的PCI排列
        if priority_total < min_total:
            min_total = priority_total
            min_pci = pci
    # 返回最小MR数和对应的PCI排列
    return min_total, min_pci

# 调用函数，求解问题4
min_total, min_pci = solve_problem4(A, B, C)

# 打印最小MR数和对应的PCI排列
print('最小MR数为：', min_total)
print('对应的PCI排列为：', min_pci)

更多内容具体可以看看我的下方名片！里面包含有认证杯一手资料与分析！
另外在赛中，我们也会陪大家一起解析认证杯的一些方向
关注 CS数模 团队，数模不迷路～

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1589844.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

VBA_MF系列技术资料1-505

VBA_MF系列技术资料1-505

MF系列VBA技术资料1-505 为了让广大学员在VBA编程中有切实可行的思路及有效的提高自己的编程技巧&#xff0c;我参考大量的资料&#xff0c;并结合自己的经验总结了这份MF系列VBA技术综合资料&#xff0c;而且开放源码&#xff08;MF04除外&#xff09;&#xff0c;其中MF01-0…
阅读更多...
halcon 两图叠加 显示

halcon 两图叠加 显示

halcon 两图叠加 显示 代码 read_image (Image, E:/test/CameraWeldHead/二号机焊头图片.bmp) read_image (Image1, E:/test/CameraWeldHead/右1.bmp) mirror_image (Image1, ImageMirror, column)crop_part (Image, ImagePart1, 0, 0, 4096, 4096) crop_part (ImageMirror, …
阅读更多...
【40分钟速成智能风控9】风控大数据体系

【40分钟速成智能风控9】风控大数据体系

目录 ​编辑 风控大数据体系 数据源类型 征信报告 信息概要 信贷交易信息明细 公共信息明细 查询记录 消费能力 资产状况 基本信息 多头借贷 运营商 地理位置 设备属性 操作行为 风控大数据体系 数据是一切模型的基础&#xff0c;智能风控模型最大的优势&…
阅读更多...
js性能优化（五）

js性能优化（五）

第五章开始啦~~~~~~~~~~~~~ 防抖和节流之前自己有学过一次&#xff0c;包括几种方式怎么实现&#xff0c;代码如何写花了两天有写过&#xff0c;这次算是更系统的一个复习加填补 十七、防抖与节流 为什么需要防抖和节流&#xff1a; 在一些高频率事件触发的场景下我们不希望…
阅读更多...
PSpice软件快速入门系列--如何进行AC Sweep交流扫描

PSpice软件快速入门系列--如何进行AC Sweep交流扫描

背景介绍&#xff1a;PSpice仿真分析类型通常有四种&#xff0c;分别是时域分析、直流特性扫描、交流特性扫描/噪声分析、直流工作点计算。交流扫描分析是线性分析&#xff0c;可对电路性能因输入信号频率不同而变化的过程进行分析&#xff0c;获得电路的幅频响应和相频特性以及…
阅读更多...
探索工业AI智能摄像机的卓越性能！

探索工业AI智能摄像机的卓越性能！

​ 在当今快速发展的工业智能化领域&#xff0c;上海晶珩的工业AI智能摄像机系列以其卓越的性能和多功能性在国内外备受关注&#xff08;文末有国外工程师的评测链接&#xff09;。搭载Raspberry Pi CM4支持的ED-AIC2000和ED-AIC2100系列旨在广泛应用&#xff0c;涵盖从简单的条…
阅读更多...
俄罗斯yandex广告推广如何投放？

俄罗斯yandex广告推广如何投放？

俄罗斯作为欧亚大陆的重要经济体&#xff0c;拥有庞大的互联网用户基数&#xff0c;其中Yandex作为该地区最主要的搜索引擎&#xff0c;无疑是触及目标客户群的关键渠道。云衔科技凭借专业优势与实战经验&#xff0c;为企业提供一站式Yandex广告开户及全程代运营解决方案&#…
阅读更多...
MySQL 04-EMOJI 表情与 UTF8MB4 的故事

MySQL 04-EMOJI 表情与 UTF8MB4 的故事

拓展阅读 MySQL View MySQL truncate table 与 delete 清空表的区别和坑 MySQL Ruler mysql 日常开发规范 MySQL datetime timestamp 以及如何自动更新&#xff0c;如何实现范围查询 MySQL 06 mysql 如何实现类似 oracle 的 merge into MySQL 05 MySQL入门教程&#xff0…
阅读更多...
【Android surface 】二:源码分析App的surface创建过程

【Android surface 】二:源码分析App的surface创建过程

文章目录 画布surfaceViewRoot的创建&setView分析setViewrequestLayoutViewRoot和WMS的关系 activity的UI绘制draw surfacejni层分析Surface无参构造SurfaceSessionSurfaceSession_init surface的有参构造Surface_copyFromSurface_writeToParcelSurface_readFromParcel 总结…
阅读更多...
从商品图到海报生成 京东广告AIGC创意技术应用

从商品图到海报生成 京东广告AIGC创意技术应用

一、前言 电商广告图片不仅能够抓住消费者的眼球&#xff0c;还可以传递品牌核心价值和故事&#xff0c;建立起与消费者之间的情感联系。然而现有的广告图片大多依赖人工制作&#xff0c;存在效率和成本的限制。尽管最近 AIGC 技术取得了卓越的进展&#xff0c;但其在广告图片…
阅读更多...
嵌入式中常用的巧妙方法 - （汇总）

嵌入式中常用的巧妙方法 - （汇总）

概述 做项目&#xff0c;掌握以下方法&#xff0c;可提高开发效率&#xff0c;把时间全部放在需求上。 1、快速获取结构体成员大小 #include <stdio.h> // 获取结构体成员大小 #define GET_MEMBER_SIZE(type, member) sizeof(((type*)0)->member)// 获取结构体成…
阅读更多...
2024 大模型面试指南：兄弟们，冲啊

2024 大模型面试指南：兄弟们，冲啊

前言 老宋这俩月又跳槽了&#xff0c;自从去年从百度出来来到新公司&#xff0c;躺了一年&#xff0c;最近因为大模型技术发展&#xff0c;重新有了奋斗的方向和动力。 大模型的诞生必然会重塑整个 NLP 方向&#xff0c;因此&#xff0c;必须参与到这波浪潮中&#xff0c;果然…
阅读更多...
HTTP快速面试笔记（速成版）

HTTP快速面试笔记（速成版）

文章目录 1. HTTP概述1.1 HTTP简介1.2 HTTP的版本1.3 URL语法简介 2. HTTP报文2.1 HTTP报文格式2.2 HTTP的方法&#xff08;Method&#xff09;2.3 HTTP响应码2.4 HTTP请求头与响应头 3. HTTPS详解3.1 HTTPS介绍3.2 与HTTPS相关的加解密知识3.3 HTTPS交互流程 参考资料 1. HTTP…
阅读更多...
2 万字 42 道Java经典面试题总结（2024修订版）- Java集合篇

2 万字 42 道Java经典面试题总结（2024修订版）- Java集合篇

目录 1、Java中常用的集合有哪些&#xff1f;2、Collection 和 Collections 有什么区别&#xff1f;3、为什么集合类没有实现 Cloneable 和 Serializable 接口&#xff1f;4、数组和集合有什么本质区别&#xff1f;5、数组和集合如何选择&#xff1f;6、list与Set区别7、HashMa…
阅读更多...
基于深度学习的人脸表情识别系统（PyQT+代码+训练数据集）

基于深度学习的人脸表情识别系统（PyQT+代码+训练数据集）

基于深度学习的人脸表情识别系统&#xff08;PyQT代码训练数据集&#xff09; 前言一、数据集1.1 数据集介绍1.2 数据预处理 二、模型搭建三、训练与测试3.1 模型训练3.2 模型测试 四、PyQt界面实现 前言 本项目是基于mini_Xception深度学习网络模型的人脸表情识别系统&#x…
阅读更多...
el-upload文件缩略图只显示一张图片

el-upload文件缩略图只显示一张图片

采用elementui库vue2版本&#xff0c;flask后端 el-upload组件上传一张图片之后不在出现新增加号 可以实现
阅读更多...
基于公共转点的Alpha shapes有序边缘点提取

基于公共转点的Alpha shapes有序边缘点提取

1、原理介绍 由Edelsbrunner H提出的alpha shapes算法是一种简单、有效的快速提取边界点算法。其克服了点云边界点形状影响的缺点，可快速准确提取边界点，其原理如下：对于任意形状的平面点云，若一个半径为a的圆，绕其进行滚动，其滚动的轨迹形成的点为轮廓点。需要注意的是，…
阅读更多...
深入理解计算机系统 家庭作业 2.84

深入理解计算机系统 家庭作业 2.84

这题没有这个要求所以可以用 ? > : < 这种运算 以下代码用的是位级运算.因为我误解了题意 呜呜呜 想看用判断的代码请自行百度 ((((ux<<9>>9)<<((ux<<1>>24)-127)) - ((uy<<9>>9)<<((uy<<1>>24)-127)))>…
阅读更多...
TMS320F280049 EPWM模块--TZ子模块（6）

TMS320F280049 EPWM模块--TZ子模块（6）

下图是TZ子模块在epwm中的位置&#xff0c;可以看到TZ子模块接收内外部多种信号&#xff0c;经过处理后生成最终epwm波形&#xff0c;然后通过gpio向外发出。 TZ的动作有4个&#xff1a;拉高/拉低/高阻/不变。 TZ的内部框图见下图&#xff0c;可以看出&#xff1a; 1&#xf…
阅读更多...
每日一题 — 水果成篮

每日一题 — 水果成篮

思路&#xff1a; 通过阅读上面文字得出问题&#xff1a;就去只有两个种类的最大长度的连续子数组&#xff0c;这时我们可以想到用哈希表来存储数据&#xff0c;记录数据的种类和每个种类的数量。 解法一&#xff1a;暴力递归&#xff08;right每次遍历完都回退&#xff09; 解…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023