R, 123 bytes

`-`=nchar;x=scan(,'');while(x!=(y=gsub("([^,]+),(([^,]*,)0,1)\1(,|$)","\1,\2,\1\4",x)))x=y;-gsub("[^,]","",y)+(-y>1)

Try it online - single program!

Try it online - multiple examples!

A full program that reads a comma-separated list of integers as the input, and outputs the slots needed. I’m sure this could be golfed some more, and implementing this regex-based solution in some other languages would be more efficient in bytes.

Note on the second TIO I’ve wrapped it in a function to permit multiple examples to be shown. This function also shows the final list, but this is not output my the main program if run in isolation.

Charcoal, 27 bytes

⊞υωＦθ«Ｆ²Ｆ⁼ι§υ±⊕κ⊞υω⊞υι»Ｉ⊖Ｌυ

Try it online! Link is to verbose version of code. Explanation:

⊞υω

Push a dummy cooling off spot to the predefined empty list.

Ｆθ«

Loop over the jobs.

Ｆ²Ｆ⁼ι§υ±⊕κ⊞υω

Add cooling off spots to ensure that the job is not one of the last two in the result.

⊞υι»

Add the current job to the result.

Ｉ⊖Ｌυ

Print the number of spots adjusted for the initial extra cooling off spot.

TSQL query, 158 bytes

Input data as a table.

The query is recursive so

OPTION(MAXRECURSION 0)

is necessary, because the list of numbers can exceed 100 although it can only go handle 32,767 recursions - is the limitation really needed in this task ?

DECLARE @ table(a int, r int identity(1,1))
INSERT @ VALUES(3),(3),(4),(4);

WITH k as(SELECT null b,null c,1p
UNION ALL
SELECT iif(a in(b,c),null,a),b,p+iif(a in(b,c),0,1)FROM @,k
WHERE p=r)SELECT sum(1)-1FROM k
OPTION(MAXRECURSION 0) 

Try it online

R, 81 bytes

sum((l=rle(s<-scan())$l-1)*3,1-l%/%2,(r=rle(s==c(s[-1:-2],.1,.1)))$v*(r$l+1)%/%2)

Try it online!

After several unsuccessful attempts, the code turned rather ugly and not so short, but at least I hope it works now...

First, we evaluate the lengths of consecutive runs of the same job. E.g. for 3, 3, 4, 3 this gives:

Run Length Encoding
 lengths: int [1:3] 2 1 1
 values : num [1:3] 3 4 3

Each of these runs produces (len - 1) * 3 + 1 steps (+ 1 is handled separately).

Next, we process occurrences of the same job 2 places apart, like: x, y, x. To detect these, we compare each element of our input sequence s with a subsequence starting from the 3rd element (1-indexed) padded by impossible values (floats) to prevent R from recycling the sequence from the beginning. This produces a vector of booleans, which we also chunk into consecutive runs (r) by rle function. Now, because of various interleaved alternations we need to add ceiling(r$len/2) steps for all truthy runs. E.g.:

x y x (length 1) and x y x y (length 2) both need 1 extra step: x y _ x (y)

x y x y x (length 3) and x y x y x y (length 4) both need 2 extra steps: x y _ x y _ x (y)

Finally, we need to compensate for occurrences of these alternations in the middle of a long run of the same job: x, x, x, x..., hence 1-l%/%2 instead of simply 1.

Perl 6, 98 bytes

