#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main(){
	int n, m;
    cin >> n >> m;


	vector<int> max_ember(m); // hany ember jatszhat egy szerepet
	for(auto &x : max_ember){
		cin >> x;
	}

	vector<int> valasztotta(n); // ki mit valasztott
	for(auto &x : valasztotta){
		cin >> x;
		x--;
	}

	vector<int> sir(n); // ki mennyit sir
	for(auto &x : sir){
		cin >> x;
	}
	// beolvasás vége
	//cout << "beolvas veg\n";

	vector<vector<int>> akar(m, vector<int>()); // melyik szerepet kik akarják
	for(int i = 0; i < n; i++){
		akar[valasztotta[i]].push_back(i);
	}

	//cout << "1\n";

	// elorebb kell-e legyen a, mint b?
	auto akar_ember_rendezo_comp = [&](int a, int b){
		return sir[a] < sir[b];
	};
	// !! PRIORITY_QUEUE-nál ez pont fordítva van


	vector<int> aktDb(m);
	for(int i = 0; i < m; i++){
		sort(akar[i].begin(), akar[i].end(), akar_ember_rendezo_comp);

		aktDb[i] = akar[i].size();
	}

	//cout << "1\n";

	vector<int> index(m);
	for(int i = 0; i < m; i++){
		index[i] = i;
	}

	//cout << "1\n";

	auto index_rend = [&](int a, int b){

		if(akar[a].size() == 0 && akar[b].size()){
			return false;
		} else if(akar[b].size() == 0 && akar[a].size()){
			return true;
		} else if(akar[a].size() == 0 && akar[b].size() == 0){
		    return a < b;
		}

		return max_ember[a] - akar[a].size() < max_ember[b] - akar[b].size();
	};

	sort(index.begin(), index.end(), index_rend);

	//cout << "1\n";

	vector<int> nem_egyedul; // nem egyedul levo emberek indexei, akik atrakhatoak
	for(int i = 0; i < n; i++){
		if(akar[valasztotta[i]].size() > 1){
			nem_egyedul.push_back(i);
		}
	}

	//cout << "1\n";

	auto nem_egyedul_rend = [&](int c, int d){
		int a = valasztotta[c];
		int b = valasztotta[d];
		if(max_ember[a] < aktDb[a] && max_ember[b] < aktDb[b]){
			return sir[c] < sir[d];
		} else if(max_ember[a] < aktDb[a]){
			return true;
		} else if(max_ember[b] < aktDb[b]){
			return false;
		}

		return sir[c] < sir[d];
	};

	sort(nem_egyedul.begin(), nem_egyedul.end(), nem_egyedul_rend);
	int ind = 0;

	vector<int> vegso(n, -1);
	vector<int> elsok(m);

	for(int i = m - 1; i >= 0 && aktDb[index[i]] == 0; i--){
		/*if(aktDb[index[i]] != 0){
			continue;
		}*/

		//cout << index[i] << "\n";
		aktDb[valasztotta[nem_egyedul[ind]]]--;
		aktDb[index[i]]++;
		vegso[nem_egyedul[ind]] = index[i];
		elsok[valasztotta[nem_egyedul[ind]]]++;
		ind++;
	}

	//cout << "nulla veg\n";

	//sort(index.begin(), index.end(), index_rend);
	/*while(max_ember[index[vesz]] - akar[index[vesz]].size() < 0){ // van meg olyan hely ahol tobben vannak mint kene
		while(max_ember[index[vesz]] - aktDb[index[vesz]] < 0){ // ez a hely meg olyan
			while(max_ember[index[tesz]] - aktDb[index[tesz]] <= 0){ // olyan helyre pakolunk ahova meg lehetseges
				tesz--;
			}

			if(vegso[akar[index[vesz]][elsok[index[vesz]]]] == -1){
				vegso[akar[index[vesz]][elsok[index[vesz]]]] = index[tesz];
				aktDb[index[vesz]]--;
				aktDb[index[tesz]]++;
				elsok[index[vesz]]++;
			} else{
				elsok[index[vesz]]++;
			}
		}

		vesz++;
	}*/

	for(int i = 0; i < m; i++){
        int ind = index[i];

        int tesz = m - 1;

        //if(max_ember[ind] >= aktDb[ind]) continue;

        while(max_ember[ind] < aktDb[ind]){
            //cout  << ind << "\n";
            while(tesz >= 0 && max_ember[tesz] == aktDb[tesz]){
                tesz--;
            }

            if(vegso[akar[ind][elsok[ind]]] == -1){
                vegso[akar[ind][elsok[ind]]] = index[tesz];
                aktDb[ind]--;
                aktDb[index[tesz]]++;
                elsok[ind]++;
            } else{
                elsok[ind]++;
            }
        }
	}

	int valasz = 0;
	for(int i = 0; i < n; i++){
        if(vegso[i] != -1){
            valasz += sir[i];
        }
	}
	cout << valasz << "\n";
	for(int i = 0; i < n; i++){
		if(vegso[i] != -1){
			cout << vegso[i] + 1 << " ";
		} else{
			cout << valasztotta[i] + 1 << " ";
		}
	}
	cout << "\n";


	// 1. rendezed a túlfolyásokat (mindenképpen lehetséges)
	// 		1.1 szerepeket berendezi plusz emberek alapján csökkenõbe
	//		1.2 elsõbõl pakolássza az utolsóba a legkevésbé sírósakat
	// 2. feltölti a helyeket, ahol nincs ember legkevésbé síró és nem egyedül lévõ emberekkel


}