基于python代码，实现500个节点进行随机多项式，计算运行时间和所占内存，然后将节点基于位置的分配分区之后，再次计算得出时间和内存的对比结果，并绘图

以下是基于 Python 的实现，用于生成随机多项式并计算运行时间和所占内存，并进行基于位置的分配分区后再次计算得出时间和内存的对比结果，并绘图。

import random
import time
import psutil
import matplotlib.pyplot as plt

# 生成随机多项式，n 为节点数量
def generate_polynomial(n):
    polynomial = []
    for i in range(n):
        coefficient = random.randint(-100, 100)
        exponent = random.randint(0, 10)
        polynomial.append((coefficient, exponent))
    return polynomial

# 计算多项式的值，x 为变量值，polynomial 为多项式
def calculate_polynomial(x, polynomial):
    result = 0
    for term in polynomial:
        result += term[0] * x ** term[1]
    return result

# 计算运行时间和所占内存，n 为节点数量
def calculate_time_and_memory(n):
    polynomial = generate_polynomial(n)
    x = random.randint(-100, 100)
    start_time = time.time()
    result = calculate_polynomial(x, polynomial)
    end_time = time.time()
    memory_usage = psutil.Process().memory_info().rss
    return end_time - start_time, memory_usage

# 基于位置的分配分区，n 为节点数量，m 为区域数量
def partition_by_position(n, m):
    partition_size = n // m
    partitions = []
    for i in range(m):
        start_index = i * partition_size
        end_index = (i + 1) * partition_size if i < m - 1 else n
        partitions.append((start_index, end_index))
    return partitions

# 计算基于位置的分配分区后的运行时间和所占内存，n 为节点数量，m 为区域数量
def calculate_time_and_memory_with_partition(n, m):
    polynomial = generate_polynomial(n)
    x = random.randint(-100, 100)
    partitions = partition_by_position(n, m)
    start_time = time.time()
    result = 0
    for partition in partitions:
        result += calculate_polynomial(x, polynomial[partition[0]:partition[1]])
    end_time = time.time()
    memory_usage = psutil.Process().memory_info().rss
    return end_time - start_time, memory_usage

# 绘制运行时间和内存对比图，x 为节点数量列表，y1 为非分区运行时间列表，y2 为分区运行时间列表，y3 为非分区内存列表，y4 为分区内存列表
def plot_comparison(x, y1, y2, y3, y4):
    plt.figure()
    plt.subplot(2, 1, 1)
    plt.plot(x, y1, label='Without Partition')
    plt.plot(x, y2, label='With Partition')
    plt.title('Time Comparison')
    plt.xlabel('Number of Nodes')
    plt.ylabel('Time (s)')
    plt.legend()
    plt.subplot(2, 1, 2)
    plt.plot(x, y3, label='Without Partition')
    plt.plot(x, y4, label='With Partition')
    plt.title('Memory Comparison')
    plt.xlabel('Number of Nodes')
    plt.ylabel('Memory Usage (bytes)')
    plt.legend()
    plt.show()

# 测试
node_counts = [10, 50, 100, 200, 300, 400, 500]
partition_count = 5
without_partition_times = []
with_partition_times = []
without_partition_memories = []
with_partition_memories = []
for n in node_counts:
    t1, m1 = calculate_time_and_memory(n)
    t2, m2 = calculate_time_and_memory_with_partition(n, partition_count)
    without_partition_times.append(t1)
    with_partition_times.append(t2)
    without_partition_memories.append(m1)
    with_partition_memories.append(m2)
plot_comparison(node_counts, without_partition_times, with_partition_times, without_partition_memories, with_partition_memories)

该实现根据节点数量列表 `node_counts` 生成随机多项式，并分别计算非分区和分区的运行时间和所占内存，然后绘制运行时间和内存的对比图。在测试中，节点数量从10到500，分区数量为5。可以通过修改这些参数来测试不同的情况。