#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

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


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

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

	auto index_rend = [&](int a, int b){
		if(akar[index[a]].size() == 0 && akar[index[b]].size()){
			return false;
		} else if(akar[index[b]].size() == 0){
			return true;
		}

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

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

	int tesz = m - 1;
	int vesz = 0;
	int valasz = 0;
	vector<int> vegso(n, -1);
	vector<int> elsok(m);

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

	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;

	for(int i = m - 1; i >= 0 && aktDb[index[i]] == 0; i++){
		aktDb[nem_egyedul[ind]]--;
		valasz += sir[nem_egyedul[ind]];
		aktDb[index[i]]++;
		vegso[nem_egyedul[ind]] = index[i];
		ind++;
	}


	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){
				valasz += sir[akar[index[vesz]][elsok[index[vesz]]]];
				vegso[akar[index[vesz]][elsok[index[vesz]]]] = index[tesz];
				aktDb[index[vesz]]--;
				aktDb[index[tesz]]++;
				elsok[index[vesz]]++;
			} else{
				elsok[index[vesz]]++;
			}
		}

		vesz++;
	}

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


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


}