Assembly Line Scheduling | DP-34

Try it on GfG Practice

Assembly line scheduling is a manufacturing problem. In automobile industries assembly lines are used to transfer parts from one station to another station.

- Manufacturing of large items like car, trucks etc. generally undergoes through multiple stations, where each station is responsible for assembling particular part only. Entire product be ready after it goes through predefined n stations in sequence. 

- Manufacturing of car may be done through several stages like engine fitting, coloring, light fitting, fixing of controlling system, gates, seats and many other things.

-The particular task is carried out at the station dedicated to that task only. Based on the requirement there may be more than one assembly line.

-In case of two assembly lines if the load at station j at assembly 1 is very high, then components are transfer to station of assembly line 2 the converse is also true. This technique helps to speed ups the manufacturing process.

 -The time to transfer partial product from one station to next station on the same assembly line is negligible. During rush factory may transfer partially completed auto from one assembly line to another, complete the manufacturing as quickly as possible.

Assembly line scheduling is a problem in operations management that involves determining the optimal sequence of tasks or operations on an assembly line to minimize production costs or maximize efficiency. This problem can be solved using various data structures and algorithms. One common approach is dynamic programming, which involves breaking the problem down into smaller sub-problems and solving them recursively.

The following is an overview of the steps involved in solving an assembly line scheduling problem using dynamic programming:

• Define the problem: The first step is to define the problem, including the number of tasks or operations involved, the time required to perform each task on each assembly line, and the cost or efficiency associated with each task.
• Define the sub-problems: Next, we need to define the sub-problems by breaking down the problem into smaller pieces. In assembly line scheduling, this involves determining the optimal sequence of tasks for each station along the assembly line.
• Define the recurrence relation: The recurrence relation defines the relationship between the sub-problems and the overall problem. In assembly line scheduling, the recurrence relation involves computing the minimum cost or maximum efficiency of the assembly line by considering the cost or efficiency of the previous station and the time required to transition to the next station.
• Solve the sub-problems: To solve the sub-problems, we can use a table or matrix to store the minimum cost or maximum efficiency of each station. We can then use this table to determine the optimal sequence of tasks for the entire assembly line.
• Trace the optimal path: Finally, we can trace the optimal path through the table or matrix to determine the sequence of tasks that minimizes production costs or maximizes efficiency.

A car factory has two assembly lines, each with n stations. A station is denoted by S_i,j where i is either 1 or 2 and indicates the assembly line the station is on, and j indicates the number of the station. The time taken per station is denoted by a_i,j. Each station is dedicated to some sort of work like engine fitting, body fitting, painting, and so on. So, a car chassis must pass through each of the n stations in order before exiting the factory. The parallel stations of the two assembly lines perform the same task. After it passes through station S_i,j, it will continue to station S_i,j+1 unless it decides to transfer to the other line. Continuing on the same line incurs no extra cost, but transferring from line i at station j - 1 to station j on the other line takes time t_i,j. Each assembly line takes an entry time e_i and exit time x_i which may be different for the two lines. Give an algorithm for computing the minimum time it will take to build a car chassis.

The below figure presents the problem in a clear picture: 
 

The following information can be extracted from the problem statement to make it simpler: 

• Two assembly lines, 1 and 2, each with stations from 1 to n.
• A car chassis must pass through all stations from 1 to n in order(in any of the two assembly lines). i.e. it cannot jump from station i to station j if they are not at one move distance.
• The car chassis can move one station forward in the same line, or one station diagonally in the other line. It incurs an extra cost ti, j to move to station j from line i. No cost is incurred for movement in same line.
• The time taken in station j on line i is a_{i, j}.
• S_{i, j} represents a station j on line i.

Breaking the problem into smaller sub-problems: 
We can easily find the ith factorial if (i-1)th factorial is known. Can we apply the similar funda here? 
If the minimum time taken by the chassis to leave station S_{i, j-1} is known, the minimum time taken to leave station S_{i, j} can be calculated quickly by combining a_{i, j} and t_{i, j}.
T1(j) indicates the minimum time taken by the car chassis to leave station j on assembly line 1.
T2(j) indicates the minimum time taken by the car chassis to leave station j on assembly line 2.

