Решение

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.BufferedWriter
import java.io.OutputStreamWriter
import java.lang.Math

data class Show(val startTimeSeconds: Int, val hammerTime: Int)

fun timeToSeconds(timeStr: String): Int {
    val parts = timeStr.split(':')
    val h = parts[0].toInt()
    val m = parts[1].toInt()
    val s = parts[2].toInt()
    return h * 3600 + m * 60 + s
}

fun main(args: Array<String>) {
    val reader = BufferedReader(InputStreamReader(System.`in`))
    val writer = BufferedWriter(OutputStreamWriter(System.out))

    val n = reader.readLine().toInt()
    val shows = mutableListOf<Show>()

    val workStart1Absolute = 9 * 3600
    val lunchStartAbsolute = 13 * 3600
    val workStart2Absolute = 14 * 3600
    val workEndAbsolute = 18 * 3600

    for (i in 0 until n) {
        val line = reader.readLine()
        val timeStr = line.substring(0, 8)
        var hammerTimeStr = ""
        var k = 8
        while (k < line.length && line[k] == ' ') {
            k++
        }
        if (k < line.length) {
            hammerTimeStr = line.substring(k)
        }

        val startTimeAbsolute = timeToSeconds(timeStr)
        val hammerTime = hammerTimeStr.toInt()
        val startTimeRelative = startTimeAbsolute - workStart1Absolute
        shows.add(Show(startTimeRelative, hammerTime))
    }

    val totalDuration = workEndAbsolute - workStart1Absolute

    val T_at_time = IntArray(totalDuration + 1)
    var currentShowIdx = 0
    if (shows.isEmpty() || shows[0].startTimeSeconds > 0) {
        writer.write("Ошибка: Нет шоу, начинающегося в 09:00:00\\n")
        writer.close()
        reader.close()
        return
    }

    for (t in 0..totalDuration) {
        while (currentShowIdx + 1 < shows.size && shows[currentShowIdx + 1].startTimeSeconds <= t) {
            currentShowIdx++
        }
        T_at_time[t] = shows[currentShowIdx].hammerTime
    }

    val lunchStartRelative = lunchStartAbsolute - workStart1Absolute
    val workStart2Relative = workStart2Absolute - workStart1Absolute
    val workEndRelative = workEndAbsolute - workStart1Absolute

    val dp = IntArray(totalDuration + 1) { 0 }

    for (t in 0 until totalDuration) {
        dp[t + 1] = Math.max(dp[t + 1], dp[t])

        val isMorning = (t < lunchStartRelative)
        val isAfternoon = (t >= workStart2Relative && t < workEndRelative)

        if (isMorning || isAfternoon) {
            val T = T_at_time[t]
            if (T <= 0) continue

            val t_finish = t + T

            var finish_ok = false
            if (isMorning && t_finish <= lunchStartRelative) {
                finish_ok = true
            } else if (isAfternoon && t_finish <= workEndRelative) {
                finish_ok = true
            }

            if (finish_ok) {
                dp[t_finish] = Math.max(dp[t_finish], dp[t] + 1)
            }
        }
    }

    writer.write(dp[totalDuration].toString())
    writer.newLine()

    reader.close()
    writer.close()
}