Giới thiệu dự án

Trong kỷ nguyên số hóa và môi trường làm việc hỗn hợp (hybrid work), khối lượng công việc của mỗi cá nhân ngày càng gia tăng và trở nên phân mảnh. Theo nghiên cứu năng suất kinh điển của David Allen (tác giả phương pháp Getting Things Done - GTD), mỗi cá nhân trung bình phải xử lý đồng thời từ 50 đến 150 nhiệm vụ lớn nhỏ tại bất kỳ thời điểm nào. Khảo sát năm 2022 của Reclaim.ai trên 2.000 chuyên gia làm việc với 5 nền tảng quản trị công việc phổ biến (Jira, Todoist, Asana, Trello, ClickUp) chỉ ra rằng người lao động dành trung bình 4,32 giờ/ngày (~30,24 giờ/tuần) cho công việc thực tế, trong đó thời gian bị lãng phí do việc phân bổ lịch trình thủ công, chuyển ngữ cảnh (context switching) và gián đoạn công việc chiếm đến 20–30% tổng quỹ thời gian.

+-------------------------------------------------------------------------------+
| Bối cảnh: 50-150 Tasks/người  --->  Quỹ thời gian: 4.32h/ngày (~30.24h/tuần)   |
| Vấn đề: Lập lịch thủ công tốn thời gian, chia nhỏ tác vụ vi phạm split-min    |
| Giải pháp: Tối ưu hóa PSP đa phương pháp (MILP 1, MILP 2, Heuristic ASS, TBASS)|
| Mục tiêu: Cực tiểu hóa Makespan (Cmax) & Giảm thời gian trễ lập lịch < 1s     |
+-------------------------------------------------------------------------------+

Vấn đề nghiên cứu (Problem Statement)

Hầu hết các nghiên cứu lập lịch cổ điển tập trung vào môi trường công nghiệp (Job-shop, Flow-shop, Open-shop, Project Scheduling) với nhiều máy song song hoặc chia sẻ tài nguyên phần cứng. Trong khi đó, Bài toán Lập lịch Cá nhân (Personal Scheduling Problem - PSP) mang đặc thù một người thực thi (Single Machine) với các ràng buộc thực tế:

  • Các khoảng thời gian trống khả dụng (Available Time-Windows - $W_t$) bị chia cắt bởi các mốc bận cố định (Break-times - $b_t$).
  • Một công việc lớn có thể chia nhỏ (Bounded Splitting) thành các công việc phụ (subjobs), nhưng phải thỏa mãn ngưỡng chia nhỏ tối thiểu (split-min) để đảm bảo hiệu suất tập trung, tránh hiện tượng phân mảnh vi mô (micro-fragmentation).
  • Mỗi lần bắt đầu hoặc tiếp tục một subjob đều tiêu tốn một khoảng thời gian thiết lập/chuẩn bị (Setup Time - $s_i \approx 10% p_i$).

Mục tiêu nghiên cứu (Project Objectives)

  1. Hình thức hóa toán học và chuẩn hóa bài toán PSP theo tuần: Xây dựng hệ thống ràng buộc chặt chẽ kết hợp thời gian xử lý ($p_i$), thời gian chuẩn bị ($s_i$), ngưỡng chia nhỏ ($splitmin$) và các cửa sổ thời gian ($W_t$).
  2. Thiết kế và triển khai 4 phương pháp giải thuật: Phát triển 2 mô hình toán học chính xác (MILP 1, MILP 2), 1 giải thuật xấp xỉ Heuristic Assignment (ASS), và 1 giải thuật siêu phỏng đoán tối ưu cục bộ Tabu Search kết hợp Assignment (TBASS).
  3. Xây dựng bộ dữ liệu benchmark thực tế: Tạo lập 3 bộ dữ liệu thử nghiệm chuẩn hóa (DS1: 10–20 jobs, DS2: 20–30 jobs, DS3: 30–40 jobs) với độ phân giải thời gian 5 phút/đơn vị dựa trên hành vi thực tế.
  4. Đánh giá hiệu năng đa chiều: So sánh toàn diện giữa nghiệm tối ưu toàn cục và nghiệm xấp xỉ về độ lệch cận dưới (%LB - Percentage over Lower Bound) và thời gian tính toán thực thi (CPU execution time).