Base cases: 
The entry time e_i comes into picture only when the car chassis enters the car factory.
Time taken to leave the first station in line 1 is given by: 
T1(1) = Entry time in Line 1 + Time spent in station S_1,1 
T1(1) = e₁ + a_1,1 
Similarly, time taken to leave the first station in line 2 is given by: 
T2(1) = e₂ + a_2,1

Recursive Relations: 
If we look at the problem statement, it quickly boils down to the below observations: 
The car chassis at station S_1,j can come either from station S_{1, j-1} or station S_{2, j-1}.

Case #1: Its previous station is S_{1, j-1} 
The minimum time to leave station S_1,j is given by: 
T1(j) = Minimum time taken to leave station S_{1, j-1} + Time spent in station S_{1, j} 
T1(j) = T1(j-1) + a_{1, j}

Case #2: Its previous station is S_{2, j-1} 
The minimum time to leave station S1, j is given by: 
T1(j) = Minimum time taken to leave station S_{2, j-1} + Extra cost incurred to change the assembly line + Time spent in station S_{1, j} 
T1(j) = T2(j-1) + t_{2, j} + a_{1, j}

The minimum time T1(j) is given by the minimum of the two obtained in cases #1 and #2. 
T1(j) = min((T1(j-1) + a_{1, j}), (T2(j-1) + t_{2, j} + a_{1, j})) 

Similarly, the minimum time to reach station S2, j is given by: 
T2(j) = min((T2(j-1) + a_{2, j}), (T1(j-1) + t_{1, j} + a_{2, j}))

The total minimum time taken by the car chassis to come out of the factory is given by: 
Tmin = min(Time taken to leave station S_i,n + Time taken to exit the car factory) 
Tmin = min(T1(n) + x₁, T2(n) + x₂)

Assembly line Scheduling Using  Recursion:

#include <iostream>
#include <vector>
using namespace std;

int fun(vector<vector<int> > a, vector<vector<int> > t,
        int cl, int cs, int x1, int x2, int n)
{
    // base case
    if (cs == n - 1) {
        if (cl == 0) { // exiting from (current) line =0
            return x1;
        }
        else // exiting from line 2
            return x2;
    }
    // continue on same line
    int same
        = fun(a, t, cl, cs + 1, x1, x2, n) + a[cl][cs + 1];
    // continue on different line
    int diff = fun(a, t, !cl, cs + 1, x1, x2, n)
               + a[!cl][cs + 1] + t[cl][cs + 1];

    return min(same, diff);
}
int main()
{
    int n = 4; // number of statin
    vector<vector<int> > a
        = { { 4, 5, 3, 2 }, { 2, 10, 1, 4 } };
    vector<vector<int> > t
        = { { 0, 7, 4, 5 }, { 0, 9, 2, 8 } };

    int e1 = 10;
    int e2 = 12;
    int x1 = 18;
    int x2 = 7;
    // entry from 1st line
    int x = fun(a, t, 0, 0, x1, x2, n) + e1 + a[0][0];
    // entry from 2nd line
    int y = fun(a, t, 1, 0, x1, x2, n) + e2 + a[1][0];
    cout << min(x, y) << endl;
}

def fun(a, t, cl, cs, x1, x2, n):
    # base case
    if cs == n - 1:
        if cl == 0:  # exiting from (current) line =0
            return x1
        else:  # exiting from line 2
            return x2
    # continue on same line
    same = fun(a, t, cl, cs + 1, x1, x2, n) + a[cl][cs + 1]
    # continue on different line
    diff = fun(a, t, not cl, cs + 1, x1, x2, n) + a[not cl][cs + 1] + t[cl][cs + 1]
    return min(same, diff)


n = 4  # number of stations
a = [[4, 5, 3, 2], [2, 10, 1, 4]]  # time taken at each station
t = [[0, 7, 4, 5], [0, 9, 2, 8]]  # time taken to switch lines
e1 = 10  # time taken to enter first line
e2 = 12  # time taken to enter second line
x1 = 18  # time taken to exit first line
x2 = 7  # time taken to exit second line

