Problem:

ストーブ(Stove)

  JOI 君の部屋にはストーブがある．JOI 君自身は寒さに強いのでひとりで部屋にいるときはストーブをつける必要はないが，来客があるときはストーブをつける必要がある．

  この日，JOI 君のもとにはN 人の来客がある．i 番目(1 \leq i \leq N) の来客は時刻T_i に到着し，時刻T_i + 1に退出する．同時に複数人の来客があることはない．

  JOI 君は任意の時刻にストーブをつけたり消したりできる．ただし，ストーブをつける度にマッチを1本消費する．JOI 君はマッチをK 本しか持っていないので，K 回までしかストーブをつけることができない．一日のはじめにストーブは消えている．

  ストーブをつけているとその分だけ燃料を消費するので，ストーブをつけたり消したりする時刻をうまく定めて，ストーブがついている時間の合計を最小化したい．

課題

  JOI 君の部屋への来客の情報と，JOI 君の持っているマッチの本数が与えられたとき，ストーブがついている時間の合計の最小値を求めよ．

入力

標準入力から以下の入力を読み込め．

 1 行目には，2 つの整数N, K が空白を区切りとして書かれている．これは，JOI 君の部屋にN 人の来客があり，JOI 君はK 本のマッチを持っていることを表す．

 続くN 行のうちのi 行目(1 \leq i \leq N) には，整数T_i が書かれている．これは，i 番目の来客が時刻T_iに到着し，時刻T_i + 1 に退出することを表す．

出力

  標準出力に，ストーブがついている時間の合計の最小値を1 行で出力せよ．

制限

  すべての入力データは以下の条件を満たす．

 1 \leq N \leq 100 000．

 1 \leq K \leq N．

 1 \leq T_i \leq 1 000 000 000 (1 \leq i \leq N)．

 T_i ．

		

問入出力例

入力例1

3 2
1
3
6

出力例1

4

  この入力例では，JOI 君の部屋への来客が3 人ある．以下のようにストーブをつけたり消したりすると，来客がある間はストーブがついており，ストーブをつける回数は2 回であり，ストーブがついている時間の合計は(4 - 1) + (7 - 6) = 4 である．

 1 番目の来客が到着する時刻1 にストーブをつける．

 2 番目の来客が退出する時刻4 にストーブを消す．

 3 番目の来客が到着する時刻6 にストーブをつける．

 3 番目の来客が退出する時刻7 にストーブを消す．

  ストーブをつけている時間の合計を4 未満にすることはできないので，答えとして4 を出力する．

入力例2

3 1
1
2
6

出力例2

6

  この入力例では，JOI 君は1 回しかストーブをつけることができないので，1 番目の来客が到着する時刻1 にストーブをつけ，3 番目の来客が退出する時刻7 にストーブを消せばよい．

  来客が退出する時刻と，その次の来客が到着する時刻が一致する場合があることに注意せよ．

入力例3

3 3
1
3
6

出力例3

3

  この入力例では，JOI 君は来客が到着する度にストーブをつけ，来客が退出する度にストーブを消せばよい．
  

入力例4

10 5
1
2
5
6
8
11
13
15
16
20

出力例4

12

  
  

  
  情報オリンピック日本委員会作 『第17 回日本情報オリンピック(JOI 2017/2018) 本選』



Sample input:
3 2
1
3
6


Sample output:
4

Submission status: Accepted

Solution code:
n, k = map(int, input().split())
diff = []
ti = int(input()) + 1
for _ in range(n - 1):
  ti1 = int(input())
  diff.append(ti1 - ti)
  ti = ti1 + 1

if n <= k:
  print(n)
else:
  diff.sort()
  print(n + sum(diff[:n - k]))

Submission status: Accepted

Solution code:
n, k = map(int, input().split())
t = [int(input()) for _ in range(n)]
v = [0 for _ in range(n -1)]
for i in range(n - 1):
    v[i] = t[i + 1] - t[i] - 1