($!=$,

Try it online!

Blergh, there's got to be a better way of doing this. I'm not 100% sure this is fully correct, though it passes all the edge cases I could think of.

Basically, this starts by grouping all the triplets of the input list, with padding to either side. For example, [1,2,1,2] becomes (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). We get the repeated elements in each triplet, becoming (), (1), (2), ().

It then squishes consecutive elements that are not the same list, but are the same size (to not squish something like [1,1,1]), and the first element is not equal to the element before it (because we can't merge the hours in [1,1,2,2]), and finally the element before hasn't also been squished ([1,2,1,2,1,2]). So (1), (2) in the above example above would be squished together.

Finally, we get the sum of all lengths of this list, which represent our inserted hours, and add the length of the original list.

For example:

(1,1,1) => (Any,1,1),(1,1,1),(1,1,Nil) => (1),(1,1),(1) => (no squishes) => 4+3 = 7
(1,2,1,2,1,2) => (Any,1,2), (1,2,1), (2,1,2), (1,2,1), (2,1,2), (1,2,Nil) => (),(1),(2),(1),(2),() => squish (1),(2) and (1),(2) => 2+6 = 8

JavaScript (ES6), 57 bytes

f=([x,...a],p,q)=>1/x?1+f(x!=p&x!=q?a:[x,...a,x=f],x,p):0

Try it online!

Commented

f = ( // f is a recursive function taking:
 [x, // x = next job
 ...a], // a[] = array of remaining jobs
 p, // p = previous job, initially undefined
 q // q = penultimate job, initially undefined
) => //
 1 / x ? // if x is defined and numeric:
 1 + // add 1 to the grand total
 f( // and do a recursive call to f:
 x != p & // if x is different from the previous job
 x != q ? // and different from the penultimate job:
 a // just pass the remaining jobs
 : // else:
 [ x, // pass x, which can't be assigned yet
 ...a, // pass the remaining jobs
 x = f // set x to a non-numeric value
 ], //
 x, // previous job = x
 p // penultimate job = previous job
 ) // end of recursive call
 : // else:
 0 // stop recursion

C# (Visual C# Interactive Compiler), 75 62 bytes

n=>n.Select((a,b)=>b<1?1:n[b-1]==a?3:b>1&&n[b-2]==a?2:1).Sum()

Very simple, maps each element to 3 if the element behind it is the same as itself, 2 if the element 2 spaces behind it is the same as itself, and 1 otherwise, then sums it all up.

Try it online!

Batch, 184 bytes

@echo off
@set l=-
@set p=-
@set n=0
@for %%j in (%*)do @call:c %%j
@exit/b%n%
:c
@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1
@set p=%l%&set l=%1&set/an+=1

Input is via command-line arguments and output is via exit code. Explanation:

@set l=-
@set p=-

Track the last two jobs.

@set n=0

Initialise the count.

@for %%j in (%*)do @call:c %%j

Process each job.

@exit/b%n%

Output the final count.

:c

For each job:

@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1

If we processed the job recently, add in an appropriate number of cooling off spots. Additionally, clear the last job so that the next job only triggers cooling off if it's the same as this job.

@set p=%l%&set l=%1&set/an+=1

Update the last two jobs and allocate a spot to this job.

Python 3, 79 bytes

f=lambda a,b=[]:a and(a[0]in b[:2]and f(a,['']+b)or f(a[1:],[a[0]]+b))or len(b)

Try it online!

Swift, 114 bytes

func t(a:[Int])
var s=1
for i in 1...a.count-1s = a[i-1]==a[i] ? s+3:i>1&&a[i-2]==a[i] ? s+2:s+1
print("(s)")

Try it online!

Jelly, 14 bytes

ṫ-i⁹⁶ẋ⁸;;µƒ⁶L’

Try it online!

R, 74 bytes

length(Reduce(function(x,y)c(y,rep("",max(0,which(y==x[2:1]))),x),scan()))

Try it online!

Constructs the work array (in reverse), then takes the length. Just a bit shorter than Kirill L.'s answer, so sometimes, the naive approach really works.

Before posting, one of my earlier revisions was similar but much longer, which I include just because.

R, 86 bytes

length(Reduce(function(x,y)c(y,rep("",min(2,1:2%*%(y==x[1:2]))),x),scan(),c("","")))-2

Try it online!

The major difference is using which() to avoid having to set init=c("","") in Reduce to avoid results of NA in the x[2:1] when the array is empty.