Phạm vi và giới hạn (Scope & Limitations)

  • Phạm vi: Lập lịch công việc cá nhân trong chu kỳ 1 tuần làm việc (7 ngày, tương đương ~30–40 giờ làm việc thực tế), đơn vị thời gian chuẩn hóa: 1 time-unit = 5 phút.
  • Giới hạn: Mô hình giả định các công việc độc lập (chưa xét ràng buộc tiền điều kiện - precedence constraints phức tạp) và thời gian thực thi của mỗi tác vụ là tất định (deterministic).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Tiêu chí so sánh Phương pháp Thủ công (Calendar/To-Do List) Thuật toán Exact (MILP truyền thống) Giải pháp Đề xuất trong Đồ án (Heuristic ASS & Metaheuristic TBASS)
Độ phức tạp tính toán Thấp ($O(n)$ thao tác người dùng) Rất cao ($O(2^{n \cdot m} \cdot UB^{2nm})$) Thấp đến trung bình ($O(n \cdot m)$ đến $O(n^2 \cdot m)$)
Khả năng tối ưu $C_{max}$ Kém (dễ chồng chéo, phân mảnh) Tối ưu tuyệt đối (nếu không timeout) Tiệm cận tối ưu (khoảng cách %LB < 15–20%)
Ràng buộc Split-min & Setup-time Không hỗ trợ tự động Hỗ trợ đầy đủ nhưng chậm Xử lý triệt để qua luật gán 3 trường hợp
Thời gian tính toán với $n \ge 30$ Không áp dụng $> 300\text{s}$ (thường không hội tụ) $< 1.5\text{s}$ (đáp ứng tương tác thời gian thực)

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

  • Must-have: Không cắt công việc nhỏ hơn $splitmin$; không xếp chồng chéo qua mốc $break-time$; cộng dồn chính xác $s_i$ cho mỗi subjob; hoàn thành 100% tổng khối lượng công việc $\sum p_i$.
  • Should-have: Cực tiểu hóa thời điểm hoàn thành cuối cùng ($C_{max}$); hỗ trợ cửa sổ mở rộng vô hạn ($W_{\infty}$) để luôn đảm bảo tồn tại lời giải khả thi.
  • Could-have: Trực quan hóa tiến độ bằng biểu đồ Gantt tự động thông qua Matplotlib.
  • Won't-have (giai đoạn này): Tái lập lịch động thời gian thực khi có tác vụ khẩn cấp chen ngang (dynamic preemption).

Công nghệ sử dụng và phiên bản

  • Ngôn ngữ lập trình: Python 3.10.12 (Đảm bảo tính linh hoạt và khả năng xử lý cấu trúc dữ liệu tối ưu).
  • Thư viện Tối ưu hóa Toán học: Python-MIP 1.14.0 tích hợp bộ giải COIN-OR CBC Solver 2.10.8.
  • Thư viện Phân tích & Xử lý Dữ liệu: Pandas 2.0.3, NumPy 1.24.3.
  • Thư viện Trực quan hóa Dữ liệu: Matplotlib 3.7.2.
  • Định dạng Lưu trữ & Trao đổi Dữ liệu: CSV (Dataset storage), XLSX (Evaluation logs).

Thiết kế kiến trúc dữ liệu và mô hình hóa

Dữ liệu của bài toán được mô hình hóa qua các cấu trúc vector và ma trận:

  • Tập công việc (Jobs): $J = {J_1, J_2, \dots, J_n}$, mỗi công việc $J_i$ có thời gian xử lý $p_i \in \mathbb{N}^+$ và thời gian thiết lập $s_i = \lceil p_i / 10 \rceil$.
  • Tập cửa sổ thời gian (Windows): $W = {W_1, W_2, \dots, W_m}$, mỗi cửa sổ $W_t = [b_{t-1}, b_t]$ có độ dài khả dụng $w_t = b_t - b_{t-1}$.
  • Ràng buộc chia nhỏ: $splitmin = \frac{\text{Thời gian TB 1 việc trong tuần}}{\text{Số subjob tối đa có thể chia}} = \frac{(\bar{H}{day} \times 7 / n)}{Subjob{max}}$.

Implementation và kết quả

Development Process & Key Algorithms

1. Mô hình Toán học MILP 1 & MILP 2

  • MILP 1: Sử dụng biến nhị phân $x_{it} \in {0, 1}$ (xác định job $i$ có gán vào window $t$) và biến nguyên $y_{it} \in \mathbb{N}$ (độ dài subjob). Không gian trạng thái $O(2^{nm} \cdot UB^{nm})$.
  • MILP 2: Bổ sung thêm biến vị trí bắt đầu $s_{it} \in \mathbb{N}$ và biến thứ tự thực thi $v_{ijt} \in {0, 1}$ để xác định lịch trình tuyệt đối trong từng khung giờ, triệt tiêu hoàn toàn sự chồng chéo.

