#include <iostream>
#include <cstring>
using namespace std;

const int MAX_LEN = 2010;
const int MAX_K = 2010;
const int INF = (1 << 25);

int dp_x_min[MAX_LEN][MAX_K][2],
    dp_x_max[MAX_LEN][MAX_K][2],
    dp_y_min[MAX_LEN][MAX_K][2],
    dp_y_max[MAX_LEN][MAX_K][2];

int main() {
    string s;
    int k;

    cin >> s;
    cin >> k;

    int n = s.size();

    for (int i = 0; i <= n; i++) {
        for (int k_i = 0; k_i <= k; k_i++) {
            for (int state = 0; state <= 1; state++) {
                dp_x_min[i][k_i][state] = INF;
                dp_x_max[i][k_i][state] = -INF;
                dp_y_min[i][k_i][state] = INF;
                dp_y_max[i][k_i][state] = -INF;
            }
        }
    }


    dp_x_max[0][0][0] = dp_x_min[0][0][0] = 0;
    for (int i = 0; i < n; i++) {
        for (int k_i = 0; k_i <= k; k_i++) {
            for (int state = 0; state <= 1; state++) {
                if (s[i] == 'L' || s[i] == 'R') {
                    int dir = (s[i] == 'L') ? -1 : 1;
                    if (state == 1) dir = -dir; // ?????¢

                    // maximize
                    dp_x_max[i + 1][k_i][state] = max(dp_x_max[i + 1][k_i][state],
                                                      dp_x_max[i][k_i][state] + dir);

                    // minimize
                    dp_x_min[i + 1][k_i][state] = min(dp_x_min[i + 1][k_i][state],
                                                      dp_x_min[i][k_i][state] + dir);
                    // ?????????????????´???
                    if (k_i + 1 > k) continue;

                    int next_state = (state + 1) % 2,
                        next_dir = -dir;

                    // maximize
                    dp_x_max[i + 1][k_i + 1][next_state] = max(dp_x_max[i + 1][k_i + 1][next_state],
                                                               dp_x_max[i][k_i][state] + next_dir);

                    // minimize
                    dp_x_min[i + 1][k_i + 1][next_state] = min(dp_x_min[i + 1][k_i + 1][next_state],
                                                               dp_x_min[i][k_i][state] + next_dir);

                } else {
                    dp_x_max[i + 1][k_i][state] = max(dp_x_max[i + 1][k_i][state],
                                                      dp_x_max[i][k_i][state]);
                    dp_x_min[i + 1][k_i][state] = min(dp_x_min[i + 1][k_i][state],
                                                      dp_x_min[i][k_i][state]);
                }
            }
        }
    }

    dp_y_max[0][0][0] = dp_y_min[0][0][0] = 0;
    for (int i = 0; i < n; i++) {
        for (int k_i = 0; k_i <= k; k_i++) {
            for (int state = 0; state <= 1; state++) {
                if (s[i] == 'U' || s[i] == 'D') {
                    int dir = (s[i] == 'D') ? -1 : 1;
                    if (state == 1) dir = -dir; // ?????¢

                    // maximize
                    dp_y_max[i + 1][k_i][state] = max(dp_y_max[i + 1][k_i][state],
                                                      dp_y_max[i][k_i][state] + dir);

                    // minimize
                    dp_y_min[i + 1][k_i][state] = min(dp_y_min[i + 1][k_i][state],
                                                      dp_y_min[i][k_i][state] + dir);
                    // ?????????????????´???
                    if (k_i + 1 > k) continue;

                    int next_state = (state + 1) % 2,
                        next_dir = -dir;

                    // maximize
                    dp_y_max[i + 1][k_i + 1][next_state] = max(dp_y_max[i + 1][k_i + 1][next_state],
                                                               dp_y_max[i][k_i][state] + next_dir);

                    // minimize
                    dp_y_min[i + 1][k_i + 1][next_state] = min(dp_y_min[i + 1][k_i + 1][next_state],
                                                               dp_y_min[i][k_i][state] + next_dir);

                } else {
                    dp_y_max[i + 1][k_i][state] = max(dp_y_max[i + 1][k_i][state],
                                                      dp_y_max[i][k_i][state]);
                    dp_y_min[i + 1][k_i][state] = min(dp_y_min[i + 1][k_i][state],
                                                      dp_y_min[i][k_i][state]);
                }
            }
        }
    }

    // INF?????????
    for (int k_i = 0; k_i <= k; k_i++) {
        for (int state = 0; state <= 1; state++) {
            if (abs(dp_x_max[n][k_i][state]) >= INF / 2) dp_x_max[n][k_i][state] = 0;
            if (abs(dp_x_min[n][k_i][state]) >= INF / 2) dp_x_min[n][k_i][state] = 0;
            if (abs(dp_y_max[n][k_i][state]) >= INF / 2) dp_y_max[n][k_i][state] = 0;
            if (abs(dp_y_min[n][k_i][state]) >= INF / 2) dp_y_min[n][k_i][state] = 0;

            /*
            if (abs(dp_x_max[n][k_i][state]) >= 1000) dp_x_max[n][k_i][state] = 0;
            if (abs(dp_x_min[n][k_i][state]) >= 1000) dp_x_min[n][k_i][state] = 0;
            if (abs(dp_y_max[n][k_i][state]) >= 1000) dp_y_max[n][k_i][state] = 0;
            if (abs(dp_y_min[n][k_i][state]) >= 1000) dp_y_min[n][k_i][state] = 0;
            */
        }
    }

    int ans = -INF;
    for (int k1 = 0; k1 <= k; k1++) {
        for (int k2 = 0; k2 <= k; k2++) {
            if (k1 + k2 > k) continue;

            for (int state1 = 0; state1 <= 1; state1++) {
                for (int state2 = 0; state2 <= 1; state2++) {
                    ans = max(ans, abs(dp_x_max[n][k1][state1]) + abs(dp_y_max[n][k2][state2]));
                    ans = max(ans, abs(dp_x_max[n][k1][state1]) + abs(dp_y_min[n][k2][state2]));
                    ans = max(ans, abs(dp_x_min[n][k1][state1]) + abs(dp_y_max[n][k2][state2]));
                    ans = max(ans, abs(dp_x_min[n][k1][state1]) + abs(dp_y_min[n][k2][state2]));
                }
            }
        }
    }
    cout << ans << endl;

    /*
    int a, b, c;
    while (cin >> a >> b >> c, a >= 0 && b >= 0 && c >= 0) {
        cout << "[i] " << a << " [k_i] " << b << " [state] " << c << endl;
        cout << "[x_max] " << dp_x_max[a][b][c] << endl;
        cout << "[x_min] " << dp_x_min[a][b][c] << endl;
        cout << "[y_max] " << dp_y_max[a][b][c] << endl;
        cout << "[y_min] " << dp_y_min[a][b][c] << endl;
    }
    */

    return 0;
}

Measured memory_bytes: 128880