R,  44  43 42 bytes

function(A,D)sum(pmax(0,diff(A)),D*.12)/10

Try it online!

-1 byte by using pmax as multiple other answers do

Takes inputs as Ascent and Distance, and returns the time in minutes.

function(A,D) # take Ascent and Distance
 diff(A) # take successive differences of ascents
 pmax(0, ) # get the positive elements of those
 D*.12 # multiply distance by 0.12
 sum( , ) # take the sum of all elements
 /10 # and divide by 10, returning the result

JavaScript (ES6), 50 bytes

Saved 1 byte thanks to Giuseppe's answer (dividing by 10 at the end of the process)

Takes input as ([altitudes])(distance). Returns the time in minutes.

a=>d=>a.map(p=n=>d-=(x=p-(p=n))<0&&x,d*=.12)&&d/10

Try it online!

05AB1E, 15 bytes

¥ʒ0›}OT÷s₄;6//+

Try it online!

Returns time in minutes.

Explanation

 + # sum of ...
¥ʒ0›}OT÷ # the sum of positive deltas of the altitude divided by 10
 s₄;6// # the distance divided by 83.33333333 (500/6, or the amount of meters per minute) 

Haskell, 47 46 bytes

d#l@(_:t)=d/5e3+sum(max 0<$>zipWith(-)t l)/600

Returns the time in hours.

Try it online!

Python 2, 62 60 bytes

Saved 2 bytes thanks to ovs.

lambda e,d:sum((a-b)*(a>b)for a,b in zip(e[1:],e))*.1+d*.012

Try it online!

Returns time in minutes.

# add all increasing slope differences together
sum(
 # multiply the difference by 0 if a<b, else by 1
 (a-b)*(a>b)
 # create a list of pairs by index, like [(1,0), (2,1) ...(n, n-1)]
 # then interate thru the pairs where a is the higher indexed item and b is the lower indexed item
 for a,b in zip(e[1:],e)
 )
 # * 60 minutes / 600 meters == .1 min/m
 *.1 
 # 60 minutes / 5000 meters = .012 min/m
 +d*.012

Perl 6, 45 39 bytes

6 bytes saved thanks to Jo King.

$^l*.012+.1*sum (@^a[1..*]Z-@a)Xmax 0

Try it online!

The first argument is the list with elevations, the second argument is the length of the trek.

Let's start from the middle: @^a[1..*]Z-@a takes the first argument (saying @^a, we essentially mean: This is the first argument, and I will be referring to it with @a from now on. (All the variables with ^ correspond to the arguments in the alphabetical order.)), removes the first element and subtracts the same unmodified list element-by-element from it (stopping when the shorter list runs out). That forms a list of differences. Then we do a "cross product" with a zero using the operator max, which returns the list of results of the operator max used on all possible pairs of one element from the list on the left and one on the right. But, since there is only one element on the right, it just acts as a shorthand for using * max 0 on each element of the list. We then sum the results, divide by 10 and add the length $^l$ multiplied by .012, which gives the result in minutes.

Jelly, 12 bytes

×.12;I}»0÷⁵S

Try it online!

-1 thanks to Mr. Xcoder.

oK, 22 bytes

1_-':x..1.012*

Try it online! Abusing a parsing bug where .1.012 is the same as .1 .012.

 .1.012* /a = [0.1 * input[0], 0.012 * input[1]]
 . /function(x=a[0], y=a[1])
 1_-':x / a = subtract pairs of elements from x
 0| / a = max(a, 0) w/ implicit map
 y++/ / y + sum(a)

k, 23 bytes

.1*(.12*y)++/0

Try it online!

Pyth, 15 bytes

c+*E.12s>#0.+QT

Full program, expects the set of heights as the first argument, distance as the second. Returns the time in minutes.

Try it online here, or verify all test cases at once here.

c+*E.12s>#0.+QT Implicit: Q=input 1, E=input 2
 .+Q Take the differences between each height point
 >#0 Filter to remove negative values
 s Take the sum
 *E.12 Multiply the distance by 0.12
 + Add the two previous results
c T Divide the above by 10, implicit print

APL (Dyalog Unicode), 21 20 18 bytes

.1×.12⊥⎕,-+/0⌊2-/⎕

Try it online!

Traditional function taking input (from right to left) as 1st ⎕=Heights/Depths, 2nd ⎕=Distance.

Thanks to @ngn for being a wizard one three bytes.

How it works:

.1×.12⊥⎕,-+/0⌊2-/⎕ ⍝ Function;
 ⎕ ⍝ Append 0 to the heights vector;
 2-/ ⍝ Pairwise (2) differences (-/);
 0⌊ ⍝ Minimum between 0 and the vector's elements;
 +/ ⍝ Sum (yields the negated total height);
 - ⍝ Subtract from;
 .12⊥⎕, ⍝ Distance × 0.12;
.1× ⍝ And divide by 10;

Python 2, 59 bytes

lambda a,d:d/5e3+sum(max(0,y-x)/6e2for x,y in zip(a,a[1:]))

Try it online!

returns hours as a decimal.

Java 8, 89 bytes

a->n->int s=0,p=0,i=a.length;for(;i-->0;p=a[i])s+=(p=p-a[i])>0?p:0;return s/10+n/500*6;

Try it online.

Explanation:

a->n-> // Method with integer-array and integer parameter and integer return-type
 int s=0, // Sum-integers, starting at 0
 p=0, // Previous integer, starting at 0
 i=a.length;for(;i-->0; // Loop `i` backwards over the array
 ; // After every iteration:
 p=a[i]) // Set `p` to the current value for the next iteration
 s+=(p=p-a[i])>0? // If the previous minus current item is larger than 0:
 p // Add that difference to the sum `s`
 : // Else:
 0; // Leave the sum the same
 return s/10 // Return the sum integer-divided by 10
 +n/500*6; // Plus the second input divided by 500 and then multiplied by 6

Japt, 39 bytes

0oUl)x@W=UgXÄ -UgX)g ¥É?0:W/#ɘ} +V/(#Ǵ0

Try it online!

Likely can be golfed quite a bit more.