output_description: Print the minimum number of operations required.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      A_1 A_2 ... A_N
attempt: # -*- coding: utf-8 -*-
  import sys
  import math
  import os
  import itertools
  import string
  import heapq
  import _collections
  from collections import Counter
  from collections import defaultdict
  from functools import lru_cache
  import bisect
  
  
  class Scanner:
      @staticmethod
      def int():
          return int(sys.stdin.readline().rstrip())
  
      @staticmethod
      def string():
          return sys.stdin.readline().rstrip()
  
      @staticmethod
      def map_int():
          return [int(x) for x in Scanner.string().split()]
  
      @staticmethod
      def string_list(n):
          return [input() for i in range(n)]
  
      @staticmethod
      def int_list_list(n):
          return [Scanner.map_int() for i in range(n)]
  
      @staticmethod
      def int_cols_list(n):
          return [int(input()) for i in range(n)]
  
  
  class Math:
      @staticmethod
      def gcd(a, b):
          if b == 0:
              return a
          return Math.gcd(b, a % b)
  
      @staticmethod
      def lcm(a, b):
          return (a * b) // Math.gcd(a, b)
  
      @staticmethod
      def roundUp(a, b):
          return -(-a // b)
  
      @staticmethod
      def toUpperMultiple(a, x):
          return Math.roundUp(a, x) * x
  
      @staticmethod
      def toLowerMultiple(a, x):
          return (a // x) * x
  
      @staticmethod
      def nearPow2(n):
          if n <= 0:
              return 0
          if n & (n - 1) == 0:
              return n
          ret = 1
          while n > 0:
              ret <<= 1
              n >>= 1
          return ret
  
      @staticmethod
      def isPrime(n):
          if n < 2:
              return False
          if n == 2:
              return True
          if n % 2 == 0:
              return False
          d = int(n**0.5) + 1
          for i in range(3, d + 1, 2):
              if n % i == 0:
                  return False
          return True
  
  
  MOD = int(1e09) + 7
  
  
  def main():
      # sys.stdin = open("sample.txt")
      N, K = Scanner.map_int()
      A = Scanner.map_int()
      print(Math.roundUp(N - 1, (K - 1)))
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence
  is a permutation of 1, 2, ..., N.
  
  On this sequence, Snuke can perform the following operation:
  
    * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen elements.
  
  Snuke would like to make all the elements in this sequence equal by repeating
  the operation above some number of times. Find the minimum number of
  operations required. It can be proved that, Under the constraints of this
  problem, this objective is always achievable.
samples: [{"input": "4 3\n    2 3 1 4", "output": "2\n    \n\nOne optimal strategy is as follows:\n\n  * In the first operation, choose the first, second and third elements. The sequence A becomes 1, 1, 1, 4.\n\n  * In the second operation, choose the second, third and fourth elements. The sequence A becomes 1, 1, 1, 1.\n\n* * *"}, {"input": "3 3\n    1 2 3", "output": "1\n    \n\n* * *"}, {"input": "8 3\n    7 3 1 8 4 6 2 5", "output": "4"}]