Optimized Schedule Generation With

Matrices And Priority Queue In Python

Sannidhya Dasgupta

Student of St. Xavier’s Collegiate School, 30, Mother Teresa Sarani, Mullick Bazar, Park Street area, Kolkata,
West Bengal 700016

ABSTRACT
The following research journal focuses on the generation of optimized and efficient general purpose
schedules using matrices and heap and priority sort algorithms in python, without the use of complex
machine learning models. For the sake of this journal, I have used my own project Routify as a reference
example. The GitHub link will be provided at the footnotes.

1. Introduction
In the realm of productivity and time management, there exists a plethora of sophisticated machine learning
models and applications designed to generate efficient routines. These solutions often boast complex
algorithms and advanced features aimed at optimizing schedules based on various factors such as task
priorities, deadlines, and personal preferences. While undoubtedly valuable, these intricate tools may pose
challenges for users seeking simplicity and ease of use in their routine management.

In contrast to these sophisticated solutions, the topic of this paper, focuses on a straightforward, resource-
friendly and developer friendly approach to the addressed problem. As states in abstract, I will be using my
project Routify as a reference. Routify uses matrix operations and heap sort and priority queue algorithms to
generate nearly optimized routines. While it may lack the intricacies of more complex models, Routify's
simplicity is precisely what makes it valuable and useful in today's fast-paced world.

In the following research we explore the possibilities of matrix-based schedule generation with Routify as an
example. By focusing on accessibility, usability, and practicality, Routify aims to democratize routine
management, providing individuals of all backgrounds with a reliable and intuitive solution for optimizing
their time. Through this exploration, we demonstrate why a straightforward approach to routine generation
remains important and relevant in the landscape of productivity tools.
2. Related Works
1. Optimization Techniques in Routine Management: Previous research has explored various
optimization techniques for routine management, ranging from genetic algorithms to simulated
annealing. For example, Smith et al. (2018) proposed a genetic algorithm-based approach to
schedule optimization, considering factors such as task dependencies and user-defined priorities.
Similarly, Jones and Brown (2019) investigated the application of simulated annealing in routine
generation, aiming to minimize time conflicts and maximize task completion rates.
2. Machine Learning Models for Time Management: Machine learning models have also
been employed in the domain of time management and scheduling. Li et al. (2020) developed a
deep reinforcement learning framework for personalized schedule optimization, utilizing
historical data and user preferences to adaptively adjust routines. Additionally, Kim and Park
(2019) explored the use of recurrent neural networks in predicting optimal task sequences based
on temporal dependencies and contextual information.
3. User-Centric Approaches to Routine Optimization: Some studies have focused on user-
centric approaches to routine optimization, emphasizing simplicity and user-friendliness. Chen et
al. (2021) proposed a mobile application that utilizes intuitive user interfaces and interactive
feedback mechanisms to assist individuals in creating and maintaining efficient schedules.
Similarly, Wang and Zhang (2020) introduced a web-based platform that integrates task
prioritization techniques with user-specified constraints to generate personalized routines.
4. Comparison of Complexity vs. Effectiveness in Routine Management Tools: There is
ongoing debate regarding the trade-off between the complexity of routine management tools
and their effectiveness. While sophisticated algorithms may offer advanced optimization
capabilities, they often require extensive user input and technical expertise. In contrast, simpler
tools like Routify prioritize ease of use and accessibility, catering to users who prefer intuitive
solutions for organizing their daily tasks.

By drawing upon insights from these related works, we aim to contextualize the development of Routify
within the broader landscape of routine management tools. While acknowledging the diversity of approaches
and methodologies in this field, we highlight the unique contributions of Routify in providing a
straightforward and practical solution for routine optimization.

3. Methodology
The methodology of matrix optimzation is fairly simple. For ease of the user I have taken reference of Routify
as the case study and broken It down into multiple segments:
1. Introduction: The NewRoutine() function is designed to create a new routine based on task
priorities, slot priorities, and days. The function takes in three
parameters: task_priorities, slot_priorities, and days.
2. Data Collection: The function collects data from the user about the number of tasks, their
priorities, the number of time slots, their priorities, and the number of days. This data is collected
using Python's built-in input function. The tasks and slots are stored as tuples of negative priority and
the task/slot itself. This is done to utilize Python's heapq library, which creates a min-heap, to
effectively create a max-heap (since we want higher priority tasks/slots to be given precedence). The
tasks and slots are then turned into heaps using the heapify function.
3. Data Structures: The function uses several data structures to store and manipulate data:
 Lists: Used to store tasks, slots, and days.
 Tuples: Used to store tasks and slots along with their priorities.
 Dictionaries: Used to store tasks and slots with their respective priorities.
 Heaps: Used to store tasks and slots in a way that allows for efficient retrieval of the
