from collections import deque

from heapq import heapify,heappop,heappush,heappushpop

from copy import copy,deepcopy

from itertools import product,permutations,combinations,combinations_with_replacement

from collections import defaultdict,Counter

from bisect import bisect_left,bisect_right

from math import gcd,ceil,floor,factorial

# from fractions import gcd

from functools import reduce

from pprint import pprint

from statistics import mean,median,mode



INF = float("inf")



def mycol(data,col):

    return [ row[col] for row in data ]



def mysort(data,col,reverse_flag):

    data.sort(key=lambda x:x[col],reverse=reverse_flag)

    return data



def mymax(data):

    M = -1*float("inf")

    for i in range(len(data)):

        m = max(data[i])

        M = max(M,m)

    return M



def mymin(data):

    m = float("inf")

    for i in range(len(data)):

        M = min(data[i])

        m = min(m,M)

    return m



def mycount(ls,x):

    # lsはソート済みであること

    l = bisect_left(ls,x)

    r = bisect_right(ls,x)

    return (r-l)



def myoutput(ls,space=True):

    if space:

        if len(ls)==0:

            print(" ")

        elif type(ls[0])==str:

            print((" ".join(ls)))

        elif type(ls[0])==int:

            print((" ".join(map(str,ls))))

        else:

            print("Output Error")

    else:

        if len(ls)==0:

            print("")

        elif type(ls[0])==str:

            print(("".join(ls)))

        elif type(ls[0])==int:

            print(("".join(map(str,ls))))

        else:

            print("Output Error")



def I():

    return int(eval(input()))



def MI():

    return list(map(int,input().split()))



def RI():

    return list(map(int,input().split()))



def CI(n):

    return [ int(eval(input())) for _ in range(n) ]



def LI(n):

    return [ list(map(int,input().split())) for _ in range(n) ]



def S():

    return eval(input())



def MS():

    return input().split()



def RS():

    return list(eval(input()))



def CS(n):

    return [ eval(input()) for _ in range(n) ]



def LS(n):

    return [ list(eval(input())) for _ in range(n) ]



# ddict = defaultdict(lambda: 0)

# ddict = defaultdict(lambda: 1)

# ddict = defaultdict(lambda: int())

# ddict = defaultdict(lambda: list())

# ddict = defaultdict(lambda: float())



n,k = MI()

a = RI()



ind = a.index(1)

ans = INF



if ind>(k-1) and ind<(n-k):

    for i in range(ind-k+1,ind+k):

        # print('i={}'.format(i))

        m = 0

        m += ceil(i/(k-1))

        m += ceil((n-i-1)/(k-1))

        ans = min(ans,m)

        # print('ans={}'.format(ans))

elif ind<=(k-1):

    ans = 0

    ans += ceil((n-k)/(k-1)) + 1

else:

    ans = 0

    ans += ceil((n-k)/(k-1)) + 1



print(ans)
from collections import deque

from heapq import heapify,heappop,heappush,heappushpop

from copy import copy,deepcopy

from itertools import product,permutations,combinations,combinations_with_replacement

from collections import defaultdict,Counter

from bisect import bisect_left,bisect_right

from math import gcd,ceil,floor,factorial

# from fractions import gcd

from functools import reduce

from pprint import pprint

from statistics import mean,median,mode



INF = float("inf")



def mycol(data,col):

    return [ row[col] for row in data ]



def mysort(data,col,reverse_flag):

    data.sort(key=lambda x:x[col],reverse=reverse_flag)

    return data



def mymax(data):

    M = -1*float("inf")

    for i in range(len(data)):

        m = max(data[i])

        M = max(M,m)

    return M



def mymin(data):

    m = float("inf")

    for i in range(len(data)):

        M = min(data[i])

        m = min(m,M)

    return m



def mycount(ls,x):

    # lsはソート済みであること

    l = bisect_left(ls,x)

    r = bisect_right(ls,x)

    return (r-l)



def myoutput(ls,space=True):

    if space:

        if len(ls)==0:

            print(" ")

        elif type(ls[0])==str:

            print((" ".join(ls)))

        elif type(ls[0])==int:

            print((" ".join(map(str,ls))))

        else:

            print("Output Error")

    else:

        if len(ls)==0:

            print("")

        elif type(ls[0])==str:

            print(("".join(ls)))

        elif type(ls[0])==int:

            print(("".join(map(str,ls))))

        else:

            print("Output Error")



def I():

    return int(eval(input()))



def MI():

    return list(map(int,input().split()))



def RI():

    return list(map(int,input().split()))



def CI(n):

    return [ int(eval(input())) for _ in range(n) ]



def LI(n):

    return [ list(map(int,input().split())) for _ in range(n) ]



def S():

    return eval(input())



def MS():

    return input().split()



def RS():

    return list(eval(input()))



def CS(n):

    return [ eval(input()) for _ in range(n) ]



def LS(n):

    return [ list(eval(input())) for _ in range(n) ]



# ddict = defaultdict(lambda: 0)

# ddict = defaultdict(lambda: 1)

# ddict = defaultdict(lambda: int())

# ddict = defaultdict(lambda: list())

# ddict = defaultdict(lambda: float())



n,k = MI()

a = RI()



# ind = a.index(1)

ans = ceil((n-k)/(k-1)) + 1

print(ans)
from collections import deque
from heapq import heapify, heappop, heappush, heappushpop
from copy import copy, deepcopy
from itertools import product, permutations, combinations, combinations_with_replacement
from collections import defaultdict, Counter
from bisect import bisect_left, bisect_right
from math import gcd, ceil, floor, factorial

