1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int n, k, t;
    string tasks;
    cin >> n >> k >> t;
    cin >> tasks;

    int max_solving_time = 0;

    vector<int> home_activities(n, 0);
    int home_missed = 0;

    for (int i = 0; i < n; i++) {
        if (tasks[i] == '2') {
            home_missed++;
            home_activities[i] = 1;
        }
    }

    if (home_missed <= k) {
        vector<int> meeting_indices;
        for (int i = 0; i < n; i++) {
            if (tasks[i] == '1') {
                meeting_indices.push_back(i);
            }
        }

        sort(meeting_indices.begin(), meeting_indices.end());

        for (int i = 0; i < meeting_indices.size() && home_missed < k; i++) {
            int idx = meeting_indices[i];
            home_activities[idx] = 1;
            home_missed++;
        }

        int home_solving = 0;
        for (int i = 0; i < n; i++) {
            if (home_activities[i] == 1 || tasks[i] == '3') {
                home_solving++;
            }
        }

        max_solving_time = home_solving;
    }

    for (int go_to_office = 0; go_to_office + 2*t <= n; go_to_office++) {
        int arrive_at_office = go_to_office + t;
        for (int leave_office = arrive_at_office; leave_office + t <= n; leave_office++) {
            int arrive_at_home = leave_office + t;

            vector<int> activities(n, 0);
            int missed_meetings = 0;

            for (int hour = 0; hour < n; hour++) {
                if (hour < go_to_office) {
                    if (tasks[hour] == '2') {
                        missed_meetings++;
                        activities[hour] = 1;
                    }
                } else if (hour < arrive_at_office) {
                    if (tasks[hour] == '1' || tasks[hour] == '2') {
                        missed_meetings++;
                    }
                } else if (hour < leave_office) {
                } else if (hour < arrive_at_home) {
                    if (tasks[hour] == '1' || tasks[hour] == '2') {
                        missed_meetings++;
                    }
                } else {
                    if (tasks[hour] == '2') {
                        missed_meetings++;
                        activities[hour] = 1;
                    }
                }
            }

            vector<int> meeting_indices;
            for (int i = 0; i < n; i++) {
                if (tasks[i] == '1' &&
                    (i < go_to_office || i >= arrive_at_home) &&
                    activities[i] == 0) {
                    meeting_indices.push_back(i);
                }
            }

            for (int i = 0; i < meeting_indices.size() && missed_meetings < k; i++) {
                int idx = meeting_indices[i];
                activities[idx] = 1;
                missed_meetings++;
            }

            int solving_time = 0;
            for (int i = 0; i < n; i++) {
                if (activities[i] == 1 ||
                    (tasks[i] == '3' && (i < go_to_office || i >= arrive_at_home))) {
                    solving_time++;
                }
            }

            if (missed_meetings <= k) {
                max_solving_time = max(max_solving_time, solving_time);
            }
        }
    }

    cout << max_solving_time << endl;
    return 0;
}