# entry from 1st line
x = fun(a, t, 0, 0, x1, x2, n) + e1 + a[0][0]
# entry from 2nd line
y = fun(a, t, 1, 0, x1, x2, n) + e2 + a[1][0]

print(min(x, y))

import java.util.*;

public class AssemblyLineScheduling {

    // Recursive function to calculate minimum time required
    // to exit from the factory
    public static int fun(ArrayList<ArrayList<Integer> > a,
                          ArrayList<ArrayList<Integer> > t,
                          int cl, int cs, int x1, int x2,
                          int n)
    {

        // base case
        if (cs == n - 1) {
            if (cl == 0) { // exiting from (current) line =0
                return x1;
            }
            else { // exiting from line 2
                return x2;
            }
        }

        // continue on same line
        int same = fun(a, t, cl, cs + 1, x1, x2, n)
                   + a.get(cl).get(cs + 1);

        // continue on different line
        int diff
            = fun(a, t, cl == 0 ? 1 : 0, cs + 1, x1, x2, n)
              + a.get(cl == 0 ? 1 : 0).get(cs + 1)
              + t.get(cl).get(cs + 1);

        return Math.min(same, diff);
    }

    // Main function
    public static void main(String[] args)
    {

        int n = 4; // number of stations

        // Create and initialize ArrayList of ArrayLists for
        // a and t
        ArrayList<ArrayList<Integer> > a
            = new ArrayList<>();
        ArrayList<ArrayList<Integer> > t
            = new ArrayList<>();

        // Add elements to ArrayList of ArrayLists a and t
        a.add(new ArrayList<Integer>(
            Arrays.asList(4, 5, 3, 2)));
        a.add(new ArrayList<Integer>(
            Arrays.asList(2, 10, 1, 4)));

        t.add(new ArrayList<Integer>(
            Arrays.asList(0, 7, 4, 5)));
        t.add(new ArrayList<Integer>(
            Arrays.asList(0, 9, 2, 8)));

        int e1 = 10;
        int e2 = 12;
        int x1 = 18;
        int x2 = 7;

        // Entry from 1st line
        int x = fun(a, t, 0, 0, x1, x2, n) + e1
                + a.get(0).get(0);

        // Entry from 2nd line
        int y = fun(a, t, 1, 0, x1, x2, n) + e2
                + a.get(1).get(0);

        // Print minimum time required to exit from the
        // factory
        System.out.println(Math.min(x, y));
    }
}

// Function to calculate minimum time required
// to exit from the factory
function fun(a, t, cl, cs, x1, x2, n) {

// base case
if (cs == n - 1) {
if (cl == 0) { // exiting from (current) line =0
return x1;
}
else { // exiting from line 2
return x2;
}
}

// continue on same line
let same = fun(a, t, cl, cs + 1, x1, x2, n)
+ a[cl][cs + 1];

// continue on different line
let diff = fun(a, t, cl == 0 ? 1 : 0, cs + 1, x1, x2, n)
+ a[cl == 0 ? 1 : 0][cs + 1]
+ t[cl][cs + 1];

return Math.min(same, diff);
}

// Main function
function main() {

const n = 4; // number of stations

// Create and initialize arrays of arrays for a and t
const a = [
[4, 5, 3, 2],
[2, 10, 1, 4]
];
const t = [
[0, 7, 4, 5],
[0, 9, 2, 8]
];

const e1 = 10;
const e2 = 12;
const x1 = 18;
const x2 = 7;

// Entry from 1st line
const x = fun(a, t, 0, 0, x1, x2, n) + e1 + a[0][0];

// Entry from 2nd line
const y = fun(a, t, 1, 0, x1, x2, n) + e2 + a[1][0];

// Print minimum time required to exit from the factory
console.log(Math.min(x, y));
}

// Call main function
main();

//C# equivalent of the above Java code
using System;
using System.Collections.Generic;

