11

import pulp
import numpy as np

# 创建线性规划问题
model = pulp.LpProblem("CrossDistribution", pulp.LpMaximize)

# 定义评审专家数量和作品数量
num_experts = 125
num_works = 3000

# 定义每位评审专家最多评审的作品数量和每份作品需要被评审的专家数量
k = 120  # 每个专家最多评审的作品数量
m = 5  # 每份作品需要被评审的专家数量

# 创建二进制变量x(i, j)
x = pulp.LpVariable.dicts("x", ((i, j) for i in range(num_experts) for j in range(num_works)), cat='Binary')

# 定义目标函数：最大化交叉评审数量
model += pulp.lpSum(x[i, j] for i in range(num_experts) for j in range(num_works))

# 添加约束条件
# 每位评审专家最多评审k份作品的约束
for i in range(num_experts):
    model += pulp.lpSum(x[i, j] for j in range(num_works)) <= k

# 每份作品需要被评审m位专家的约束
for j in range(num_works):
    model += pulp.lpSum(x[i, j] for i in range(num_experts)) == m

# 求解线性规划问题
model.solve()

# 打印结果
print("Status:", pulp.LpStatus[model.status])
assignments = np.zeros((num_experts, num_works))
# 打印每位评审专家评审的作品列表
for i in range(num_experts):
    selected_works = [j for j in range(num_works) if x[i, j].value() == 1]
    for j in selected_works:
        assignments[i - 1, j] = 1
    print(f"评审专家 {i + 1} 评审的作品列表：{selected_works}")

print(assignments)  # 分配矩阵
print(np.sum(assignments, axis=0))


def calculateCorrelation(matrix):
    num_experts = matrix.shape[0]
    num_works = matrix.shape[1]
    counter = 0
    cor = 0
    for expertx in range(num_experts):
        for expertx1 in range(expertx + 1, num_experts):
            cor += np.sum(matrix[expertx] * matrix[expertx1])
            counter += 1

    cor /= counter
    return cor


print("rate:", calculateCorrelation(assignments))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import json
import math
def find_score(df,column_indices):
    multiple_columns_data = df.iloc[:, column_indices]
    array_from_to_numpy = multiple_columns_data.values[2:]
    result = []
    for arrary in array_from_to_numpy:
        result.extend(arrary)
    prof_list = list(set(result))
    # 统计第二阶段评审
    index = 0
    flag = 0
    for i, arrary in enumerate(array_from_to_numpy):
        for a in arrary:
            if isinstance(a, float):
                index = i
                flag = 1
                break
        if flag == 1:
            break

    second_stage_list = array_from_to_numpy[:index].tolist()
    return second_stage_list

def cover_iloc(array_from_to_numpy):
    all_result = []
    for i in range(len(array_from_to_numpy[0])):
        tmp = []
        for j in range(len(array_from_to_numpy)):
            tmp.append(array_from_to_numpy[j][i])
        all_result.append(tmp)
    return all_result

def Calculation_of_standard_scores(array_from_to_numpy_or):
    all_stand_score = []
    for score in array_from_to_numpy_or:
        or_score = integer_list = [int(x) for x in score]
        expert_num = len(or_score)
        stand_score = []
        _a = sum(or_score) / expert_num
        _sum = 0
        for i in range(expert_num):
            _sum += pow(or_score[i] - _a, 2)
        s = math.sqrt(_sum / (expert_num - 1))
        for i in range(expert_num):
            x_k = 50 + 10 * ((or_score[i] - _a) / (s + 1))
            stand_score.append(int(x_k))
        all_stand_score.append(stand_score)
    #print(all_stand_score)
    return all_stand_score
def find_or_st_2():
    # 读取Excel文件，指定文件路径
    excel_file = '数据1.xlsx'
    # 使用pandas的read_excel函数读取Excel文件
    df = pd.read_excel(excel_file)
    column_indices_or = [24, 28, 32]
    array_from_to_numpy_or = find_score(df, column_indices_or)
    array_from_to_numpy_or = cover_iloc(array_from_to_numpy_or)
    #print(array_from_to_numpy_or)
    array_from_to_numpy_st = Calculation_of_standard_scores(array_from_to_numpy_or)
    return array_from_to_numpy_or, array_from_to_numpy_st
if __name__ == '__main__':

    array_from_to_numpy_or, array_from_to_numpy_st = find_or_st_2()
    bin_width = 10
    bins = list(range(0, 101, bin_width))

    # 初始化一个列表，用于存储每个小列表中每个区间的数值个数
    histograms = []
    # 计算需要创建的子图数量
    num_subplots = len(array_from_to_numpy_or)

    # 计算每行显示的子图数量（一行排两个，不足两个的就排一个）
    num_cols = 2
    num_rows = (num_subplots + 1) // 2

    # 创建一个大图，拥有动态确定的子图布局
    fig, axs = plt.subplots(num_rows, num_cols, figsize=(12, 6 * num_rows))

    # 遍历大列表中的每个小列表
    # 遍历大列表中的每个小列表
    for i, (small_list_or, small_list_st) in enumerate(zip(array_from_to_numpy_or, array_from_to_numpy_st)):
        # 使用numpy的histogram函数计算数值列表的分布
        hist_or, bin_edges_or = np.histogram(small_list_or, bins=bins)
        hist_st, bin_edges_st = np.histogram(small_list_st, bins=bins)

        # 计算当前子图的行和列索引
        row_idx = i // num_cols
        col_idx = i % num_cols
        # 处理直方图数据，将负数替换为0
        hist_or = np.clip(hist_or, 0, None)
        hist_st = np.clip(hist_st, 0, None)
        # 绘制条形图，并指定ax参数，以便将每个条形图绘制在不同的子图上
        axs[row_idx, col_idx].bar(bin_edges_or[:-1], hist_or, width=bin_width, align='edge', alpha=0.5, label='original score')
        axs[row_idx, col_idx].bar(bin_edges_st[:-1], hist_st, width=bin_width, align='edge', alpha=0.5, label='standard scores')

        # 设置X轴和Y轴标签
        axs[row_idx, col_idx].set_xlabel('corridor')
        axs[row_idx, col_idx].set_ylabel('Number')
        # 设置子图标题
        axs[row_idx, col_idx].set_title(f'Distribution of ratings for expert {i+1}')

        # 添加图例
        axs[row_idx, col_idx].legend()

    # 隐藏不需要的空白子图
    for i in range(num_subplots, num_cols * num_rows):
        axs[i // num_cols, i % num_cols].axis('off')

    # 调整子图之间的距离
    plt.tight_layout()

    # 显示图形
    plt.show()