智能排课系统

# 定义课程类

class Course:

def __init__(self, name, duration, teacher):

self.name = name

self.duration = duration

self.teacher = teacher

# 定义教师类

class Teacher:

def __init__(self, name, available_times):

self.name = name

self.available_times = available_times # 可用时间段列表

# 定义教室类

class Classroom:

def __init__(self, id, capacity, available_times):

self.id = id

self.capacity = capacity

self.available_times = available_times

# 排课函数

def schedule_courses(courses, teachers, classrooms):

scheduled = []

for course in courses:

for teacher in teachers:

if course.teacher == teacher.name:

for time in teacher.available_times:

for classroom in classrooms:

if time in classroom.available_times and classroom.capacity >= course.duration:

scheduled.append({

'course': course.name,

'teacher': teacher.name,

'classroom': classroom.id,

'time': time

})

# 标记该时间段已被占用

classroom.available_times.remove(time)

teacher.available_times.remove(time)

break

else:

continue

break

return scheduled

# 示例数据

courses = [

Course("数学", 2, "张老师"),

Course("英语", 1, "李老师")

]

teachers = [

Teacher("张老师", ["周一上午", "周三下午"]),

Teacher("李老师", ["周二上午", "周四下午"])

]

classrooms = [

Classroom(1, 30, ["周一上午", "周三下午"]),

Classroom(2, 40, ["周二上午", "周四下午"])

]

# 调用排课函数

result = schedule_courses(courses, teachers, classrooms)

print(result)

import random

# 定义课程和教师数据

courses = [

{"name": "数学", "duration": 2, "teacher": "张老师"},

{"name": "英语", "duration": 1, "teacher": "李老师"}

]

teachers = {

"张老师": ["周一上午", "周三下午"],

"李老师": ["周二上午", "周四下午"]

}

classrooms = {

1: {"capacity": 30, "times": ["周一上午", "周三下午"]},

2: {"capacity": 40, "times": ["周二上午", "周四下午"]}

}

# 遗传算法参数

population_size = 50

generations = 100

mutation_rate = 0.1

# 初始化种群

def initialize_population():

population = []

for _ in range(population_size):

individual = {}

for course in courses:

teacher = course["teacher"]

time = random.choice(teachers[teacher])

classroom = random.choice([1, 2])

if classrooms[classroom]["capacity"] >= course["duration"]:

individual[course["name"]] = {"teacher": teacher, "time": time, "classroom": classroom}

population.append(individual)

return population

# 适应度函数

def fitness(individual):

conflict = 0

for course in courses:

course_name = course["name"]

info = individual.get(course_name, {})

teacher = info.get("teacher")

time = info.get("time")

classroom = info.get("classroom")

# 检查教师是否在同一时间被安排多门课

for other_course in courses:

if other_course["name"] != course_name:

other_info = individual.get(other_course["name"], {})

if other_info.get("teacher") == teacher and other_info.get("time") == time:

conflict += 1

# 检查教室是否在同一时间被占用

for other_course in courses:

if other_course["name"] != course_name:

other_info = individual.get(other_course["name"], {})

if other_info.get("classroom") == classroom and other_info.get("time") == time:

conflict += 1

return -conflict # 最小化冲突

# 选择函数

def select(population):

sorted_pop = sorted(population, key=lambda x: fitness(x), reverse=True)

return sorted_pop[:int(population_size * 0.5)]

# 交叉函数

def crossover(parent1, parent2):

child = {}

for course in courses:

course_name = course["name"]

if random.random() > 0.5:

child[course_name] = parent1.get(course_name, {})

else:

child[course_name] = parent2.get(course_name, {})

return child

# 变异函数

def mutate(individual):

for course in courses:

course_name = course["name"]

if random.random() < mutation_rate:

teacher = course["teacher"]

time = random.choice(teachers[teacher])

classroom = random.choice([1, 2])

if classrooms[classroom]["capacity"] >= course["duration"]:

individual[course_name] = {"teacher": teacher, "time": time, "classroom": classroom}

return individual

# 运行遗传算法

population = initialize_population()

for generation in range(generations):

population = select(population)

new_population = []

while len(new_population) < population_size:

parent1 = random.choice(population)

parent2 = random.choice(population)

child = crossover(parent1, parent2)

child = mutate(child)

new_population.append(child)

population = new_population

# 找出最佳个体

best_individual = max(population, key=lambda x: fitness(x))

print("最佳排课方案：", best_individual)