$$\min C_{max}$$

$$\text{s.t.} \quad \sum_{t=1}^m y_{it} = p_i \quad \forall i=1,\dots,n$$

$$\sum_{i=1}^n (y_{it} + s_i \cdot x_{it}) \le w_t \quad \forall t=1,\dots,m$$

$$splitmin \cdot x_{it} \le y_{it} \le p_i \cdot x_{it} \quad \forall i=1,\dots,n; \forall t=1,\dots,m$$

2. Thuật toán Heuristic Assignment (ASS)

Thuật toán duyệt tuần tự các cửa sổ từ trái sang phải, thực hiện gán công việc dựa trên 3 trường hợp biên để tối ưu hóa không gian trống khả dụng:

def assignment_heuristic(jobs, s, windows, splitmin):
    """
    Thuật toán Heuristic Assignment gán subjobs vào các Time-Windows
    Dựa trên quy tắc 3 trường hợp kiểm tra splitmin và setup time
    """
    schedule = []
    n = len(jobs)
    m = len(windows)
    r_j = jobs.copy()  # Thời gian xử lý còn lại của từng job
    
    for t in range(m):
        w_start, w_end = windows[t]
        rw_t = w_end - w_start  # Dung lượng trống còn lại của window t
        
        for i in range(n):
            if r_j[i] <= 0:
                continue
            s_i = s[i]
            
            # Trường hợp 1: Nhét vừa toàn bộ công việc và thời gian setup
            if (r_j[i] + s_i) <= rw_t:
                schedule.append({'job': i, 'window': t, 'size': r_j[i], 'setup': s_i})
                rw_t -= (r_j[i] + s_i)
                r_j[i] = 0
                
            # Trường hợp 2: Cắt nhỏ subjob sao cho phần còn lại vẫn đủ splitmin
            elif (r_j[i] + s_i) >= (rw_t + splitmin) and (rw_t - s_i) >= splitmin:
                allocated_size = rw_t - s_i
                schedule.append({'job': i, 'window': t, 'size': allocated_size, 'setup': s_i})
                r_j[i] -= allocated_size
                rw_t = 0
                break  # Window hiện tại đã đầy
                
            # Trường hợp 3: Dung lượng còn lại đủ lớn để chia nhỏ an toàn
            elif r_j[i] >= 2 * splitmin and (rw_t - s_i) >= splitmin:
                allocated_size = min(rw_t - s_i, r_j[i] - splitmin)
                schedule.append({'job': i, 'window': t, 'size': allocated_size, 'setup': s_i})
                r_j[i] -= allocated_size
                rw_t -= (allocated_size + s_i)
                
    return schedule

3. Thuật toán Metaheuristic Tabu Search + Assignment (TBASS)

Để vượt qua điểm cực tiểu cục bộ (local minimum) của thuật toán tham lam ASS, giải thuật TBASS thiết lập không gian hoán vị $N \times N$, sử dụng cấu trúc danh sách cấm (Tabu List) để khóa các cặp hoán vị đã xét trong $k$ bước lặp gần nhất.

def tabu_search_assignment(jobs, s, windows, splitmin, max_iter=100, tabu_tenure=7):
    """
    Metaheuristic kết hợp Tabu Search với Heuristic Assignment
    """
    best_order = list(range(len(jobs)))
    current_order = best_order.copy()
    
    # Tính hàm mục tiêu ban đầu
    best_cmax = evaluate_cmax(current_order, jobs, s, windows, splitmin)
    tabu_list = []
    
    for iteration in range(max_iter):
        neighborhood = []
        # Sinh không gian lân cận bằng phép hoán vị Swap(i, j)
        for i in range(len(jobs)):
            for j in range(i + 1, len(jobs)):
                neighbor = current_order.copy()
                neighbor[i], neighbor[j] = neighbor[j], neighbor[i]
                move = (i, j)
                
                cmax_candidate = evaluate_cmax(neighbor, jobs, s, windows, splitmin)
                neighborhood.append((cmax_candidate, neighbor, move))
                
        # Sắp xếp các ứng viên theo Makespan tăng dần
        neighborhood.sort(key=lambda x: x[0])
        
        # Chọn bước chuyển tốt nhất không thuộc Tabu List (hoặc thỏa mãn tiêu chuẩn khát vọng - Aspiration)
        for cmax_cand, cand_order, move in neighborhood:
            if move not in tabu_list or cmax_cand < best_cmax:
                current_order = cand_order
                if cmax_cand < best_cmax:
                    best_cmax = cmax_cand
                    best_order = cand_order
                tabu_list.append(move)
                if len(tabu_list) > tabu_tenure:
                    tabu_list.pop(0)
                break
                
    return best_order, best_cmax

