#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

static int removeIndices[1000];
static int current[1000];
static int validPositions[1000];

int calculateTime(int* removeIdx, int removeCount, int* position, int* time, int n) {
    // Work on local copies
    int currentTime[1000];
    int currentPos[1000];
    int currentTimeSize = n - 1;
    int currentPosSize = n;

    for (int i = 0; i < n - 1; i++) currentTime[i] = time[i];
    for (int i = 0; i < n; i++)     currentPos[i]  = position[i];

    // Sort removal indices descending so each splice doesn't shift later targets
    int indices[1000];
    for (int i = 0; i < removeCount; i++) indices[i] = removeIdx[i];

    for (int i = 0; i < removeCount - 1; i++)
        for (int j = i + 1; j < removeCount; j++)
            if (indices[i] < indices[j]) {
                int t = indices[i]; indices[i] = indices[j]; indices[j] = t;
            }

    for (int i = 0; i < removeCount; i++) {
        int idx = indices[i]; // index into currentPos (1 .. currentPosSize-2)

        // The traveler at position idx hands its time to the previous segment.
        // time array index for the segment ENDING at position idx is (idx - 1).
        currentTime[idx - 1] += currentTime[idx];

        // Remove element idx from currentTime (size = currentPosSize - 1)
        for (int j = idx; j < currentTimeSize - 1; j++)
            currentTime[j] = currentTime[j + 1];
        currentTimeSize--;

        // Remove element idx from currentPos
        for (int j = idx; j < currentPosSize - 1; j++)
            currentPos[j] = currentPos[j + 1];
        currentPosSize--;
    }

    int totalTime = 0;
    for (int i = 0; i < currentTimeSize; i++) {
        int distance = currentPos[i + 1] - currentPos[i];
        totalTime += distance * currentTime[i];
    }
    return totalTime;
}

void generateCombinations(int arrSize, int k, int start, int currentSize,
                          int* minTime, int* position, int* time, int n) {
    if (currentSize == k) {
        int timeResult = calculateTime(current, k, position, time, n);
        if (timeResult < *minTime) *minTime = timeResult;
        return;
    }
    for (int i = start; i < arrSize; i++) {
        current[currentSize] = validPositions[i];
        generateCombinations(arrSize, k, i + 1, currentSize + 1, minTime, position, time, n);
    }
}

int minimumTravelTime(int l, int n, int k, int* position, int* time) {
    if (k == 0) {
        int total = 0;
        for (int i = 0; i < n - 1; i++)
            total += (position[i + 1] - position[i]) * time[i];
        return total;
    }

    int validCount = 0;
    for (int i = 1; i < n - 1; i++)
        validPositions[validCount++] = i;

    int minTime = INT_MAX;
    generateCombinations(validCount, k, 0, 0, &minTime, position, time, n);
    return minTime;
}

// Parse "[0,2,5,7,10]" into arr[], returns count
int parseArray(const char* s, int* arr) {
    int count = 0;
    const char* p = s;
    while (*p) {
        // skip non-digit, non-minus
        if (*p == '-' || (*p >= '0' && *p <= '9')) {
            arr[count++] = (int)strtol(p, (char**)&p, 10);
        } else {
            p++;
        }
    }
    return count;
}

int main() {
    int l, n, k;
    scanf("%d %d %d", &l, &n, &k);

    static int position[1000];
    static int timeArr[1000];

    char line[10000];

    // consume leftover newline
    scanf(" ");
    fgets(line, sizeof(line), stdin);
    parseArray(line, position);

    fgets(line, sizeof(line), stdin);
    parseArray(line, timeArr);

    printf("%d\n", minimumTravelTime(l, n, k, position, timeArr));
    return 0;
}