#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 9;
const long long INFLL = 1LL << 60;
const int maxn = 10010;
struct Edge {
  int from, to, cap, flow;
  long long cost;
};
struct MCMF {
  int n, m, s, t, flow;
  vector<Edge> edges;
  vector<int> G[maxn];
  long long d[maxn];
  int p[maxn], a[maxn];
  bool vis[maxn], inq[maxn];
  void addEdge(int from, int to, int cap, long long cost) {
    edges.push_back((Edge){from, to, cap, 0, cost});
    edges.push_back((Edge){to, from, 0, 0, -cost});
    m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
  }
  bool BellmanFord(int &flow, long long &cost) {
    for (int(i) = 0; (i) < (n); i++) {
      d[i] = INFLL;
    }
    memset(inq, 0, sizeof(inq));
    d[s] = 0, inq[s] = 1, p[s] = 0, a[s] = INF;
    queue<int> Q;
    Q.push(s);
    while (!Q.empty()) {
      int u = Q.front();
      Q.pop();
      inq[u] = 0;
      for (int(i) = 0; (i) < (G[u].size()); i++) {
        Edge &e = edges[G[u][i]];
        if (e.cap > e.flow && d[e.to] > e.cost + d[u]) {
          d[e.to] = d[u] + e.cost;
          p[e.to] = G[u][i];
          a[e.to] = min(a[u], e.cap - e.flow);
          if (!inq[e.to]) {
            Q.push(e.to);
            inq[e.to] = 1;
          }
        }
      }
    }
    if (d[t] == INFLL) return false;
    flow += a[t];
    cost += d[t] * a[t];
    int u = t;
    while (u != s) {
      edges[p[u]].flow += a[t];
      edges[p[u] ^ 1].flow -= a[t];
      u = edges[p[u]].from;
    }
    return true;
  }
  long long minCostMaxFlow(int s, int t) {
    this->s = s, this->t = t;
    flow = 0;
    long long cost = 0;
    while (BellmanFord(flow, cost))
      ;
    return cost;
  }
  void ini(int n) {
    this->n = n;
    for (int(i) = 0; (i) < (n); i++) {
      G[i].clear();
    }
    edges.clear();
  }
} G;
int N, P, S;
int p[3333], s[3333];
int main() {
  cin >> N >> P >> S;
  for (int(i) = 1; (i) <= (N); i++) {
    cin >> p[i];
  }
  for (int(i) = 1; (i) <= (N); i++) {
    cin >> s[i];
  }
  G.ini(N + 4);
  for (int(i) = 1; (i) <= (N); i++) {
    G.addEdge(0, i, 1, 0);
    G.addEdge(i, N + 1, 1, -p[i]);
    G.addEdge(i, N + 2, 1, -s[i]);
  }
  G.addEdge(N + 1, N + 3, P, 0);
  G.addEdge(N + 2, N + 3, S, 0);
  long long ans = G.minCostMaxFlow(0, N + 3);
  cout << -ans << endl;
  bool ok = 1;
  for (auto e : G.edges) {
    if (e.from > 0 && e.from <= N && e.to == N + 1 && e.flow == 1) {
      if (!ok) {
        cout << " ";
      } else
        ok = 0;
      cout << e.from;
    }
  }
  cout << endl;
  ok = 1;
  for (auto e : G.edges) {
    if (e.from > 0 && e.from <= N && e.to == N + 2 && e.flow == 1) {
      if (!ok) {
        cout << " ";
      } else
        ok = 0;
      cout << e.from;
    }
  }
  cout << endl;
  return 0;
}