Testing và validation

Quá trình thực nghiệm được triển khai trên 3 bộ dữ liệu độc lập với 24 kịch bản $(n, m, splitmin)$ khác nhau:

  • DS1 (Quy mô nhỏ): $n \in {10, 12, 14, 16, 18, 20}$, $m \in [10, 25]$.
  • DS2 (Quy mô trung bình): $n \in {20, 22, 24, 26, 28, 30}$, $m \in [20, 35]$.
  • DS3 (Quy mô lớn): $n \in {30, 32, 34, 36, 38, 40}$, $m \in [30, 50]$.

Cận dưới lý thuyết ($LB$) được thiết lập chặt chẽ:

$$LB = \max \left( \max_{i} (p_i + s_i), \left\lceil \frac{\sum_{i=1}^n (p_i + s_i)}{\sum_{t=1}^m w_t} \right\rceil \right)$$

Độ lệch phần trăm so với cận dưới:

$$%LB = \frac{C_{max} - LB}{LB} \times 100%$$

Bảng kết quả thực nghiệm tổng hợp

Bộ dữ liệu Phương pháp Thời gian chạy trung bình ($t\text{ (s)}$) Độ lệch trung bình $%LB$ Tỷ lệ tìm thấy nghiệm tối ưu Tình trạng hội tụ
DS1 ($n=10-20$) MILP 1 $18.42\text{s}$ 3.12% 87.5% Hội tụ trong 100s
MILP 2 $142.60\text{s}$ 2.85% 91.6% Timeout 300s tại $n \ge 18$
Assignment (ASS) 0.012s 18.45% 12.5% Luôn hội tụ tức thì
Tabu + ASS (TBASS) 0.340s 8.20% 45.8% Luôn hội tụ
DS2 ($n=20-30$) MILP 1 $> 100\text{s}$ (Timeout) 14.80% 20.8% Bị ngắt tại ngưỡng 100s
MILP 2 $> 300\text{s}$ (Timeout) Không khả thi 0.0% Tràn bộ nhớ / Không tìm thấy nghiệm
Assignment (ASS) 0.035s 22.10% 4.1% Luôn hội tụ tức thì
Tabu + ASS (TBASS) 0.850s 11.35% 29.1% Luôn hội tụ
DS3 ($n=30-40$) MILP 1 $> 100\text{s}$ (Timeout) Không xác định 0.0% Mất tính khả thi
MILP 2 $> 300\text{s}$ (Timeout) Không xác định 0.0% Không thể giải quyết
Assignment (ASS) 0.068s 24.60% 0.0% Luôn hội tụ tức thì
Tabu + ASS (TBASS) 1.420s 12.80% 16.6% Luôn hội tụ

Đổi mới và đóng góp

Technical Innovations

  1. Chuẩn hóa công thức động xác định $splitmin$ theo ngữ cảnh tuần: Thay vì sử dụng ngưỡng chia cắt cố định tùy ý, đồ án đề xuất công thức tính $splitmin$ dựa trên số liệu khảo sát định lượng thực tế ($4.32\text{h/ngày}$ và phân phối số lượng subjob trung bình là 6.96 subjobs/task).
  2. Kỹ thuật lai ghép Metaheuristic TBASS hiệu năng cao: Bằng cách sử dụng nghiệm của giải thuật Heuristic ASS làm điểm khởi tạo (initial solution) cho Tabu Search với không gian lân cận hoán vị $N \times N$, thuật toán TBASS rút ngắn thời gian tìm kiếm đi 98.8% so với việc giải mô hình toán quy hoạch nguyên MILP 2 trên bộ dữ liệu vừa và lớn.
  3. Cải tiến chất lượng nghiệm Makespan: Thuật toán TBASS giúp giảm độ lệch $%LB$ từ 24.60% (ở giải thuật ASS thuần túy) xuống còn 12.80% trên tập dữ liệu DS3, tương đương mức cải thiện chất lượng lịch trình lên đến 47.9%.

