introduction:

"Today, industries face a critical challenge: optimizing project execution for

maximum efficiency. In particular, this study focuses on a priority-based
assignment problem within industrial projects comprising a series of tasks. These
projects unfold in two stages: an initial set of primary jobs (m in total) and
subsequent secondary jobs ((n - m) in total) that rely on the completion of the
primary ones.

Each project involves n jobs, and there are precisely n manufacturing units
available, capable of handling all project tasks. The objective? To assign these
jobs to the manufacturing units in a manner that minimizes the overall project
completion time across the two stages.

To tackle this, a novel polynomial time iterative algorithm is proposed. At each

iteration, the algorithm selects m manufacturing units for the primary jobs while
optimizing the assignment of the remaining units to the secondary tasks. This
iterative process aims to decrease Stage-I time while increasing Stage-II time.
Ultimately, the goal is to identify the pair of Stage-I and Stage-II times that
yield the minimum total duration, signifying the optimal assignment.

The study includes a numerical illustration supporting the proposed theory, along
with implementation and testing of the algorithm across various test problems. By
calculating the average run time for each problem, the effectiveness of the
algorithm in minimizing project duration is assessed."

Certainly! Here's a simplified version for your presentation:

---

**Slide: Mathematical Formulation**

**Stage-I Problem:**
- **Objective:** Minimize time for completing primary jobs (J1).
- **Formulation:** \(T_1(X) = \min_{X\in S} \max_{I\times J1} (t_{ij}(x_{ij}))\)
- **Constraints:** Allocation (\(x_{ij}\)) limited to 1 per unit, each primary job
done once (\(x_{ij} = 1\)), binary values for task allocation.

**Stage-II Problem:**
- **Objective:** Optimal completion for remaining jobs (J\J1) after Stage-I.
- **Formulation:** \(T_2(Y) = \min_{Y\in S(X)} \max_{\overline{I1}\times\
overline{J1}} (t_{ij}(y_{ij}))\)
- **Constraints:** Allocation (\(y_{ij}\)) similar to Stage-I, involving the
leftover units and jobs.

**Priority Based Assignment Problem (PBAP):**

- **Overall Objective:** Minimize total completion time for both primary and
secondary jobs.
- **Formulation:** \(\min_{X\in S} \left[\max_{I1\times J1} (t_{ij}(x_{ij})) + \
min_{Y\in S(X)} \{ \max_{\overline{I1}\times \overline{J1}} (t_{ij}(y_{ij})) \}\
right]\)

---
This concise overview highlights the objectives, formulations, and constraints for
both Stage-I and Stage-II problems, culminating in the overall Priority Based
Assignment Problem (PBAP).

**Algorithm for PBAP:**

1. **Initial Step:**
- Find an Optimal Basic Feasible Solution (OBFS) for (CP).
- Obtain corresponding Stage-I (T0_1) and Stage-II (T0_2) times.

2. **General Step (Iterative):**

- For k ≥ 1 at given Stage-I (Tk−1_1) and Stage-II (Tk−1_2) times:
- Solve (CPk) based on the previous iteration.
- Construct pairs (Tk_1, Tk_2) from the OBFS of (CPk).

3. **Terminal Step:**
- Stop if the OBFS of (CPk) is not M-feasible.
- Optimal value of PBAP: min{Th_1 + Th_2} for h = {0, 1..., k−1}.

**Algorithm Complexity Analysis:**

- Reoptimization Property of CMAP:
- Optimal solution renewal for a single arc change: O(n2 + n log n) time.
- Time Complexity Calculation:
- Overall complexity: O(mn(n2 + n log n) + n3), where O(n3) is the initial CP
solution time.

*Table 1: PBAP*
(W1 W2 W3 W4 W5 W6)
P1 82 28 96 80 68 71
P2 91 55 49 96 76 04
P3 13 96 81 66 75 28
P4 92 97 15 04 40 05
P5 64 16 43 85 66 10
P6 10 98 92 94 18 83