# from fractions import gcd
from functools import reduce
from pprint import pprint
from statistics import mean, median, mode

INF = float("inf")


def mycol(data, col):
    return [row[col] for row in data]


def mysort(data, col, reverse_flag):
    data.sort(key=lambda x: x[col], reverse=reverse_flag)
    return data


def mymax(data):
    M = -1 * float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M, m)
    return M


def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m, M)
    return m


def mycount(ls, x):
    # lsはソート済みであること
    l = bisect_left(ls, x)
    r = bisect_right(ls, x)
    return r - l


def myoutput(ls, space=True):
    if space:
        if len(ls) == 0:
            print(" ")
        elif type(ls[0]) == str:
            print((" ".join(ls)))
        elif type(ls[0]) == int:
            print((" ".join(map(str, ls))))
        else:
            print("Output Error")
    else:
        if len(ls) == 0:
            print("")
        elif type(ls[0]) == str:
            print(("".join(ls)))
        elif type(ls[0]) == int:
            print(("".join(map(str, ls))))
        else:
            print("Output Error")


def I():
    return int(eval(input()))


def MI():
    return list(map(int, input().split()))


def RI():
    return list(map(int, input().split()))


def CI(n):
    return [int(eval(input())) for _ in range(n)]


def LI(n):
    return [list(map(int, input().split())) for _ in range(n)]


def S():
    return eval(input())


def MS():
    return input().split()


def RS():
    return list(eval(input()))


def CS(n):
    return [eval(input()) for _ in range(n)]


def LS(n):
    return [list(eval(input())) for _ in range(n)]


# ddict = defaultdict(lambda: 0)
# ddict = defaultdict(lambda: 1)
# ddict = defaultdict(lambda: int())
# ddict = defaultdict(lambda: list())
# ddict = defaultdict(lambda: float())
n, k = MI()
a = RI()
ind = a.index(1)
ans = INF
if ind > (k - 1) and ind < (n - k):
    for i in range(ind - k + 1, ind + k):
        # print('i={}'.format(i))
        m = 0
        m += ceil(i / (k - 1))
        m += ceil((n - i - 1) / (k - 1))
        ans = min(ans, m)
        # print('ans={}'.format(ans))
elif ind <= (k - 1):
    ans = 0
    ans += ceil((n - k) / (k - 1)) + 1
else:
    ans = 0
    ans += ceil((n - k) / (k - 1)) + 1
print(ans)

from collections import deque
from heapq import heapify, heappop, heappush, heappushpop
from copy import copy, deepcopy
from itertools import product, permutations, combinations, combinations_with_replacement
from collections import defaultdict, Counter
from bisect import bisect_left, bisect_right
from math import gcd, ceil, floor, factorial

# from fractions import gcd
from functools import reduce
from pprint import pprint
from statistics import mean, median, mode

INF = float("inf")


def mycol(data, col):
    return [row[col] for row in data]


def mysort(data, col, reverse_flag):
    data.sort(key=lambda x: x[col], reverse=reverse_flag)
    return data


def mymax(data):
    M = -1 * float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M, m)
    return M


def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m, M)
    return m


def mycount(ls, x):
    # lsはソート済みであること
    l = bisect_left(ls, x)
    r = bisect_right(ls, x)
    return r - l


def myoutput(ls, space=True):
    if space:
        if len(ls) == 0:
            print(" ")
        elif type(ls[0]) == str:
            print((" ".join(ls)))
        elif type(ls[0]) == int:
            print((" ".join(map(str, ls))))
        else:
            print("Output Error")
    else:
        if len(ls) == 0:
            print("")
        elif type(ls[0]) == str:
            print(("".join(ls)))
        elif type(ls[0]) == int:
            print(("".join(map(str, ls))))
        else:
            print("Output Error")


def I():
    return int(eval(input()))


def MI():
    return list(map(int, input().split()))


def RI():
    return list(map(int, input().split()))


def CI(n):
    return [int(eval(input())) for _ in range(n)]


def LI(n):
    return [list(map(int, input().split())) for _ in range(n)]


def S():
    return eval(input())


def MS():
    return input().split()


def RS():
    return list(eval(input()))


def CS(n):
    return [eval(input()) for _ in range(n)]


def LS(n):
    return [list(eval(input())) for _ in range(n)]


# ddict = defaultdict(lambda: 0)
# ddict = defaultdict(lambda: 1)
# ddict = defaultdict(lambda: int())
# ddict = defaultdict(lambda: list())
# ddict = defaultdict(lambda: float())
n, k = MI()
a = RI()
# ind = a.index(1)
ans = ceil((n - k) / (k - 1)) + 1
print(ans)

-ind = a.index(1) -ans = INF -if ind > (k - 1) and ind < (n - k): -    for i in range(ind - k + 1, ind + k): -        # print('i={}'.format(i)) -        m = 0 -        m += ceil(i / (k - 1)) -        m += ceil((n - i - 1) / (k - 1)) -        ans = min(ans, m) -        # print('ans={}'.format(ans)) -elif ind <= (k - 1): -    ans = 0 -    ans += ceil((n - k) / (k - 1)) + 1 -else: -    ans = 0 -    ans += ceil((n - k) / (k - 1)) + 1 +# ind = a.index(1) +ans = ceil((n - k) / (k - 1)) + 1