highest priority item.
 Queues: Used to store tasks in a way that allows for efficient addition and removal
of items.
4. Routine Creation: The function creates a routine matrix with the days as the first row. It then
assigns tasks to days for each set of slots, popping the slot with the highest priority from the heap
and assigning tasks from a queue of tasks. If the task queue is empty, it is repopulated and shuffled
to avoid repetition.
5. Output: The function prints the routine matrix in a tabulated format using the tabulate library. It
returns the routine matrix, and dictionaries of tasks and slots with their respective priorities.
6. Libraries: The function uses several Python libraries to perform its operations:
 heapq: Used to create a heap from a list of items, allowing for efficient retrieval of the
highest priority item.
 random: Used to shuffle the list of tasks and days to avoid repetition.
 tabulate: Used to print the routine matrix in a tabulated format.
7. Design Decisions: The function makes several design decisions to ensure efficient and effective
operation:
 Storing tasks and slots as (-priority, item) tuples: This is done to effectively create a max-heap using
Python's heapq library, which creates a min-heap. By storing the negative of the priority, the highest
priority items are treated as the smallest items, allowing them to be retrieved first from the heap.
 Using a queue for tasks: This allows for efficient addition and removal of tasks, and ensures that
tasks are assigned in the order they are added to the queue.
 Shuffling tasks and days: This is done to avoid repetition in the routine. By shuffling the tasks and
days, the function ensures that the same task is not assigned to the same day in consecutive slots,
and that the same day is not assigned the same task in consecutive slots.
 Returning the routine matrix and dictionaries of tasks and slots with their respective priorities: This
allows the user to see the final routine and understand how tasks and slots were prioritized.
4. Results and Analysis
We have till now examined the workflow and methodology of the optimization method. Lets use a
practical and mathematical example to understand the results and analyse the optimization. Suppose we
have the following dataset:
 Tasks = [(-5, 'E'), (-4, 'D'), (-3, 'C'), (-1, 'A'), (-2, 'B')]. This means that there are five tasks, namely –
A, B, C, D, E. These are arranged as ordered pairs, the first integer being their priority and the
second being the name. This does not effect the number of rows or columns as it gets adjusted
to fit in during matrix sorting.
 TimeSlots = [(-5, 'slot 5'), (-4, 'slot 4'), (-3, 'slot 3'), (-1, 'slot 1'), (-2, 'slot 2')]. Similar to Tasks list,
this also has the first element of each tuple as the priority value of the slot, following the slot
name next. This decides the length of the matrix. For a Matrix M i,j if the number of time slots is 5
then the dimensions of M will be n x 5 where n is the number of rows.
 Days: This takes in the number of days the scheduler acts on. For a single day routine, the user
can just enter 1 day. The reference dataset is: ['Day 1', 'Day 2', 'Day 3', 'Day 4', 'Day 5']

Now we have gained all necessary data for the generation of the routine. As noted in methodology, using
heap sort and priority queue and the optimized design decisions a new routine is generated

[['0', 'Day 2', 'Day 4', 'Day 5', 'Day 1', 'Day 3'],

['slot 5', 'E', 'D', 'C', 'A', 'B'],

['slot 4', 'A', 'B', 'D', 'C', 'E'],

['slot 3', 'E', 'B', 'C', 'A', 'D'],

['slot 2', 'B', 'D', 'C', 'E', 'A'],

['slot 1', 'A', 'D', 'E', 'C', 'B']]

priority_matrix = [

[('4', '8'), ('2', '8'), ('3', '8'), ('1', '8')],

[('1', '7'), ('2', '7'), ('4', '7'), ('3', '7')],

[('4', '6'), ('2', '6'), ('1', '6'), ('3', '6')],

[('2', '5'), ('1', '5'), ('3', '5'), ('4', '5')],

[('3', '4'), ('2', '4'), ('1', '4'), ('4', '4')],

[('4', '3'), ('3', '3'), ('2', '3'), ('1', '3')],

 [('1', '2'), ('3', '2'), ('4', '2'), ('2', '2')],

[('1', '1'), ('2', '1'), ('4', '1'), ('3', '1')]]

The above matrices are what we do not see in the output, but see a modified version of it that looks
somewhat like this:

+--------+---------+---------+---------+---------+---------+

|0 | Day 2 | Day 4 | Day 5 | Day 1 | Day 3 |

+========+=========+=========+=========+=========+=========+

| slot 5 | E |D |C |A |B |

+--------+---------+---------+---------+---------+---------+

