python程序设计04

# ##https://blog.csdn.net/Lyyyp/article/details/119832225
# ##https://www.jianshu.com/p/437bd6936dad
####FZ1:使用基于最大度的改进资源冲突消解方案,比较不同数量SS链需要冲突消解迭代的次数;冲突检测消解的花费时间
####FZ2:使用基于元素替换的资源冲突消解方案,比较不同数量SS链需要冲突消解迭代的次数;冲突检测消解的花费时间
####FZ3:使用结合基于最大度思想的时间约束调整及元素替换的资源冲突消解方法,它的不同数量SS链需要冲突消解迭代的次数;冲突检测消解的花费时间
##问题1：某个WQ的最大空余通道数目需要查询，以方便于判断；
import copy
import time
import pandas as pd
import numpy as np
import openpyxl
############BronKerbosch函数定义#############
def BronKerbosch(d, rn, pn, xn, u):# BronKerbosch,cnt记录目前是第几层
    #初始化BronKerbosch(0, 0, n, 0, -1)
    # 判断P、X是否为空，为空则找到最大值
    if pn == 0 and xn == 0:
        route.append(copy.deepcopy(R[d]))
    if len(P[d]) > 0:
        u = P[d][0]  # 记录最近放入P集合中的元素
    # 遍历P中的每一个v,len(P)==0时，搜索到终点
    for j in range(pn):
        # 取出P中的第j个点
        v = P[d][j]
        # 判断u，v是否是邻居，是则跳过
        if u != -1 and conf[u][v] == 1: continue
        R[d + 1] = []  # 因为后面是直接在list后面添加元素，所以先将下一层的list清空
        for k in range(rn):
            R[d + 1].append(R[d][k])
        R[d + 1].append(v)  # 将v节点，添加到R集合中
        # 用来分别记录下一层中P集合和X集合中节点的个数
        tp, tx = 0, 0
        # 更新X集合（下一层X集合），保证X集合中的点都能与R集合中所有的点相连接
        X[d + 1] = []  # 因为后面是直接在list后面添加元素，所以先将下一层的list清空
        for k in X[d]:
            if conf[v][k]:
                X[d + 1].append(k)
                tx += 1
        # 更新P集合时，同时以R、X两个集合作为依据，在X中的元素不能出现在P中
        P[d + 1] = []  # 因为后面是直接在list后面添加元素，所以先将下一层的list清空
        for k in P[d]:
            if conf[v][k] and k not in X[d]:
                P[d + 1].append(k)
                tp += 1
        # 递归进入下一层
        BronKerbosch(d + 1, rn + 1, tp, tx, u)
        # 完成后，将操作的节点，放入X中，开始下面的寻找
        X[d].append(v)
        xn += 1
##############conflict函数定义##################
def conflict(data):# 任务冲突矩阵
    m = len(data)
    M = [[0]*m]*m  #创建m*m的list,list无维度，数组有维度
    M = np.array(M) #将list转成数组
    for k in range(m):
        for j in range(k+1,m):
            if data.taskStartTime[j] < data.taskStartTime[k] <data.taskEndTime[j] \
                    or data.taskStartTime[j] < data.taskEndTime[k] < data.taskEndTime[j]:
                M[j,k] = 1
                M[k,j] = 1
    return M
##############datamodification函数定义##################
def datamodification(row,addtime,taskStartTime,taskEndTime):
    wb = openpyxl.load_workbook('D:\python学习\pythonProject\ResolveSourceConfil\datatest02.xlsx')
    sheet = wb['Sheet1']
    sheet.cell(row+2, 2).value = addtime + taskStartTime
    sheet.cell(row+2, 3).value = addtime + taskEndTime
    wb.save('datatest02.xlsx')
##############ResolvingResourceConflicts函数定义##################增加度的思想
def ResolvingResourceConflicts(Pa):
    for Serialnumber in Pa:
        detaTIME=cmin-data.taskStartTime[Serialnumber]#Serialnumber为SS链的序号
        datamodification(Serialnumber,detaTIME,data.taskStartTime[Serialnumber],data.taskEndTime[Serialnumber])
