#include <bits/stdc++.h>
using namespace std;
template <class Flow = int, class Cost = int>
struct MinCostFlow {
  struct Edge {
    int t;
    Flow f;
    Cost c;
    Edge *next, *rev;
    Edge(int _t, Flow _f, Cost _c, Edge* _next)
        : t(_t), f(_f), c(_c), next(_next) {}
  };
  vector<Edge*> E;
  int addV() {
    E.push_back((Edge*)0);
    return E.size() - 1;
  }
  Edge* makeEdge(int s, int t, Flow f, Cost c) {
    return E[s] = new Edge(t, f, c, E[s]);
  }
  Edge* addEdge(int s, int t, Flow f, Cost c) {
    Edge *e1 = makeEdge(s, t, f, c), *e2 = makeEdge(t, s, 0, -c);
    e1->rev = e2, e2->rev = e1;
    return e1;
  }
  pair<Flow, Cost> minCostFlow(int vs, int vt) {
    int n = E.size();
    Flow flow = 0;
    Cost cost = 0;
    const Cost MAX_COST = INT_MAX;
    const Flow MAX_FLOW = INT_MAX;
    for (;;) {
      vector<Cost> dist(n, MAX_COST);
      vector<Flow> am(n, 0);
      vector<Edge*> prev(n);
      vector<bool> inQ(n, false);
      queue<int> que;
      dist[vs] = 0;
      am[vs] = MAX_FLOW;
      que.push(vs);
      inQ[vs] = true;
      while (!que.empty()) {
        int u = que.front();
        Cost c = dist[u];
        que.pop();
        inQ[u] = false;
        for (Edge* e = E[u]; e; e = e->next)
          if (e->f > 0) {
            Cost nc = c + e->c;
            if (nc < dist[e->t]) {
              dist[e->t] = nc;
              prev[e->t] = e;
              am[e->t] = min(am[u], e->f);
              if (!inQ[e->t]) {
                que.push(e->t);
                inQ[e->t] = true;
              }
            }
          }
      }
      if (dist[vt] == MAX_COST) break;
      Flow by = am[vt];
      int u = vt;
      flow += by;
      cost += by * dist[vt];
      while (u != vs) {
        Edge* e = prev[u];
        e->f -= by;
        e->rev->f += by;
        u = e->rev->t;
      }
    }
    return make_pair(flow, cost);
  }
  vector<pair<int, int> > getRes(int N, int vsp, int vss) {
    vector<pair<int, int> > res;
    for (Edge* e = E[vsp]; e; e = e->next) {
      if (e->f != 0) res.push_back({e->t + 1 - N, 1});
    }
    for (Edge* e = E[vss]; e; e = e->next) {
      if (e->f != 0) {
        res.push_back({e->t + 1 - N, 2});
      }
    }
    return res;
    for (int i = 1; i <= N; i++) {
      int u = i + N - 1;
      u = 12;
      for (Edge* e = E[u]; e; e = e->next) {
        if (u == 12) {
          cout << "haha " << e->t << " " << e->f << endl;
        }
        if (e->t == vsp) {
          if (e->f != 0) {
            cout << i << " " << e->f << endl;
            res.push_back({i, 1});
          }
        } else if (e->t == vss) {
          if (e->f != 0) {
            cout << i << " " << e->f << endl;
            res.push_back({i, 2});
          }
        }
      }
    }
    return res;
  }
};
struct Edge {
  int u, v, f, c;
};
vector<Edge> E;
int a[3005], b[3005];
int N, P, S, vs, vt, vsp, vss;
MinCostFlow<int, int> mcf;
int main() {
  scanf("%d%d%d", &N, &P, &S);
  vs = 2 * N + 1;
  vss = 2 * N + 2;
  vsp = 2 * N + 3;
  vt = 2 * N + 4;
  for (int i = 1; i <= N; i++) {
    scanf("%d", &a[i]);
    E.push_back({vs, i, 1, 0});
    E.push_back({i, i + N, 1, 0});
    E.push_back({i + N, vsp, 1, -a[i]});
  }
  for (int i = 1; i <= N; i++) {
    scanf("%d", &b[i]);
    E.push_back({i + N, vss, 1, -b[i]});
  }
  E.push_back({vsp, vt, P, 0});
  E.push_back({vss, vt, S, 0});
  N = 2 * N + 4;
  for (int i = 0; i < N; i++) mcf.addV();
  for (int i = 0; i < int(E.size()); i++) {
    mcf.addEdge(E[i].u - 1, E[i].v - 1, E[i].f, E[i].c);
  }
  pair<int, int> res = mcf.minCostFlow(vs - 1, vt - 1);
  printf("%d\n", -res.second);
  vector<pair<int, int> > ans = mcf.getRes((N - 4) / 2, vsp - 1, vss - 1);
  for (int i = 0; i < int(ans.size()); i++) {
    if (ans[i].second == 1) printf("%d ", ans[i].first);
  }
  puts("");
  for (int i = 0; i < int(ans.size()); i++) {
    if (ans[i].second == 2) printf("%d ", ans[i].first);
  }
  puts("");
  return 0;
}
