Merge arrays with optimisation

I have an optimisation problem.

I have multiple arrays, with id-s.

Example:

productArray1 = '{64, 56, 33, 12, 10}'
productArray2 = '{64, 33, 12, 99}'
productArray3 = '{64, 56, 99}'
productArray4 = '{56, 64, 99}'

To understand: Each array id is representing a processId of a manufactured product.
So basically an array is representing the manufacturing process scheme of a product, because of that, the order of id-s is not changeable.
I want to make a function that synchronise those, using 'pauses' (null),
The example resolution is this:

productArraySync1 = '{null, 64, 56, 33, 12, null, 10}'
productArraySync2 = '{null, 64, null, 33, 12, 99, null}'
productArraySync3 = '{null, 64, 56, null, null, 99, null}'
productArraySync4 = '{56, 64, null, null, null, 99, null}'

I painted the columns in this picture so you can see what I want to achieve.
In a column in productArraySync I need to get to minimise the null values, but I need to respect the original order.

For an example 64(green) means a drilling process. And as mentioned, each array represent an order of processes of a manufactured product.
In the 4. array there is an another method (56(yellow) centering process)
before this 64. so it has to be done before 64, so you have to add 1.,2.,3. arrays to a null in the first column, so in the 2. column you get the minimal null values.
This means the 2. column is effective because in a 'workstation' you can process as many product in one setup as possible.

I don't need code, I don't need a solution, this is far more complicated, I can understand.
I need some ideas how to approach this problem, at this point I have no idea.

my current approach is to calculate all possible combinations, and then select the
best, but this is not good becasue its exponential, and can not work with larger arrays

So finally I coded this method in C# with your help. It's working perfectly, but I run some test later

public static void Main()
{
var sequences = new int[][]
{
new[] {64, 56, 33, 12, 10},
new[] {64, 33, 12, 99},
new[] {64, 56, 99},
new[] {56, 64, 99}
};
ShortestCommonSuperDP(sequences, out var sCsSequenceArray);
foreach (var result in sCsSequenceArray.Select(arr => arr.Select(x => x == null ? "null" : $"{x}").ToArray()))
{
Console.WriteLine(string.Join("\t", result));
}
Console.ReadLine();
}
private static int[] ShortestCommonSuperDP(IReadOnlyList<int[]> sequenceArray, out List<int?[]> sCsSequenceArray)
{
var resultSequence = sequenceArray[0];
for (var i = 0; i < sequenceArray.Count - 1; i++)
{
var nextSequence = sequenceArray[i + 1];
var result = ShortestCommonSuperDP(resultSequence, nextSequence, out _, out _);
resultSequence = result;
}
sCsSequenceArray = new List<int?[]>();
foreach (var sequence in sequenceArray)
{
ShortestCommonSuperDP(resultSequence, sequence, out _, out var resultArr2);
sCsSequenceArray.Add(resultArr2);
}
return resultSequence.Select(x => x).ToArray();
}
private static int[] ShortestCommonSuperDP(IReadOnlyList<int> sequence1, IReadOnlyList<int> sequence2, out int?[] sequenceScs1, out int?[] sequenceScs2)
{
var dynamicTable = new int[sequence1.Count + 1, sequence2.Count + 1];
for (var i = 0; i <= sequence1.Count; i++)
{
for (var j = 0; j <= sequence2.Count; j++)
if (i == 0)
dynamicTable[i, j] = j;
else if (j == 0)
dynamicTable[i, j] = i;
else if (sequence1[i - 1] == sequence2[j - 1])
dynamicTable[i, j] = dynamicTable[i - 1, j - 1] + 1;
else
dynamicTable[i, j] = 1 + Math.Min(dynamicTable[i - 1, j], dynamicTable[i, j - 1]);
}
var scsLength = dynamicTable[sequence1.Count, sequence2.Count];
var commonScs = new int[scsLength];
int x = sequence1.Count, y = sequence2.Count;
sequenceScs1 = new int?[scsLength];
sequenceScs2 = new int?[scsLength];
while (x > 0 && y > 0)
if (sequence1[x - 1] == sequence2[y - 1])
{
commonScs[--scsLength] = sequence1[x - 1];
x--;
y--;
sequenceScs1[scsLength] = commonScs[scsLength];
sequenceScs2[scsLength] = commonScs[scsLength];
}
else if (dynamicTable[x, y - 1] < dynamicTable[x - 1, y])
{
commonScs[--scsLength] = sequence2[y - 1];
sequenceScs1[scsLength] = null;
sequenceScs2[scsLength] = commonScs[scsLength];
y--;
}
else
{
commonScs[--scsLength] = sequence1[x - 1];
sequenceScs1[scsLength] = commonScs[scsLength];
sequenceScs2[scsLength] = null;
x--;
}
while (x > 0)
{
commonScs[--scsLength] = sequence1[x - 1];
x--;
}
while (y > 0)
{
commonScs[--scsLength] = sequence2[y - 1];
y--;
}
return commonScs;
}