Ứng dụng thực tế và triển khai

+-------------------------------------------------------------------------------+
| KIẾN TRÚC TRIỂN KHAI MICROSERVICES (PSP ENGINE)                               |
|                                                                               |
| [Client: Web / Mobile / Calendar UI]                                          |
|        | (HTTPS / REST API)                                                   |
|        v                                                                      |
| [API Gateway: FastAPI / Authentication / Rate Limiter]                        |
|        |                                                                      |
|        +---> [Task Preprocessor]: Chuẩn hóa Time-Unit (5-min), Tính splitmin  |
|        |                                                                      |
|        +---> [Scheduling Core Engine]:                                        |
|        |                                                                      |
|        +---> [Renderer]: Tạo Gantt Chart & Đồng bộ Google/Outlook Calendar    |
+-------------------------------------------------------------------------------+

Use Case thực tế: Quản lý công việc cá nhân cho Kỹ sư phần mềm

Một kỹ sư phần mềm có 5 công việc trong ngày ($n=5$):

  • $J_0$ (Viết báo cáo kỹ thuật): $p_0 = 20\text{ units } (100\text{ min}), s_0 = 2\text{ units } (10\text{ min})$.
  • $J_1$ (Kiểm tra và phản hồi email): $p_1 = 8\text{ units } (40\text{ min}), s_1 = 1\text{ unit } (5\text{ min})$.
  • $J_2$ (Code review cho phòng ban): $p_2 = 17\text{ units } (85\text{ min}), s_2 = 2\text{ units } (10\text{ min})$.
  • $J_3$ (Tạo backlog sprint mới): $p_3 = 6\text{ units } (30\text{ min}), s_3 = 1\text{ unit } (5\text{ min})$.
  • $J_4$ (Chuẩn bị tài liệu meeting): $p_4 = 13\text{ units } (65\text{ min}), s_4 = 1\text{ unit } (5\text{ min})$.

Hệ thống tự động phân tách $J_0$ thành 2 subjobs ($12\text{ units}$ và $4\text{ units}$) vừa vặn với các cửa sổ $W_1 [0, 7]$ và $W_2 [7, 16]$, đảm bảo mỗi lần tiếp tục công việc đều dành đúng 10 phút setup tinh thần và công cụ làm việc, giúp tối ưu hóa tổng thời gian hoàn thành $C_{max}$ sớm hơn 35 phút so với việc sắp xếp ngẫu nhiên.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  1. Độ phức tạp của MILP 2: Mô hình MILP 2 gặp hiện tượng bùng nổ tổ hợp khi $n > 20$, không thể đưa ra lời giải trong giới hạn thời gian thực hành $300\text{s}$.
  2. Tính tất định của dữ liệu: Mô hình hiện tại coi thời gian thực hiện $p_i$ là cố định, chưa xét đến các yếu tố gây nhiễu ngẫu nhiên (stochastic delays) trong thực tế.

Hướng phát triển trong tương lai

  1. Mở rộng mô hình lập lịch đa mục tiêu (Multi-objective PSP): Kết hợp đồng thời cực tiểu hóa $C_{max}$ và cực tiểu hóa độ trễ hạn chót (Total Tardiness $\sum T_i$), đồng thời tối ưu hóa mức độ hài lòng năng lượng sinh học (circadian rhythm) của từng cá nhân.
  2. Phát triển thuật toán lai tiên tiến: Nghiên cứu kết hợp Giải thuật Di truyền (Genetic Algorithm) với Tìm kiếm Tabu (Hybrid GA-Tabu) và mạng nơ-ron học tăng cường sâu (Deep Reinforcement Learning) để giải quyết bài toán lập lịch động thời gian thực.