public class AssemblyLineScheduling
{
    // Recursive function to calculate minimum time required
    // to exit from the factory
    public static int fun(List<List<int>> a,
        List<List<int>> t,
        int cl, int cs, int x1, int x2,
        int n)
    {
        // base case
        if (cs == n - 1)
        {
            if (cl == 0) // exiting from (current) line =0
            {
                return x1;
            }
            else // exiting from line 2
            {
                return x2;
            }
        }

        // continue on same line
        int same = fun(a, t, cl, cs + 1, x1, x2, n) 
            + a[cl][cs + 1];

        // continue on different line
        int diff = fun(a, t, cl == 0 ? 1 : 0, cs + 1, x1, x2, n)
            + a[cl == 0 ? 1 : 0][cs + 1]
            + t[cl][cs + 1];

        return Math.Min(same, diff);
    }

    // Main function
    public static void Main(string[] args)
    {
        int n = 4; // number of stations

        // Create and initialize List of Lists for
        // a and t
        List<List<int>> a = new List<List<int>>();
        List<List<int>> t = new List<List<int>>();

        // Add elements to List of Lists a and t
        a.Add(new List<int>(new int[] { 4, 5, 3, 2 }));
        a.Add(new List<int>(new int[] { 2, 10, 1, 4 }));

        t.Add(new List<int>(new int[] { 0, 7, 4, 5 }));
        t.Add(new List<int>(new int[] { 0, 9, 2, 8 }));

        int e1 = 10;
        int e2 = 12;
        int x1 = 18;
        int x2 = 7;

        // Entry from 1st line
        int x = fun(a, t, 0, 0, x1, x2, n) + e1
            + a[0][0];

        // Entry from 2nd line
        int y = fun(a, t, 1, 0, x1, x2, n) + e2
            + a[1][0];

        // Print minimum time required to exit from the
        // factory
        Console.WriteLine(Math.Min(x, y));
    }
}

35

Time Complexity: O(2^n) where n = number of stations
Auxiliary Space: O(n) as the recursion depth of the function is proportional to n, so the space required by the function call stack is also O(n)

Why dynamic programming? 
The above recursion exhibits overlapping sub-problems. There are two ways to reach station S_{1, j}: 

1. From station S_{1, j-1}
2. From station S_{2, j-1}

So, to find the minimum time to leave station S_{1, j} the minimum time to leave the previous two stations must be calculated(as explained in above recursion).

Similarly, there are two ways to reach station S_{2, j}: 

1. From station S_{2, j-1}
2. From station S_{1, j-1}

Please note that the minimum times to leave stations S_{1, j-1} and S_{2, j-1} have already been calculated.
So, we need two tables to store the partial results calculated for each station in an assembly line. The table will be filled in a bottom-up fashion.

Note: 
In this post, the word “leave” has been used in place of “reach” to avoid confusion. Since the car chassis must spend a fixed time in each station, the word leave suits better.

Implementation: 

// A C++ program to find minimum possible 
// time by the car chassis to complete 
#include <bits/stdc++.h>
using namespace std;
#define NUM_LINE 2 
#define NUM_STATION 4 

// Utility function to find a minimum of two numbers 
int min(int a, int b)
{ 
    return a < b ? a : b; 
} 

int carAssembly(int a[][NUM_STATION], 
                int t[][NUM_STATION], 
                int *e, int *x) 
{ 
    int T1[NUM_STATION], T2[NUM_STATION], i; 

    // time taken to leave first station in line 1 
    T1[0] = e[0] + a[0][0]; 
    
    // time taken to leave first station in line 2 
    T2[0] = e[1] + a[1][0]; 

    // Fill tables T1[] and T2[] using the 
    // above given recursive relations 
    for (i = 1; i < NUM_STATION; ++i) 
    { 
        T1[i] = min(T1[i - 1] + a[0][i], 
                    T2[i - 1] + t[1][i] + a[0][i]); 
        T2[i] = min(T2[i - 1] + a[1][i],
                    T1[i - 1] + t[0][i] + a[1][i]); 
    } 

    // Consider exit times and return minimum 
    return min(T1[NUM_STATION - 1] + x[0], 
               T2[NUM_STATION - 1] + x[1]); 
} 