##############检测消解主程序##################
st = time.time()
flag=True;num1=0;
while flag:
    data = pd.read_excel('datatest02.xlsx')
    data.taskStartTime = pd.to_numeric(data.taskStartTime)
    data.taskEndTime = pd.to_numeric(data.taskEndTime)
    conf = conflict(data) #M矩阵为任务冲突矩阵，且为对称矩阵# 获取冲突矩阵

    print("====打印冲突矩阵====")
    print(conf)

    n = len(conf)# 节点总数
    node_sum = []# 每个节点的边数(计算行的数值和)
    for i in range(n):
        node_sum.append(sum(conf[i]))

    R, P, X = [[]] * n, [[]] * n, [[]] * n# 定义三个集合,R已确定的极大团顶点的集合,P未处理顶点集,X以搜过的并且属于某个极大团的顶点集合
    route = []
    P[0] = sorted(range(len(node_sum)), key=lambda k: node_sum[k], reverse=True)# 初始化,以边数做倒序
    BronKerbosch(0, 0, n, 0, -1)# 求解极大冲突团

    print("========极大团输出开始========")
    numJDT=[]#numJDT为极大团中元素的数目
    for key in route:
        numJDT.append(len(key))
        print(key)

    nummaxJDT=max(numJDT)#最大团中元素数目
    positionJDT = numJDT.index(max(numJDT)) #最大团的位置：从0开始数
    a=route[positionJDT];#用于放置最大冲突团包含的SS链簇的位置,最大冲突团包含的SS链簇
    print("最大冲突团包含的SS链簇",a)#[42, 57, 43, 39, 40, 46, 48, 51, 53, 55, 58, 59, 62]
    b=[];#用于放置最大冲突团包含的SS链簇的最晚开始的时间点
    c=[];#用于放置最大冲突团包含的SS链簇的最早结束的时间点
    d=[];#用于放置最大冲突团包含的SS链簇的威胁度等级
    Pa=[]#用于放置最大冲突团需要进行元素替换的SS的编号
    numTD=8;#用于放置该武器的最大空余通道数,属于动态变化的,可以先设计成8

    for key1 in a:
        b.append(data.taskStartTime[key1])
        c.append(data.taskEndTime[key1])
        d.append(data.threatLevel[key1])#各个SS链DJ目标的威胁度数据已经在上一个环节生成,此处只需要调用即可

    ###找到最大冲突团中SS链簇共享某个WQ的时间段[tstar,tend],Tstar为各个SS链最晚开始的时间点;Tend为各个SS链最早结束的时间点
    bmax=max(b)#极大团中data.taskStartTime的最大值
    cmin=min(c)#极大团中data.taskEndTime的最小值

    print("========极大团输出完毕========")
    print("最大团中SS链的数目:{}".format(nummaxJDT),",最大团在极大团中的位置:{}".format(positionJDT))
    if numTD<nummaxJDT:
        flag=True
        num1=num1+1
        print("当前WQ最大空余通道数目为:{},".format(numTD),
          "因此该WQ在{} -".format(bmax),"{}时间段发生了资源冲突。".format(cmin))
        ####提取SS链的威胁度进行排序,给出需要进行元素替换的SS的编号
        d1 = np.array(d)  # 列表[a,b,c,d]变数组[a b c d]
        # print(a)#SS链的向量[42, 43, 40, 41, 46, 47, 65, 48, 49, 50, 51, 53, 54, 55, 57, 58, 59, 64,                                                                                                                                                                                                                       62, 63, 66]
        # print(d)#SS链的向量元素对应的威胁度,列表
        # print(d1)#SS链的向量元素对应的威胁度系数,数组
        # print(abs(np.sort(-d1)))#威胁度正序排序
        z = np.argsort(-d1)  # 威胁度向量位置的逆序输出索引,从大到小
        e = z[-(len(z) - numTD):]
        list1 = e.tolist()
        for key2 in list1:
            Pa.append(a[key2])
        print("需要进行元素替换的SS的编号为:{}".format(Pa))###提取SS链的威胁度进行排序,给出需要进行元素替换的SS的编号
        # ResolvingResourceConflicts(Pa)#基于时间约束调整的消解
    else:
        print("检测消解完毕,该WQ未发生资源冲突")
        flag = False
###去除[48, 64, 66, ... ,46, 53]制导雷达元素,使用SS链寻优获得元素
##其中从48链-53链的威胁度依次降低

###去除[48, 64, 66, ...,46, 53]制导雷达元素,使用SS链寻优获得元素，完成
##开始消解完更新SS链的值,包括新武器的序号;新武器环节到下一个环节的时间;##

##消解完更新SS链##
###对该武器按上述步骤检测,消解,直到该武器没有资源冲突,再换一个武器检测消解####

###对该武器检测，消解，知道该武器没有资源冲突,再换一个武器检测消解####
print("资源冲突检测消解迭代总计:{}次".format(num1),
      "资源冲突检测消解用时总计:{}s".format(round(time.time()-st,3)))