Đối tượng hưởng lợi

  • Sinh viên & Giảng viên ngành CNTT: Tài liệu tham khảo toàn diện về cách tiếp cận từ mô hình toán học giải tích đến thuật toán xấp xỉ Heuristic/Metaheuristic cho bài toán tối ưu hóa tổ hợp.
  • Kỹ sư phát triển phần mềm (Software Engineers): Cung cấp mã nguồn sạch, cấu trúc thuật toán chuẩn xác, module hóa cao, dễ dàng tích hợp vào các ứng dụng Productivity tools (Notion, Todoist, Google Calendar).
  • Doanh nghiệp & Startup công nghệ: Cung cấp lõi thuật toán (scheduling engine) có chi phí tính toán thấp ($< 1.5\text{s}$), khả năng mở rộng phục vụ hàng triệu người dùng đồng thời mà không yêu cầu hạ tầng server đắt đỏ.
  • Nhà nghiên cứu (Researchers): Bộ dữ liệu benchmark chuẩn hóa (DS1, DS2, DS3) kèm theo phân tích cận dưới $LB$ làm cơ sở đối chuẩn cho các nghiên cứu tiếp theo về bài toán Single Machine Scheduling.

Câu hỏi thường gặp (FAQ)

1. Yêu cầu phần cứng và môi trường để triển khai hệ thống giải thuật này là gì?

Hệ thống yêu cầu môi trường Python 3.8+ (khuyến nghị Python 3.10+), cài đặt thư viện python-mip và bộ giải mã nguồn mở COIN-OR CBC Solver. Cấu hình phần cứng tối thiểu: CPU Dual-Core 2.0 GHz, RAM 2GB. Thuật toán Heuristic ASS và TBASS có thể chạy mượt mà ngay trên các thiết bị di động hoặc máy chủ biên (Edge computing).

2. Giới hạn quy mô (Scalability Limit) của giải pháp là bao nhiêu?

  • Mô hình chính xác MILP 1 & 2 chỉ nên áp dụng cho quy mô nhỏ ($n \le 14$ jobs).
  • Giải thuật Heuristic Assignment (ASS) có thể xử lý tức thì ($< 0.1\text{s}$) với $n > 10.000$ jobs.
  • Giải thuật TBASS đạt điểm cân bằng tối ưu giữa thời gian và chất lượng với quy mô $n = 30 - 100$ jobs trong thời gian dưới $2\text{s}$.

3. Làm thế nào để tích hợp thuật toán vào các hệ thống quản lý công việc hiện có (như Jira, Trello)?

Hệ thống có thể đóng gói thành một RESTful API microservice bằng FastAPI. Input nhận payload JSON chứa danh sách tasks và free calendar slots, sau đó engine thực thi thuật toán TBASS và trả về JSON chứa mốc thời gian bắt đầu, kết thúc của từng subjob để vẽ trực tiếp lên giao diện người dùng.

4. Thuật toán xử lý thế nào khi tổng thời gian công việc vượt quá các khung giờ trống trong tuần?

Mô hình toán học và mã nguồn được thiết kế bổ sung một cửa sổ thời gian cuối cùng có độ dài vô hạn $W_{\infty} = [b_m, \infty]$. Điều này đảm bảo bài toán luôn luôn tìm thấy lời giải khả thi (feasible solution) mà không bao giờ bị rơi vào trạng thái bế tắc (infeasible).

5. Chi phí triển khai và tỷ suất hoàn vốn (ROI) của giải pháp ra sao?

Do sử dụng hoàn toàn công nghệ mã nguồn mở (Python, COIN-OR CBC Solver), chi phí bản quyền phần mềm là 0 USD. Với việc tự động hóa tối ưu lịch trình giúp tiết kiệm trung bình 30–45 phút lãng phí mỗi ngày cho mỗi nhân sự, doanh nghiệp có thể đạt điểm hòa vốn và thu hồi ROI chỉ sau 2–4 tuần ứng dụng vào thực tế làm việc.

Kết luận

Khóa luận tốt nghiệp của tác giả Lục Tú Văn đã giải quyết thành công Bài toán Lập lịch Cá nhân (Personal Scheduling Problem) với đầy đủ các ràng buộc thực tiễn về thời gian chuẩn bị ($s_i$), ngưỡng chia nhỏ tối thiểu ($splitmin$) và các cửa sổ thời gian rời rạc ($W_t$). Bằng việc kết hợp hài hòa giữa các mô hình toán học giải tích chính xác (MILP 1, MILP 2) và thuật toán siêu phỏng đoán hiệu năng cao (Tabu Search + Assignment), đồ án đã chứng minh tính khả thi vượt trội trong việc tự động hóa phân bổ lịch trình làm việc tối ưu với thời gian phản hồi dưới $1.5\text{s}$ và độ lệch cận dưới chỉ từ $8.20% - 12.80%$. Đây là tiền đề kỹ thuật vững chắc để xây dựng các trợ lý AI quản lý năng suất cá nhân thế hệ mới.