1090: MTM （费用流）

1090: MTM

Time Limit:3000/1000 MS (Java/Others)   Memory Limit:163840/131072 KB (Java/Others)
Total Submissions:127   Accepted:19

[Submit][Status][Discuss]

Description

MTM is not only a good ACMer but also a good teacher. There are n" role="presentation">n

students in MTM’s class. Every student has two skills, each measured as a number:ai" role="presentation">ai – the programming skill andbi" role="presentation">bi

– the math skill.

Both ACM competition and Math
competition will be held soon. So MTM decides to compose two teams to
take part in these competitions. Because of the limitation of the number
of student, MTM has to select p" role="presentation">p

students to take part in the ACM competition ands" role="presentation">s

students to take part in the Math competition. A student can't be a member of both teams.

MTM considers that his expected
result is equal to the sum of two values: the ACM team strength and the
Math team strength. The strength of each team is the sum of skills of
its members in the corresponding area.

Help MTM to compose two teams to maximize his expected result.

Input

The input test file will contain multiple test cases. The first line of each input contains three positive integer numbers n" role="presentation">n

, p" role="presentation">p and s" role="presentation">s (2 ≤ n ≤ 500" role="presentation">2≤n≤500, p + s ≤ n" role="presentation">p+s≤n) --- the number of students, the size of the ACM team and the size of the Math team.

The second line contains n" role="presentation">n positive integers a1, a2, …, an" role="presentation">a1,a2,…,an (1 ≤ ai ≤ 500" role="presentation">1≤ai≤500), where ai" role="presentation">ai is the programming skill of the i" role="presentation">i-th student.

The third line containsn" role="presentation">n positive integersb1, b2, …, bn" role="presentation">b1,b2,…,bn (1 ≤ bi ≤ 500" role="presentation">1≤bi≤500), wherebi" role="presentation">bi is the math skill of thei" role="presentation">i

-th student.

Output

In
the first line, print the maximum strength of MTM’s expected result. In
the second line, print p numbers — the members of the ACM team. In the
third line, print s numbers — the members of the Math team.

The students are numbered from 1" role="presentation">1

ton" role="presentation">n

as they are given in the input. All numbers printed in the second and in the third lines should be distinct and should be printed in ascending order.

Sample Input

5 2 2
1 3 4 5 2
5 3 2 1 4

4 2 2
10 8 8 3
10 7 9 4

5 3 1
5 2 5 1 7
6 3 1 6 3

Sample Output

18
3 4
1 5
31
1 2
3 4
23
1 3 5
4

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <time.h>
#include <string>
#include <map>
#include <stack>
#include <vector>
#include <set>
#include <queue>
#define inf 0x7fffffff
#define mod 10000
#define met(a,b) memset(a,b,sizeof a)
typedef long long ll;
using namespace std;
const int N = +;
const int M = ;
set<int>ac,ma;
int n,p,s;
int acm[N],math[N];
struct Edge {
  int from, to, cap, flow;
  int  cost;
};
inline int Min(int aa,int bb)
{
    return aa<bb?aa:bb;
}
struct MCMF {
  int n, m, s, t;
  vector<Edge> edges;
  vector<int> G[N];
  int inq[N];         // 是否在队列中
  int d[N];           // Bellman-Ford
  int p[N];           // 上一条弧
  int a[N];           // 可改进量
  void init(int n) {
    this->n = n;
    for(int i = ; i < n; i++) G[i].clear();
    edges.clear();
  }

  void addedge(int from, int to, int cap, int cost) {
    edges.push_back((Edge){from, to, cap, , cost});
    edges.push_back((Edge){to, from, , , -cost});
    m = edges.size();
    G[from].push_back(m-);
    G[to].push_back(m-);
  }

  bool BellmanFord(int s, int t, int& flow,int& cost) {
    for(int i = ; i < n; i++) d[i] = inf;
    memset(inq, , sizeof(inq));
    d[s] = ; inq[s] = ; p[s] = ; a[s] = inf;

    queue<int> Q;
    Q.push(s);
    while(!Q.empty()) {
      int u = Q.front(); Q.pop();
      inq[u] = ;
      int l=G[u].size();
      for(int i = ; i < l; i++) {
        Edge& e = edges[G[u][i]];
        if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {
          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] = ; }
        }
      }
    }
    if(d[t] == inf) return false;
    cost += d[t]*a[t];
    int u = t;
    while(u != s) {
      edges[p[u]].flow += a[t];
      edges[p[u]^].flow -= a[t];
      u = edges[p[u]].from;
    }
    return true;
  }
  // 需要保证初始网络中没有负权圈
    void Mincost(int s, int t) {
        int cost = ;
        int flow=;
        while(BellmanFord(s, t,flow, cost));
        printf("%d\n",-cost);
    }
}g;
int main() {
    int k;
    while(~scanf("%d%d%d",&n,&p,&s) ) {
        g.init(n+);
        ac.clear();ma.clear();
        for(int i=;i<=n;i++)scanf("%d",&acm[i]);
        for(int i=;i<=n;i++)scanf("%d",&math[i]);
        for(int i=;i<=n;i++){
            g.addedge(,i,,);
            g.addedge(i,n+,,-acm[i]);
            g.addedge(i,n+,,-math[i]);
        }
        g.addedge(n+,n+,p,);g.addedge(n+,n+,s,);
        int ans=;
        g.Mincost(,n+);

        for(int i=;i<g.m;i++){
            Edge temp=g.edges[i];
            if(temp.to==n+&&temp.flow==) {
                ac.insert(temp.from);
            }
            else if(temp.to==n+&&temp.flow==) {
                ma.insert(temp.from);
            }
        }
        bool f=false;
        for(int x:ac){
                if (f==false){
                    printf("%d",x);
                    f=true;
                }
                else
                    printf(" %d",x);
        }
        printf("\n");
        f=false;
        for(int x:ma){
                if (f==false){
                    printf("%d",x);
                    f=true;
                }
                else
                    printf(" %d",x);
        }
        printf("\n");
    }
    return ;
}