#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

#include <fstream>

struct Gyerek {
    int kivant_szerep;
    int kapott_szerep = 0;
    int siras_percben;
};

void beolvas(std::istream &be, std::vector<Gyerek> &gyerekek, std::vector<int> &max_szereplok) {
    int n, k;
    be >> n >> k;

    max_szereplok.resize(k + 1);
    for (int i = 1; i <= k; i++) {
        be >> max_szereplok[i];
    }

    gyerekek.resize(n);
    for (auto &gy : gyerekek) {
        be >> gy.kivant_szerep;
    }
    for (auto &gy : gyerekek) {
        be >> gy.siras_percben;
    }
}

void feldolgoz(std::vector<Gyerek> &gyerekek, std::vector<int> &max_szereplok) {
    const int n = static_cast<int>(gyerekek.size());
    const int k = static_cast<int>(max_szereplok.size());

    std::vector<int> sorrend(n);
    std::iota(sorrend.begin(), sorrend.end(), 0);
    std::sort(sorrend.begin(), sorrend.end(), [&](int a, int b) {
        return gyerekek[a].siras_percben < gyerekek[b].siras_percben;
    });

    std::vector<int> szereplok_szama(k, 0);

    // Eloszor a legsirosabb gyerekek kapnak szerepet.
    for (int i = n - 1; i >= 0; i--) {
        auto &gy = gyerekek[sorrend[i]];

        if (szereplok_szama[gy.kivant_szerep] < max_szereplok[gy.kivant_szerep]) {
            gy.kapott_szerep = gy.kivant_szerep;
            szereplok_szama[gy.kapott_szerep]++;
        }
    }

    // Minden be nem toltott szerephez kijelolunk egy-egy olyan gyereket, akik eddig
    // meg nem kaptak semmilyen szerepet.
    int i, j = 1;
    for (i = 0; i < n; i++) {
        auto &gy = gyerekek[i];

        if (gy.kapott_szerep == 0) {
            for (; j < k && szereplok_szama[j] > 0; j++) {}
            if (j < k) {
                szereplok_szama[j]++;
                gy.kapott_szerep = j;

            } else {
                break;
            }
        }
    }

    if (i < n) {
        // Ha vannak meg olyan gyerekek, akik meg nem kaptak semmilyen szerepet, akkor
        // sorban kiosztjuk nekik a meg szabad szerepeket.
        j = 1;
        for (; i < n; i++) {
            auto &gy = gyerekek[i];

            if (gy.kapott_szerep == 0) {
                for (; j < k && szereplok_szama[j] == max_szereplok[j]; j++) {}
                gy.kapott_szerep = j;
                szereplok_szama[gy.kapott_szerep]++;
            }
        }

    } else {
        // Ha mar minden gyerek kapott szerepet, viszont vannak meg be nem toltott szerepek,
        // akkor nincs mas valasztasunk, mint hogy olyan gyerekeknek adjuk, akiknek van mar
        // ugyan szerepuk, de azt rajtuk kivul mar mas is megkapta. A szerepcsereket azokkal
        // a gyerekekkel kezdjuk, akik a legkevesebbet sirnak.
        for (i = 0; i < n && j < k; i++) {
            auto &gy = gyerekek[sorrend[i]];

            if (szereplok_szama[gy.kapott_szerep] > 1) {
                for (; j < k && szereplok_szama[j] > 0; j++) {}
                if (j < k) {
                    szereplok_szama[gy.kapott_szerep]--;
                    szereplok_szama[j]++;
                    gy.kapott_szerep = j;
                }
            }
        }
    }

    // Osszegezzuk azoknak a gyerekeknek a siras idejet, akik nem a kivant szerepet kaptak.
    int ossz_siras = 0;
    for (auto &gy : gyerekek) {
        if (gy.kapott_szerep != gy.kivant_szerep) {
            ossz_siras += gy.siras_percben;
        }
    }
    std::cout << ossz_siras << '\n';

    // Kiiratjuk a szereposztast.
    for (auto &gy : gyerekek) {
        std::cout << gy.kapott_szerep << ' ';
    }
    std::cout << '\n';
}

int main() {
    std::vector<Gyerek> gyerekek;
    std::vector<int> max_szereplok;
    beolvas(std::cin, gyerekek, max_szereplok);
    feldolgoz(gyerekek, max_szereplok);

    return 0;
}