#include <bits/stdc++.h>
using namespace std;
const int SIZE = 3006;
const int INF = 100000000;
struct edge {
  int v;
  int flow;
  int capacity;
  int cost;
};
vector<vector<edge> > G(SIZE);
int n, p, s;
bool bellmanFord(const vector<vector<pair<int, int> > > &rGraph, int source,
                 int sink, vector<int> &path) {
  int parent[SIZE];
  int dist[SIZE];
  for (int i = 0; i < SIZE; i++) {
    dist[i] = INF;
  }
  dist[source] = 0;
  for (int i = 0; i < 6; i++) {
    for (int j = 0; j < rGraph.size(); j++) {
      if (dist[j] == INF) continue;
      for (auto e : rGraph[j]) {
        if (dist[e.first] > dist[j] + e.second) {
          dist[e.first] = dist[j] + e.second;
          parent[e.first] = j;
        }
      }
    }
  }
  if (dist[sink] == INF) {
    return false;
  }
  int cur = sink;
  while (cur != source) {
    path.push_back(cur);
    cur = parent[cur];
  }
  path.push_back(cur);
  reverse(path.begin(), path.end());
  return true;
}
int minCostMaxFlow(int source, int sink) {
  vector<vector<pair<int, int> > > rGraph(SIZE);
  vector<int> path;
  for (int i = 1; i <= n; i++) {
    rGraph[0].push_back({i, 0});
    rGraph[i].push_back({n + 1, G[i][0].cost});
    rGraph[i].push_back({n + 2, G[i][1].cost});
  }
  rGraph[n + 1].push_back({n + 3, 0});
  rGraph[n + 2].push_back({n + 3, 0});
  while (bellmanFord(rGraph, source, sink, path)) {
    G[0][path[1] - 1].flow = 1;
    G[path[1]][path[2] == n + 1 ? 0 : 1].flow = 1;
    if (path.size() == 4) {
      G[path[2]][0].flow += 1;
    } else {
      G[path[3]][path[2] == n + 1 ? 0 : 1].flow = 0;
      G[path[3]][path[4] == n + 1 ? 0 : 1].flow = 1;
      G[path[4]][0].flow += 1;
    }
    path.clear();
    for (int i = 0; i < SIZE; i++) {
      rGraph[i].clear();
    }
    for (int i = 1; i <= n; i++) {
      if (G[0][i - 1].flow == 0) {
        rGraph[0].push_back({i, 0});
      }
      if (G[i][0].flow == 0) {
        rGraph[i].push_back({n + 1, G[i][0].cost});
      } else {
        rGraph[n + 1].push_back({i, -G[i][0].cost});
      }
      if (G[i][1].flow == 0) {
        rGraph[i].push_back({n + 2, G[i][1].cost});
      } else {
        rGraph[n + 2].push_back({i, -G[i][1].cost});
      }
    }
    if (G[n + 1][0].capacity - G[n + 1][0].flow > 0) {
      rGraph[n + 1].push_back({n + 3, 0});
    }
    if (G[n + 2][0].capacity - G[n + 2][0].flow > 0) {
      rGraph[n + 2].push_back({n + 3, 0});
    }
  }
  int minCost = 0;
  for (int i = 0; i < SIZE; i++) {
    for (int j = 0; j < G[i].size(); j++) {
      minCost += G[i][j].flow * G[i][j].cost;
    }
  }
  return minCost;
}
int main(void) {
  ios_base::sync_with_stdio(false);
  cin >> n >> p >> s;
  for (int i = 1; i <= n; i++) {
    edge e;
    e.flow = 0;
    e.capacity = 1;
    e.v = n + 1;
    cin >> e.cost;
    e.cost *= -1;
    G[i].push_back(e);
  }
  for (int i = 1; i <= n; i++) {
    edge e;
    e.flow = 0;
    e.capacity = 1;
    e.v = n + 2;
    cin >> e.cost;
    e.cost *= -1;
    G[i].push_back(e);
  }
  for (int i = 1; i <= n; i++) {
    edge e;
    e.capacity = 1;
    e.cost = 0;
    e.flow = 0;
    e.v = i;
    G[0].push_back(e);
  }
  edge e;
  e.capacity = p;
  e.flow = 0;
  e.cost = 0;
  e.v = n + 3;
  G[n + 1].push_back(e);
  e.capacity = s;
  G[n + 2].push_back(e);
  cout << -minCostMaxFlow(0, n + 3) << "\n";
  for (int i = 1; i <= n; i++) {
    if (G[i][0].flow == 1) {
      cout << i << " ";
    }
  }
  cout << "\n";
  for (int i = 1; i <= n; i++) {
    if (G[i][1].flow == 1) {
      cout << i << " ";
    }
  }
  return 0;
}