// Driver Code
int main() 
{ 
    int a[][NUM_STATION] = {{4, 5, 3, 2}, 
                            {2, 10, 1, 4}}; 
    int t[][NUM_STATION] = {{0, 7, 4, 5}, 
                            {0, 9, 2, 8}}; 
    int e[] = {10, 12}, x[] = {18, 7}; 

    cout << carAssembly(a, t, e, x); 

    return 0; 
} 

// This is code is contributed by rathbhupendra

// A C program to find minimum possible time by the car chassis to complete
#include <stdio.h>
#define NUM_LINE 2
#define NUM_STATION 4

// Utility function to find minimum of two numbers
int min(int a, int b) { return a < b ? a : b; }

int carAssembly(int a[][NUM_STATION], int t[][NUM_STATION], int *e, int *x)
{
    int T1[NUM_STATION], T2[NUM_STATION], i;

    T1[0] = e[0] + a[0][0]; // time taken to leave first station in line 1
    T2[0] = e[1] + a[1][0]; // time taken to leave first station in line 2

    // Fill tables T1[] and T2[] using the above given recursive relations
    for (i = 1; i < NUM_STATION; ++i)
    {
        T1[i] = min(T1[i-1] + a[0][i], T2[i-1] + t[1][i] + a[0][i]);
        T2[i] = min(T2[i-1] + a[1][i], T1[i-1] + t[0][i] + a[1][i]);
    }

    // Consider exit times and return minimum
    return min(T1[NUM_STATION-1] + x[0], T2[NUM_STATION-1] + x[1]);
}

int main()
{
    int a[][NUM_STATION] = {{4, 5, 3, 2},
                {2, 10, 1, 4}};
    int t[][NUM_STATION] = {{0, 7, 4, 5},
                {0, 9, 2, 8}};
    int e[] = {10, 12}, x[] = {18, 7};

    printf("%d", carAssembly(a, t, e, x));

    return 0;
}

// A java program to find minimum possible
// time by the car chassis to complete
import java.io.*;

class GFG 
{
    static int NUM_LINE = 2;
    static int NUM_STATION = 4;
    
    // Utility function to find minimum of two numbers
    static int min(int a, int b) 
    { 
        return a < b ? a : b; 
        
    }
    
    static int carAssembly(int a[][], int t[][], int e[], int x[])
    {
        int T1[]= new int [NUM_STATION];
        int T2[] =new int[NUM_STATION] ;
        int i;
    
        // time taken to leave first station in line 1
        T1[0] = e[0] + a[0][0]; 
        
        // time taken to leave first station in line 2
        T2[0] = e[1] + a[1][0];
    
        // Fill tables T1[] and T2[] using 
        // the above given recursive relations
        for (i = 1; i < NUM_STATION; ++i)
        {
            T1[i] = min(T1[i - 1] + a[0][i], 
                    T2[i - 1] + t[1][i] + a[0][i]);
            T2[i] = min(T2[i - 1] + a[1][i], 
                    T1[i - 1] + t[0][i] + a[1][i]);
        }
    
        // Consider exit times and return minimum
        return min(T1[NUM_STATION-1] + x[0], 
                    T2[NUM_STATION-1] + x[1]);
    }
    
    
    // Driver code
    public static void main (String[] args) 
    {
        int a[][] = {{4, 5, 3, 2},
                    {2, 10, 1, 4}};
        int t[][] = {{0, 7, 4, 5},
                    {0, 9, 2, 8}};
        int e[] = {10, 12}, x[] = {18, 7};
    
        System.out.println(carAssembly(a, t, e, x));    
    
    }
}
// This code is contributed by vt_m

# Python program to find minimum possible 
# time by the car chassis to complete

