05AB1E, 22 bytes

v¯R¬yQiõˆ}2£yåiˆ}yˆ}¯g

Try it online or verify all test cases.

Explanation:

v # Loop over the integers `y` of the (implicit) input-list:
 ¯R # Push the global_array, and reverse it
 ¬ # Get the first item (without popping the reversed global_array itself)
 yQi } # If it's equal to the integer `y`:
 õˆ # Add an empty string to the global_array
 2£ # Then only leave the first 2 items of the reversed global_array
 yåi } # If the integer `y` is in these first 2 items:
 ˆ # Add the (implicit) input-list to the global_array
 yˆ # And push the integer `y` itself to the global_array
}¯g # After the loop: push the global array, and then pop and push its length
 # (which is output implicitly as result)

Brachylog, 10 bytes

It's always nice to see problem where Brachylog performs best

⊆Is₃ᶠ≠ᵐ∧Il

Explanation

⊆I # Find the minimal ordered superset of the input (and store in I) where:
 s₃ᶠ # each substring of length 3
 ≠ᵐ # has only distinct numbers
 ∧Il # and output the length of that superset

Try it online!

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.

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 70 bytes

sum(l<-rle(s<-scan())$l*3-3,1-l%/%6,((r=rle(diff(s,2)))$l+1)%/%2*!r$v)

Try it online!

After several unsuccessful attempts, the code turned rather ugly and not so short, but at least 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, by using diff(s, lag=2). The resulting vector is also chunked into consecutive runs (r) by rle function. Now, because of various interleaved alternations we need to add ceiling(r$len/2) steps for all runs of zeroes. 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%/%6 instead of simply 1.

Python 2, 67 bytes

r=[]
for x in input():
 while x in r[-2:]:r+=r,
 r+=x,
print len(r)

Try it online!

Implements the challenge pretty literally. Uses copies of the list itself as "blanks", since these can't equal any number.

Charcoal, 27 23 bytes

Ｆθ«Ｗ№✂υ±²¦¦¦ι⊞υω⊞υι»ＩＬυ

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

Ｆθ«

Loop over the jobs.

Ｗ№✂υ±²¦¦¦ι⊞υω

Add cooling off spots while the job is one of the last two in the result.

⊞υι»

Add the current job to the result.

ＩＬυ

Print the number of spots.

R, 74 68 bytes

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

Try it online!

Constructs the work array (in reverse), then takes the length. Just a bit shorter longer than Kirill L.'s answer, so sometimes, the naive approach is pretty good. EDIT: shorter again! I also borrowed Kirill's test template.

-6 bytes replacing max(0,which(y==x[2:1])) with match(y,x,0).

Perl 6, 98 bytes

$_ Z$_ Z .[1..*+1])>>.repeated.squish(:with($+^=[*] $! ne$^a ne$^b,$b==($!=$a))).sum+$_

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 (gcc), 69 bytes

f(j,l)int*j;j=l>1?(*j-*++j?j[-1]==j[l>2]?j++,l--,3:1:3)+f(j,l-1):l;

Try it online!

Straightforward recursion.

f(j,l)int*j; //Jobs, (array) Length
 j=l>1 //if l > 1, do a recursion:
 ? (*j-*++j // check if first and second elements are equal (j++)
 ? j[-1]== // 1st!=2nd; check if first and third are equal
 j[l>2] // (first and second if l==2, but we already know 1st!=2nd)
 ? j++,l--,3 // 1st==3rd (j++,l--) return 3+f(j+2,l-2)
 : 1 // 1st!=3rd (or l==2) return 1+f(j+1,l-1)
 : 3 // 1st==2nd return 3+f(j+1,l-1)
 )+f(j,l-1) // j and l were modified as needed
 : l; // nothing more needed return l

Perl 6, 48 bytes

$!=0;.map:$_=($!=$!+1 max$_)+3((%)$_);$!

Try it online!

45 bytes if the list has at least two elements:

+*.reduce:(*xx 3-(

Try it online!

Smalltalk, 125 bytes

c:=0.n:=q size.1to:n-2do:[:i|(j:=q at:i)=(k:=q at:i+1)ifTrue:[c:=c+2].j=(m:=q at:i+2)ifTrue:[c:=c+1]].k=m ifTrue:[c:=c+1].c+n

Explanation

c : accumulator of proximity penalty
q : input array.
n := q length
i : iteration index from 1 to: n-2 (arrays are 1-based in Smalltalk).
j := memory for element i, saves some few bytes when reused
k := similar to j but for i+1.
m := similar to k but for i+2.

Perl 5 -pl, 42 40 bytes

$a$_=~s/.*/$=$&if++$<$&;$+3/e}improve this answer