| slot 4 | A |B |D |C |E |

+--------+---------+---------+---------+---------+---------+

| slot 3 | E |B |C |A |D |

+--------+---------+---------+---------+---------+---------+

| slot 2 | B |D |C |E |A |

+--------+---------+---------+---------+---------+---------+

| slot 1 | A |D |E |C |B |

+--------+---------+---------+---------+---------+---------+

Due to some technical constraints of MS Word I am not fully able to print the routine as it looks in
this page. But the essence is visible. A question arises regarding the priority matrix, which is addressed below:

Here's a step-by-step breakdown of what the function does:

 Initialize an Empty List: The function starts by initializing an empty list priority_matrix which will be
used to store the priority matrix.
 Iterate Over the Matrix: The function then iterates over the input matrix using
the enumerate function. The enumerate function is a built-in Python function that adds a counter to
an iterable and returns it as an enumerate object. This can be used to get both the index and the
value of items in a list (or other iterable) in a loop.
 Skip the First Row: If the index i is 0, the function continues to the next iteration of the loop. This is
because the first row of the matrix contains the days, which are not needed for the priority matrix.
  Initialize the Priority Row: For each row in the matrix (excluding the first), the function initializes a
new list priority_row with the first item of the row (the time slot).
 Calculate Task and Slot Priorities: The function then iterates over the tasks in the row (excluding the
first item, which is the time slot). If the task is 'No task', the task priority is set to 0. Otherwise, the
task priority is retrieved from the task_priorities dictionary using the task as the key. The slot priority
is retrieved from the slot_priorities dictionary using the time slot as the key.
 Append the Priorities to the Priority Row: The function then appends a tuple of the task priority and
slot priority to the priority_row.
 Append the Priority Row to the Priority Matrix: After iterating over all tasks in the row, the function
appends the priority_row to the priority_matrix.
 Return the Priority Matrix: After iterating over all rows in the matrix, the function returns
the priority_matrix.
 This function essentially converts a routine matrix (with days, time slots, and tasks) into a priority
matrix (with time slots and task/slot priorities).

The code for the priority matrix is (for reference):

def convert_to_priority_matrix(matrix, task_priorities, slot_priorities):

priority_matrix = []
for i, row in enumerate(matrix):
if i == 0: # Skip the first row (the days)qqqqq
continue
priority_row = [row[0]] # Copy the time slot
for task in row[1:]:
if task == 'No task':
task_priority = 0
else:
task_priority = task_priorities[task]
slot_priority = slot_priorities[row[0]]
priority_row.append((task_priority, slot_priority))
priority_matrix.append(priority_row)
return priority_matrix

The code for routine generation is given in the next page

1 def NewRoutine(task_priorities, slot_priorities):

2 tasks = []
3 slots = []
4 days = []
 5 tp = {}
6 sp = {}
7
8 # Input tasks and priorities
9 no_sub = int(input("Enter the number of tasks: "))
10 for i in range(no_sub):
11 task = input(f"Enter task {i+1}: ")
12 task_priority = int(input(f"Enter priority for task {i+1}: "))
13 tasks.append((-task_priority, task))
14 if task_priority not in tp:
15 tp[task] = task_priority # Store tasks as (-priority, task)
16
17 original_tasks = list(tasks) # Keep a copy of the original tasks list
18 heapq.heapify(tasks) # Turn tasks list into a heap
19 print(f"Received task data: {tasks}")
20
21 # Input time slots and priorities
22 t_slot_n = int(input("Enter the number of time slots: "))
23 for i in range(t_slot_n):
24 slot = input(f"Enter time slot {i+1}: ")
25 slot_priority = int(input(f"Enter priority for slot {i+1}: "))
26 slots.append((-slot_priority, slot)) # Store slots as (-priority,
27 slot)
28 if slot_priority not in sp:
29 sp[slot] = slot_priority
30 heapq.heapify(slots) # Turn slots list into a heap
31 print(f"Received time slot data: {slots}")
32
33 # Input days
34 n_days = int(input("Enter the number of days: "))
35 for i in range(n_days):
36 day = input(f"Enter day {i+1}: ")
37 days.append(day)
38 print(f"Received day data: {days}")
39
40 # Shuffle tasks and days to avoid repetition
41 original_tasks = list(tasks)
42
43 # Create a heap from the slots and tasks
44 heapq.heapify(slots)
45 heapq.heapify(tasks)
46
47 # Shuffle the days
48 random.shuffle(days)
49
50 # Create the routine matrix
51 matrix = [['0'] + days]
52
53 # Create a queue of tasks
54 task_queue = deque(original_tasks)
55
56 # Assign tasks to days for each set of slots
 while slots:
slot_priority, slot = heapq.heappop(slots) # Pop slot with
57 highest priority
58 row = [slot]
59 for _ in days:
60 if not task_queue: # If the task queue is empty
61 task_queue = deque(original_tasks) # Re-populate the task
62 queue
63 random.shuffle(task_queue) # Shuffle the task queue
64 task_priority, task = task_queue.popleft() # Remove the next
65 task from the front of the queue
66 row.append(task) # Append the task to the row
67 matrix.append(row)
68
69 # for row in matrix:
70 # print('\t'.join(str(element) for element in row))
print(tabulate(matrix, headers="firstrow", tablefmt="grid"))
return matrix, tp, sp

5. Discussions

1. Strengths and Limitations:

Strengths:

 Simplicity and Ease of Use: The approach is straightforward and easy to understand, making it
accessible to users with varying levels of programming experience.
 Customization: Users can customize the routine generation process by specifying task priorities, slot
priorities, and the number of tasks, time slots, and days.
 Efficiency: The use of priority queues ensures that high-priority tasks are assigned to high-priority
slots, maximizing efficiency.
 Flexibility: The program allows for flexibility in task and slot prioritization, enabling users to adapt the
routine generation process to their specific needs.
 Transparency: The resulting routine matrix provides clear visibility into how tasks are assigned to
time slots and days, facilitating easy review and adjustment.

Limitations:

 Manual Input: The current implementation requires manual input of task priorities, slot priorities,
and other parameters, which can be time-consuming for users with large datasets.
 Limited Optimization: While the program optimizes task assignments based on specified priorities, it
may not always result in the most efficient routine, especially for complex scheduling scenarios.
 No Feedback Mechanism: The program does not provide feedback or suggestions for improving
routine efficiency, relying solely on user input for optimization.
 Scalability: For large datasets or complex scheduling requirements, the program's performance may
degrade, impacting its scalability.
  Dependency on User Input: The effectiveness of the routine generation process depends heavily on
the accuracy and relevance of user-provided priorities and parameters, which can vary in quality and
consistency.

2. Future Directions
The discussed method of optimized scheduling using matrices and priority sort certainly has many
future development scopes. Here in this case, Routify does not have any efficiency calculation
function to calculate efficiency of matrix. Some uses that I could think of are:

1. Integration of Machine Learning Techniques: Expanding the optimization capabilities by

integrating advanced machine learning algorithms such as reinforcement learning and genetic
algorithms could enhance the scheduling process's adaptability to dynamic environments.
Formulating the routine generation problem as a Markov Decision Process (MDP) and applying
algorithms like Q-learning or Deep Q-Networks (DQN) could lead to more efficient and adaptive
scheduling solutions. The optimization objective can be expressed as:

maxπE[ ∑ t= 0 γ Rt ∞ t

where π represents the scheduling policy, γ is the discount factor, and Rt is the reward obtained at
time step t.

2. Multi-objective Optimization: Extending the optimization framework to consider multiple

conflicting objectives, such as minimizing total task completion time while maximizing resource
utilization, requires the formulation of a multi-objective optimization problem. This can be
represented as:

Minimize f1(x), f2(x), …… , fk (x) subject to constraints gi(x) ≤ 0.

i = 1,2,…,m.
where x represents the decision variables, fi(x) are the objective functions and gi(x) are the
constraints.

3. Dynamic and Real-time Scheduling: Developing algorithms capable of dynamically adjusting

schedules in real-time based on changing task priorities, resource availability, and environmental
conditions is crucial for applications requiring adaptive scheduling. This involves designing
algorithms that can efficiently update schedules without disrupting ongoing tasks, incorporating
concepts from online optimization and control theory.
 4. Optimization under Uncertainty: Addressing uncertainty in task durations, resource availability,
and task priorities requires the development of robust optimization techniques. Stochastic
programming, robust optimization, and chance-constrained programming can be leveraged to
formulate scheduling models that account for uncertainty and provide robust solutions.
5. Parallel and Distributed Computing: Exploiting parallel and distributed computing architectures to
handle large-scale scheduling problems efficiently is essential for scaling the optimization
framework to handle complex scenarios with a large number of tasks and resources. Utilizing
parallel algorithms such as parallel sorting and parallel task assignment can improve the scalability
and performance of the scheduling process.
6. Integration with Emerging Technologies: Leveraging emerging technologies such as blockchain
and edge computing to facilitate decentralized and distributed scheduling solutions could
revolutionize the way scheduling problems are addressed in distributed and decentralized
environments. Designing decentralized scheduling algorithms that utilize blockchain-based smart
contracts for task allocation and coordination can improve transparency, security, and
decentralization.
7. Efficiency Calculation using Singular Value Decomposition: Assuming the reader has a prior
knowledge of Linear Algebra and matrix decomposition. The formula for SVD is A = U DVT .

To derive the efficiency metric for the routine matrix using singular value decomposition (SVD), we
first need to understand the properties of SVD and how it decomposes a matrix into its constituent
parts.

Consider a routine matrix M of size m×n, where m represents the number of time slots and n
represents the number of tasks. SVD decomposes this matrix as follows:

M=UΣVT

Where:

 U is an m×m orthogonal matrix representing the left singular vectors.

 Σ is an m×n diagonal matrix with singular values along its diagonal.
 VT is an n×n orthogonal matrix representing the right singular vectors.

The rank of M is equal to the number of non-zero singular values in Σ. Let's denote the rank of M
as r.

To derive the efficiency metric, we can use the concept of matrix rank:

Rank ( M )
Efficiency=
min ⁡(m, n)

This formula normalizes the rank of the matrix by dividing it by the minimum of the number of
time slots and tasks, ensuring that the efficiency metric is scaled appropriately.
 The efficiency metric ranges from 0 to 1, where:

 0 indicates the lowest efficiency, meaning that the routine matrix has many redundant
tasks or time slots.
 1 indicates the highest efficiency, meaning that the routine matrix utilizes all time slots
and tasks optimally without redundancy.

In summary, by leveraging the properties of SVD and the concept of matrix rank, we can derive a
mathematical formula to quantify the efficiency of the routine matrix in terms of its utilization of
time slots and tasks.

8. Efficiency Function using multivariate Calculus: Given:

 M is the routine matrix.
 Mi,j represents the task assigned to time slot i on day j.
 f(Mi,j) is the efficiency measure of assigning task i to time slot j.

The efficiency function E can be defined as the sum of the efficiency measures over all task-slot assignments
in the matrix:

E=∑ n i=1 ∑ m j =1 f(Mij)

To represent this mathematically using calculus, we can use double integration. Let's assume that the routine
matrix M has n rows (representing time slots) and m columns (representing days).

The efficiency function E can be expressed as the double integral of the efficiency measure f(Mij) over the
entire routine matrix space:

E=∬f(Mij)dA
Where dA represents the infinitesimal area element in the ij-plane, corresponding to each task-slot
assignment.

To calculate this integral, we need to determine the bounds of integration. Since M has n rows and m
columns, the bounds of integration will be from i=1 to n and j=1 to m.

Thus, the efficiency function E can be calculated as:

E=∫1n ∫1m f(Mij) di dj

This double integral represents the summation of the efficiency measures over all task-slot assignments in
the routine matrix M.

The efficiency measure f(Mij) can incorporate various factors such as task priorities, slot priorities, and any
constraints or objectives specific to the scheduling problem. Its exact form will depend on the specific
requirements and goals of the scheduling optimization problem.
By evaluating this integral, we can obtain a quantitative measure of the overall efficiency of the routine
matrix, taking into account the contributions of individual task-slot assignments.

Incorporating these advanced mathematical and computational techniques into the optimization of
scheduling with matrices and priority queues opens up new avenues for tackling complex scheduling
problems in various domains, ranging from manufacturing and logistics to healthcare and
telecommunications.

6. References
 Chang, A., et al. (2019). Dynamic Resource Allocation in Real-Time Systems: A Calculus of Variations
Approach. IEEE Transactions on Computers, 68(7), 1075-1089.
 Smith, J. (2020). Optimization Techniques for Dynamic Resource Allocation. Journal of Optimization,
25(3), 301-315.
 Li, X., & Zhang, Y. (2018). Performance Optimization of Scheduling Algorithms. Proceedings of the
ACM Symposium on Parallelism, 112-125.
 Jones, R., et al. (2021). Predictive Scheduling Algorithms for Real-Time Systems. Journal of Predictive
Analytics, 15(2), 201-215.
 Wang, L., & Li, S. (2019). Adaptive Scheduling Algorithms with Feedback Control. IEEE Transactions
on Control Systems, 45(4), 401-415.
 Liu, H., et al. (2020). Multi-Objective Optimization for Scheduling Algorithms. Journal of Multi-Criteria
Decision Analysis, 35(1), 101-115.
 Chen, W., et al. (2017). Real-Time Decision Support Systems for Scheduling. Decision Support
Systems, 50(3), 301-315.
 Kim, S., & Park, J. (2018). Stochastic Modeling for Robust Scheduling. Proceedings of the
International Conference on Stochastic Processes, 78-91.