#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;

char in_expr[100001];
char cleaned_expr[100001];
bool deletions[51];

// bestdeletes[i][j] - best deletion of j N's from i-th segment
vector<vector<int>> bestdeletes;
int cleaned_n;

long long compute_naviasity();

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    k-=1;
    scanf("%s", in_expr);

    // EXPRESSION CLEANUP
    // B - break, N - ()
    int balance = 0;
    int cleaned_i = 0;
    int total_n = 0;
    char last_thing = 'X';
    for (int i = 0; i < n; ++i) {
        if (in_expr[i] == '(') {
            balance += 1;
            // printf("Inserting (\n");
            cleaned_expr[cleaned_i] = '(';
            last_thing = '(';
        } else {
            balance -= 1;
            if (last_thing == '(') {
                // replace '(' with 'N'
                cleaned_i--;
                // printf("Replacing ( with N\n");
                cleaned_expr[cleaned_i] = 'N';
                last_thing = 'N';
                total_n++;
            } else if (balance < 0) {
                if (last_thing == 'B') {
                    // just merge it into the barrier
                    cleaned_i--;
                } else {
                    // create a barrier
                    // printf("Inserting B\n");
                    cleaned_expr[cleaned_i] = 'B';
                    last_thing = 'B';
                }
                balance = 0;
            } else {
                // a )) sequence
                // printf("Inserting )\n");
                cleaned_expr[cleaned_i] = ')';
                last_thing = ')';
            }
        }
        cleaned_i++;
    }
    cleaned_n = cleaned_i;

    // now go right to left and remove excess '('
    // excess ')' are already removed
    cleaned_i--;
    balance = 0;
    for (; cleaned_i >= 0; --cleaned_i) {
        if (cleaned_expr[cleaned_i] == ')') {
            balance += 1;
        } else if (cleaned_expr[cleaned_i] == '(') {
            balance -= 1;
            if (balance < 0) {
                cleaned_expr[cleaned_i] = 'B';
                balance = 0;
            }
        }
    }

    if (total_n <= k) {
        printf("0\n");
        return 0;
    }

//    int aridx = 0;
//    int segment_start = 0;
//    int segment_end = 0;
//
//    while(true) {
//        if (segment_start >= cleaned_n) {
//            break;
//        }
//        vector<int> newsegment;
//
//        int n_in_segment = 0;
//
//        while (cleaned_expr[segment_end] != 'B') {
//            if (cleaned_expr[segment_end] == 'N') {
//                n_in_segment += 1;
//            }
//            segment_end++;
//        }
//        if (n_in_segment == 0) {
//            // BB or array end
//            segment_end++;
//            segment_start = segment_end;
//            continue;
//        }
//
//        // calculate k-removals
//        for (int krems = 1; krems < n_in_segment && krems <= k; ++krems) {
//            // remval is the best reduction of naviasity when using krems breaks
//            int remval = 0;
//
//            // TODO: jak to zrobić lepiej niż wykładniczo
//
//            newsegment.push_back(remval);
//        }
//        newsegment.push_back()
//
//        bestdeletes.push_back(newsegment);
//    }

//    for (int i = 0; i < cleaned_n; ++i) {
//        printf("%c", cleaned_expr[i]);
//    }
//    printf("\n");

    long long expnum = 1;
    for (int i = 0; i < total_n; ++i) {
        expnum *= 2;
    }

    long long max_naviasity = compute_naviasity();
    long long min_naviasity = max_naviasity;

    for (long long i = 1; i < expnum; ++i) {
        for (int j = 0; j < 50; ++j) {
            deletions[j] = false;
        }
        long long xcopy = i;
        int d_idx = 0;
        int yess = 0;
        while(xcopy > 0) {
            deletions[d_idx] = xcopy%2;
            if (deletions[d_idx]) {
                yess++;
            }
            d_idx++;

            xcopy /= 2;
        }
        if (yess != k) {
            continue;
        }

        long long nav = compute_naviasity();
        // DEBUG START
//        printf("result for: ");
//        xcopy = i;
//        while(xcopy > 0) {
//            printf("%d", xcopy%2);
//            xcopy /= 2;
//        }
//        printf(" : %d\n", nav);
        // DEBUG END
        if (nav < min_naviasity) {
            min_naviasity = nav;
        }
    }

    printf("%lld\n", min_naviasity);
    return 0;
}

long long compute_naviasity() {
    int total_naviasity = 0;
    int prev_on_level[30];
    for(int i = 0; i < 30; ++i){
        prev_on_level[i] = 0;
    }
    int seen_n = 0;
    int current_level = 0;
    for (int i = 0; i < cleaned_n; ++i) {
        if (cleaned_expr[i] == '(') {
            current_level++;
        } else if (cleaned_expr[i] == 'B') {
            for(int i = 0; i < 30; ++i){
                prev_on_level[i] = 0;
            }
            current_level = 0;
        } else if (cleaned_expr[i] == 'N') {
            if (deletions[seen_n]) {
                // treat as 'B'
                for(int i = 0; i < 30; ++i){
                    prev_on_level[i] = 0;
                }
                current_level = 0;
            } else {
                total_naviasity += prev_on_level[current_level]+1;
                prev_on_level[current_level] ++;
            }
            seen_n += 1;
        } else if (cleaned_expr[i] == ')') {
            // reset current streak
            prev_on_level[current_level] = 0;
            current_level--;
            if (current_level < 0) {
                current_level = 0;
            } else {
                total_naviasity += prev_on_level[current_level]+1;
                prev_on_level[current_level] ++;
            }
        }
    }
    return total_naviasity;
}