def carAssembly (a, t, e, x):
    
    NUM_STATION = len(a[0])
    T1 = [0 for i in range(NUM_STATION)]
    T2 = [0 for i in range(NUM_STATION)]
    
    T1[0] = e[0] + a[0][0] # time taken to leave
                           # first station in line 1
    T2[0] = e[1] + a[1][0] # time taken to leave
                           # first station in line 2

    # Fill tables T1[] and T2[] using
    # above given recursive relations
    for i in range(1, NUM_STATION):
        T1[i] = min(T1[i-1] + a[0][i],
                    T2[i-1] + t[1][i] + a[0][i])
        T2[i] = min(T2[i-1] + a[1][i],
                    T1[i-1] + t[0][i] + a[1][i] )

    # consider exit times and return minimum
    return min(T1[NUM_STATION - 1] + x[0],
               T2[NUM_STATION - 1] + x[1])

a = [[4, 5, 3, 2],
     [2, 10, 1, 4]]
t = [[0, 7, 4, 5],
     [0, 9, 2, 8]]
e = [10, 12]
x = [18, 7]

print(carAssembly(a, t, e, x))

# This code is contributed by Soumen Ghosh

// A C# program to find minimum possible
// time by the car chassis to complete
using System;

class GFG {
    
    static int NUM_STATION = 4;
    
    // Utility function to find minimum 
    // of two numbers
    static int min(int a, int b) 
    { 
        return a < b ? a : b; 
        
    }
    
    static int carAssembly(int [,]a, int [,]t,
                             int []e, int []x)
    {
        int []T1= new int [NUM_STATION];
        int []T2 =new int[NUM_STATION] ;
        int i;
    
        // time taken to leave first station
        // in line 1
        T1[0] = e[0] + a[0,0]; 
        
        // time taken to leave first station
        // in line 2
        T2[0] = e[1] + a[1,0];
    
        // Fill tables T1[] and T2[] using 
        // the above given recursive relations
        for (i = 1; i < NUM_STATION; ++i)
        {
            T1[i] = min(T1[i - 1] + a[0,i], 
                  T2[i - 1] + t[1,i] + a[0,i]);
            T2[i] = min(T2[i - 1] + a[1,i], 
                  T1[i - 1] + t[0,i] + a[1,i]);
        }
    
        // Consider exit times and return
        // minimum
        return min(T1[NUM_STATION-1] + x[0], 
                    T2[NUM_STATION-1] + x[1]);
    }
    
    // Driver code
    public static void Main () 
    {
        int [,]a = { {4, 5, 3, 2},
                     {2, 10, 1, 4} };
                     
        int [,]t = { {0, 7, 4, 5},
                     {0, 9, 2, 8} };
                     
        int []e = {10, 12};
        int []x = {18, 7};
    
        Console.Write(carAssembly(a, t, e, x)); 
    
    }
}

// This code is contributed by nitin mittal.

<?php
// A PHP program to find minimum
// possible time by the car chassis
// to complete

$NUM_LINE = 2;
$NUM_STATION = 4;

// Utility function to find 
// minimum of two numbers
function carAssembly($a, $t, 
                     $e, $x)
{
    global $NUM_LINE,
           $NUM_STATION;
    $T1 = array(); 
    $T2 = array();
    $i;

    $T1[0] = $e[0] + $a[0][0]; // time taken to leave 
                               // first station in line 1
    $T2[0] = $e[1] + $a[1][0]; // time taken to leave 
                               // first station in line 2

    // Fill tables T1[] and T2[] 
    // using the above given
    // recursive relations
    for ($i = 1; 
         $i < $NUM_STATION; ++$i)
    {
        $T1[$i] = min($T1[$i - 1] + $a[0][$i], 
                      $T2[$i - 1] + $t[1][$i] + 
                                    $a[0][$i]);
        $T2[$i] = min($T2[$i - 1] + $a[1][$i], 
                      $T1[$i - 1] + $t[0][$i] + 
                                    $a[1][$i]);
    }

    // Consider exit times 
    // and return minimum
    return min($T1[$NUM_STATION - 1] + $x[0], 
               $T2[$NUM_STATION - 1] + $x[1]);
}

