#include <bits/stdc++.h>
using namespace std;
struct edge {
  int to, cap, cost, rev;
  edge(int t, int c, int co, int r) {
    to = t;
    cap = c;
    cost = co;
    rev = r;
  }
};
struct mincostflow {
  vector<edge> G[3005];
  int V;
  int h[3005];
  int dist[3005];
  int prevv[3005], preve[3005];
  void add_edge(int from, int to, int cap, int cost) {
    G[from].push_back(edge(to, cap, cost, G[to].size()));
    G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
  }
  int min_cost_flow(int s, int t, int f, int V) {
    int res = 0;
    fill(h, h + V, 0);
    while (f > 0) {
      priority_queue<pair<int, int>, vector<pair<int, int> >,
                     greater<pair<int, int> > >
          que;
      fill(dist, dist + V, 10000000);
      dist[s] = 0;
      que.push(pair<int, int>(0, s));
      while (que.size()) {
        pair<int, int> p = que.top();
        que.pop();
        int v = p.second;
        if (dist[v] < p.first) continue;
        for (int i = 0; i < 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(pair<int, int>(dist[e.to], e.to));
          }
        }
      }
      if (dist[t] == 10000000) return -1;
      for (int v = 0; v < V; v++) {
        h[v] += dist[v];
      }
      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 n, p, s;
int a[3001], b[3001];
mincostflow mi;
int main(void) {
  scanf("%d%d%d", &n, &p, &s);
  for (int i = 0; i < n; i++) {
    scanf("%d", &a[i]);
  }
  for (int i = 0; i < n; i++) {
    scanf("%d", &b[i]);
  }
  int S = n + 2, T = S + 1;
  int maxi = 3000;
  for (int i = 0; i < n; i++) {
    mi.add_edge(S, i, 1, 0);
    mi.add_edge(i, n, 1, maxi - a[i]);
    mi.add_edge(i, n + 1, 1, maxi - b[i]);
  }
  mi.add_edge(n, T, p, 0);
  mi.add_edge(n + 1, T, s, 0);
  printf("%d\n", maxi * (p + s) - mi.min_cost_flow(S, T, p + s, T + 1));
  vector<int> ans[2];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < mi.G[i].size(); j++) {
      edge e = mi.G[i][j];
      if (e.to == n && e.cap == 0) {
        ans[0].push_back(i + 1);
      }
      if (e.to == (n + 1) && e.cap == 0) {
        ans[1].push_back(i + 1);
      }
    }
  }
  for (int i = 0; i < 2; i++) {
    for (int j = 0; j < ans[i].size(); j++) {
      printf("%d%c", ans[i][j], j + 1 == ans[i].size() ? '\n' : ' ');
    }
  }
  return 0;
}
