#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct edge {
  int to, cap;
  int cost;
  int rev;
};
template <typename T>
class min_cost_flow {
 public:
  using pti = pair<T, int>;
  vector<vector<edge> > G;
  vector<T> h, dist;
  vector<int> prevv, preve;
  T inf;
  int V;
  min_cost_flow(int node_size) {
    V = node_size;
    inf = numeric_limits<T>::max() / 100;
    G.resize(V), h.resize(V), dist.resize(V), prevv.resize(V), preve.resize(V);
  }
  void add_edge(int from, int to, int cap, T cost) {
    G[from].push_back((edge){to, cap, cost, (int)G[to].size()});
    G[to].push_back((edge){from, 0, -cost, (int)G[from].size() - 1});
  }
  T solve(int s, int t, int f) {
    T res = 0;
    fill(h.begin(), h.end(), 0);
    while (f > 0) {
      priority_queue<pti, vector<pti>, greater<pti> > que;
      fill(dist.begin(), dist.end(), inf);
      dist[s] = 0;
      que.push(pti(0, s));
      while (!que.empty()) {
        pti p = que.top();
        que.pop();
        int v = p.second;
        if (dist[v] < p.first) {
          continue;
        }
        for (int i = 0; i < (int)G[v].size(); i++) {
          edge& e = G[v][i];
          if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
            dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
            prevv[e.to] = v, preve[e.to] = i;
            que.push(pti(dist[e.to], e.to));
          }
        }
      }
      if (dist[t] == inf) {
        return -1;
      }
      for (int i = 0; i < (int)V; i++) {
        h[i] += dist[i];
      }
      int d = f;
      for (int v = t; v != s; v = prevv[v]) {
        d = min(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * h[t];
      for (int v = t; v != s; v = prevv[v]) {
        edge& e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
    }
    return res;
  }
};
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n, p, s;
  cin >> n >> p >> s;
  vector<int> a(n), b(n);
  for (int i = 0; i < (int)n; i++) {
    cin >> a[i];
  }
  for (int i = 0; i < (int)n; i++) {
    cin >> b[i];
  }
  min_cost_flow<int> mc(n + 4);
  mc.add_edge(n, n + 1, p, 0);
  mc.add_edge(n, n + 2, s, 0);
  for (int i = 0; i < (int)n; i++) {
    mc.add_edge(n + 1, i, 1, 3000 - a[i]);
    mc.add_edge(n + 2, i, 1, 3000 - b[i]);
    mc.add_edge(i, n + 3, 1, 0);
  }
  cout << -(mc.solve(n, n + 3, s + p) - 3000 * (p + s)) << "\n";
  vector<int> a1, a2;
  vector<edge>& g = mc.G[n + 1];
  for (auto& e : g) {
    if (e.to != n && e.cap == 0) {
      a1.push_back(e.to + 1);
    }
  }
  g = mc.G[n + 2];
  for (auto& e : g) {
    if (e.to != n && e.cap == 0) {
      a2.push_back(e.to + 1);
    }
  }
  for (int i = 0; i < (int)a1.size(); i++) {
    cout << a1[i] << " ";
  }
  cout << "\n";
  for (int i = 0; i < (int)a2.size(); i++) {
    cout << a2[i] << " ";
  }
  cout << "\n";
  return 0;
}