// Driver Code
$a = array(array(4, 5, 3, 2),
           array(2, 10, 1, 4));
$t = array(array(0, 7, 4, 5),
           array(0, 9, 2, 8));
$e = array(10, 12);
$x = array(18, 7);

echo carAssembly($a, $t, $e, $x);

// This code is contributed
// by anuj_67.
?>

<script>

// A JavaScript program to find minimum possible
// time by the car chassis to complete

const NUM_LINE = 2;
const NUM_STATION = 4;

// Utility function to find a minimum of two numbers
function min(a, b)
{
    return a < b ? a : b;
}

function carAssembly(a, t, e, x)
{
    let T1 = new Array(NUM_STATION); 
    let T2 = new Array(NUM_STATION);
    let i;

    // time taken to leave first station in line 1
    T1[0] = e[0] + a[0][0];
    
    // time taken to leave first station in line 2
    T2[0] = e[1] + a[1][0];

    // Fill tables T1[] and T2[] using the
    // above given recursive relations
    for (i = 1; i < NUM_STATION; ++i)
    {
        T1[i] = min(T1[i - 1] + a[0][i],
                    T2[i - 1] + t[1][i] + a[0][i]);
        T2[i] = min(T2[i - 1] + a[1][i],
                    T1[i - 1] + t[0][i] + a[1][i]);
    }

    // Consider exit times and return minimum
    return min(T1[NUM_STATION - 1] + x[0],
            T2[NUM_STATION - 1] + x[1]);
}

// Driver Code
    let a = [[4, 5, 3, 2],
                            [2, 10, 1, 4]];
    let t = [[0, 7, 4, 5],
                            [0, 9, 2, 8]];
    let e = [10, 12], x = [18, 7];

    document.write(carAssembly(a, t, e, x));


// This code is contributed by Surbhi Tyagi.

</script>

Time Complexity: O(NUM_STATION), where NUM_STATION = number of stations
Auxiliary Space: O(1)

The bold line shows the path covered by the car chassis for given input values. We need only the last two values in the auxiliary arrays. So instead of creating two arrays, we can use two variables.

// A space optimized solution for
// assembly line scheduling 
#include <bits/stdc++.h> 
using namespace std; 

int carAssembly(int a[][4], 
                int t[][4], 
                int *e, int *x) 
{ 
    int first, second, i;

    // Time taken to leave first 
    // station in line 1 
    first = e[0] + a[0][0]; 
    
    // Time taken to leave first 
    // station in line 2 
    second = e[1] + a[1][0]; 

    // Fill tables T1[] and T2[] using the 
    // above given recursive relations 
    for(i = 1; i < 4; ++i) 
    { 
        int up =  min(first + a[0][i], 
                     second + t[1][i] + 
                              a[0][i]); 
        int down = min(second + a[1][i], 
                        first + t[0][i] + 
                                a[1][i]); 
        first = up;
        second = down;
    } 

    // Consider exit times and 
    // return minimum 
    return min(first + x[0], 
              second + x[1]); 
} 

// Driver Code 
int main() 
{ 
    int a[][4] = { { 4, 5, 3, 2 }, 
                   { 2, 10, 1, 4 } }; 
    int t[][4] = { { 0, 7, 4, 5 }, 
                   { 0, 9, 2, 8 } }; 
    int e[] = { 10, 12 }, x[] = { 18, 7 }; 

    cout << carAssembly(a, t, e, x); 

    return 0; 
} 

// This code is contributed by chitrasingla2001

// A space optimized solution for assembly line scheduling
public class AssemblyLine {
    public static void main(String[] args) {
        int a[][] = {{4, 5, 3, 2},
                {2, 10, 1, 4}};
        int t[][] = {{0, 7, 4, 5},
                {0, 9, 2, 8}};
        int e[] = {10, 12}, x[] = {18, 7};
 
        System.out.println(carAssembleTime(a, t, e, x));
    }
 