v.sort(reverse = True)
print(t[-1] - t[0] + 1 - sum(v[:(k - 1)]))

Submission status: Accepted

Solution code:
from bisect import bisect
N, K, *T = map(int, open(0).read().split())

S = [(T[i+1] - T[i])-1 for i in range(N-1)]
S.sort(reverse=1)
print((T[-1] - T[0] + 1) - sum(S[:K-1]))

Submission status: Accepted

Solution code:
#!/usr/bin/python3

import os
import sys


def main():
    N, K = read_ints()
    T = [read_int() for _ in range(N)]
    print(solve(N, K, T))


def solve(N, K, T):
    diffs = [T[i + 1] - T[i] for i in range(N - 1)]
    diffs.sort()
    t = N
    for i in range(N - K):
        t += diffs[i] - 1
    return t


###############################################################################

DEBUG = 'DEBUG' in os.environ


def inp():
    return sys.stdin.readline().rstrip()


def read_int():
    return int(inp())


def read_ints():
    return [int(e) for e in inp().split()]


def dprint(*value, sep=' ', end='\n'):
    if DEBUG:
        print(*value, sep=sep, end=end)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n,k=map(int,input().split())
guest=[]
interval=[]
flag=0
for i in range(n):
    guest.append(int(input()))
    if flag==1:
        interval.append(guest[-1]-guest[-2]-1)
    flag=1
interval.sort()
ans=n
if n>k:
    for i in range(n-k):
        ans+=interval[i]
print(ans)

Submission status: Accepted

Solution code:
n, k = map(int, input().split())
li = [int(input()) for i in range(n)]
diff = []
for j in range(n-1):
    diff.append(li[j+1]-li[j]-1)
diff.sort(reverse=True)
print(n+sum(diff[k-1:]))

Submission status: Runtime Error

Solution code:
n,k = map(int,input().split())

numbers = []
times = []

for i in range(n):
  numbers.append(i)
  times.append(int(input()))

candidates = [ [0] + x for x in gen_kcombination(numbers[1:],k-1)]

bestTime = times[-1] + 1
for i in range(len(candidates)):
  candidate = candidates[i]
  time = 0
  for j in range(k-1):
    igniteTime = times[candidates[j]]
    extinguishTime = times[candidates[j+1]-1] + 1
    time += extinguishTime - igniteTime
  time += times[-1] + 1 - times[candidates[-1]]
  if bestTime >= time:
    bestTime = time
return time

def gen_kcombination(lis,k):                   
     if k >= len(lis):                          
         return [lis]                           
     kcombs = []                                
     if k == 1:                                 
         return [[x] for x in lis]              
     for i in range(len(lis) - k+1):              
         kcombs += [[lis[i]] + x for x in gen_kcombination(lis[i+1:],k-1)]                       
     return kcombs

Submission status: Runtime Error

Solution code:
def gen_kcombination(lis,k):                   
     if k >= len(lis):                          
         return [lis]                           
     kcombs = []                                
     if k == 1:                                 
         return [[x] for x in lis]              
     for i in range(len(lis) - k+1):              
         kcombs += [[lis[i]] + x for x in gen_kcombination(lis[i+1:],k-1)]                       
     return kcombs 

n,k = map(int,input().split())

numbers = []
times = []

for i in range(n):
  numbers.append(i)
  times.append(int(input()))

candidates = [ [0] + x for x in gen_kcombination(numbers[1:],k-1)]

bestTime = times[-1] + 1
for i in range(len(candidates)):
  candidate = candidates[i]
  time = 0
  for j in range(k-1):
    igniteTime = times[candidate[j]]
    extinguishTime = times[candidate[j+1]-1] + 1
    time += extinguishTime - igniteTime
  time += times[-1] + 1 - times[candidate[-1]]
  if bestTime >= time:
    bestTime = time
print(time)