*Table 2: CP*
(W1 W2 W3 W4 W5 W6)
P1 λ21 0 0 λ19 0 0
P2 λ24 0 0 λ27 0 0
P3 λ4 0 0 λ14 0 0
P4 λ25 0 0 λ1 0 0
P5 λ13 0 0 λ23 0 0
P6 λ3 0 0 λ26 0 0

**Example 1:**

- Consider a 6x6 PBAP with job execution times shown in Table 1.

- Assigned specific times to job pairs as per t-values.
- Used Bh sets and corresponding weights λs−h+1 for CP.
- Iterations tracked Stage-I and Stage-II times and solutions.
- Recorded pairs: (75, 10), (66, 10), (43, 13), (28, 66), (18, 80).
- Determined the optimal pair: (43, 13) with an assignment schedule.

**Example 2:**

- Presented a 6x6 two-stage time minimizing assignment problem (Table 3).

- Defined time route partition and Bh sets with respective weights.
- Tracked iterations' Stage-I and Stage-II times and solutions.
- Recorded pairs: (80, 26), (62, 71), (59, 76), (53, 76), (49, 80), (43, 93).
- Concluded the optimal value of the objective function: 106 from the first
recorded pairs.

**Remark:**

- Highlighted algorithm efficiency, generating fewer pairs (6) than an existing

approach (10), yet finding the optimal solution.

**Algorithm Verification:**

- Implemented the algorithm in MATLAB on a 64-bit OS.

- Verified it across various test problems.
- Created a testbed with ten instance classes ranging from n = 10 to n = 100.
- Each class includes instances of size n with different values of m.
- Instances were randomly generated, utilizing tij values from a uniform
distribution between 1 and mn.
- Employed the Hungarian algorithm as a CMAP solver.

**Computational Behavior (Table 5):**

- Showcased average running times (seconds) taken over approximately 100 instances
for each class.
- Displayed in Fig. 1, the runtime variations based on the percentage of primary
and secondary jobs.
- Noticed maximum runtime peaks around 50% of primary or secondary jobs (40 in some
cases).
- The algorithm performed better when the percentage was below 40 or above 60 due
to variations in time entries between primary and secondary job sets.
- The peak around 50% suggests longer execution times as time variations in both
primary and secondary sets were maximal, unlike other cases.

**Concluding Remarks:**

1. Introduced a polynomial time iterative algorithm for the priority-based

assignment problem, generating Stage-I and Stage-II time pairs. The algorithm halts
upon reaching the minimum Stage-I time or encountering a non-M-feasible solution
for (CPk).

2. The algorithm concludes in a finite number of steps, with a maximum of (s - r +

1) iterations if T01 = tr, where r ∈ {1, 2, ..., s}.

3. Each iteration involves solving a TMAP via a corresponding CMAP, both solvable
by polynomial-bound algorithms, limiting the total problems to a finite number.
4. In the worst case, the algorithm solves at most m∗n problems, where m∗ is the
count of distinct time entries for primary jobs.

5. The time complexity of the algorithm is O(mn(n^2 + n log n) + n^3).

6. Advantages over Sonia and Puri's algorithm:

- Generates pairs with fewer problems solved.
- Produces a single sequence where Stage-I time decreases and Stage-II time
increases.
- Solves fewer problems (at most (s - r + 1) compared to 4(2 + n(n - 1)).

7. Limitation: Cannot solve problems when the one agent-one job condition is
relaxed.

8. Handling agent-job incapability: Unavailable agent-job links can be blocked

using a very large time value, allowing problem resolution with the current method.

9. Further exploration: Extend the problem to accommodate more than two types of
jobs prioritized differently.

10. Future exploration: Seek techniques that strictly decrease the sum T1 + T2 at
each iteration, improving upon the current algorithm's behavior.