    public static int carAssembleTime(int a[][], int t[][], 
                                       int e[], int x[]) {
        int n = a[0].length;
        
        // time taken to leave first station in line 1  
        int first = e[0] + a[0][0];

        // time taken to leave first station in line 2
        int second = e[1] + a[1][0];
         
        for (int i = 1; i < n; i++) {
            int up = Math.min(first + a[0][i],
                    second + t[1][i] + a[0][i]),
                    down = Math.min(second + a[1][i],
                            first + t[0][i] + a[1][i]);
            first = up;
            second = down;
        }
 
        first += x[0];
        second += x[1];
 
        return Math.min(first, second);
    }
}

# A space optimized solution for assembly
# line scheduling in Python3
def carAssembleTime(a, t, e, x):
    
    n = len(a[0])

    # Time taken to leave first station
    # in line 1
    first = e[0] + a[0][0]

    # Time taken to leave first station 
    # in line 2
    second = e[1] + a[1][0]

    for i in range(1, n):
        up = min(first + a[0][i], 
                 second + t[1][i] + a[0][i])
        down = min(second + a[1][i], 
                   first + t[0][i] + a[1][i]) 
            
        first, second = up, down 

    first += x[0] 
    second += x[1] 

    return min(first, second)

# Driver Code
a = [ [ 4, 5, 3, 2 ], [ 2, 10, 1, 4 ] ] 
t = [ [ 0, 7, 4, 5 ], [ 0, 9, 2, 8 ] ]
e = [ 10, 12 ] 
x = [ 18, 7 ] 
    
print(carAssembleTime(a, t, e, x))

# This code is contributed by Prateek Gupta 

// A space optimized solution for 
// assembly line scheduling
using System;

class GFG{
    
static int carAssembleTime(int[,] a, int[,] t, 
                           int[] e, int[] x)
{
    int n = a.GetLength(1);
    
    // Time taken to leave first station in line 1  
    int first = e[0] + a[0, 0];

    // Time taken to leave first station in line 2
    int second = e[1] + a[1, 0];
      
    for(int i = 1; i < n; i++)
    {
        int up = Math.Min(first + a[0, i],
               second + t[1, i] + a[0, i]),
            down = Math.Min(second + a[1, i],
                   first + t[0, i] + a[1, i]);
      
        first = up;
        second = down;
    }

    first += x[0];
    second += x[1];

    return Math.Min(first, second);
}

// Driver Code
static void Main() 
{
    int[,] a = { { 4, 5, 3, 2 },
                 { 2, 10, 1, 4 } };
    int[,] t = { { 0, 7, 4, 5 },
                 { 0, 9, 2, 8 } };
    int[] e = { 10, 12 }, x = { 18, 7 };
    
    Console.WriteLine(carAssembleTime(a, t, e, x));
}
}

// This code is contributed by divyeshrabadiya07

<script>
// A space optimized solution for assembly line scheduling

    function carAssembleTime(a , t , e , x) {
        var n = a[0].length;

        // time taken to leave first station in line 1
        var first = e[0] + a[0][0];

        // time taken to leave first station in line 2
        var second = e[1] + a[1][0];

        for (var i = 1; i < n; i++) {
            var up = Math.min(first + a[0][i], second + t[1][i] + a[0][i]),
                    down = Math.min(second + a[1][i], first + t[0][i] + a[1][i]);
            first = up;
            second = down;
        }

        first += x[0];
        second += x[1];

        return Math.min(first, second);
        }
       var a = [ [ 4, 5, 3, 2 ], [ 2, 10, 1, 4 ] ];
        var t = [ [ 0, 7, 4, 5 ], [ 0, 9, 2, 8 ] ];
        var e = [ 10, 12 ], x = [ 18, 7 ];

        document.write(carAssembleTime(a, t, e, x));
    
// This code is contributed by gauravrajput1
</script>

35

Time Complexity: O(n), where n = number of stations
Auxiliary Space: O(1)

Exercise: 
Extend the above algorithm to print the path covered by the car chassis in the factory.

References: 
Introduction to Algorithms 3rd Edition by Clifford Stein, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest
This article is compiled by Aashish Barnwal.