#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::vector<Gyerek> &gyerekek, std::vector<int> &max_szereplok, std::istream &be = std::cin) {
    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() - 1);

    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 + 1);

    // 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, szerep;
    for (szerep = 1; szerep <= k && szereplok_szama[szerep] > 0; szerep++) {}
    for (i = 0; i < n && szerep <= k; i++) {
        auto &gy = gyerekek[i];

        if (gy.kapott_szerep == 0) {
            gy.kapott_szerep = szerep;
            szereplok_szama[szerep]++;

            for (; szerep <= k && szereplok_szama[szerep] > 0; szerep++) {}
        }
    }

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

            if (gy.kapott_szerep == 0) {
                for (; szerep <= k && szereplok_szama[szerep] == max_szereplok[szerep]; szerep++) {}
                gy.kapott_szerep = szerep;
                szereplok_szama[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 && szerep <= k; i++) {
            auto &gy = gyerekek[sorrend[i]];

            if (szereplok_szama[gy.kapott_szerep] > 1) {
                szereplok_szama[gy.kapott_szerep]--;
                szereplok_szama[szerep] = 1;
                gy.kapott_szerep = szerep;

                for (; szerep <= k && szereplok_szama[szerep] > 0; szerep++) {}
            }
        }
    }

    // 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;
        }
    }

    using std::cout;

    cout << ossz_siras << '\n';

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

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

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

    return 0;
}