SGU 323 Aviamachinations

Aviamachinations

Time Limit: 4500ms

Memory Limit: 65536KB

This problem will be judged on SGU. Original ID: 323
64-bit integer IO format: %I64d      Java class name: Solution

 

Berland consists of N towns as you probably already know. Berland also has M domestic airlines. In fact all these airlines belong to Don Berlione. Don Berlione was forced to create a number of companies instead of just one by the Antimonopoly Committee. 

The Antimonopoly Committee was disbanded as a result of a government crisis. So, Don Berlione decided to close all but one airline. Naturally, this company should have flights (possibly including stopovers) from any town of Berland to any other one. To be able to choose the airline satisfying the above requirement, Don Berlione decided to carry out a number of fake purchase-sell operations. During a purchase-sell operation a flight of one airline is passed under the control of another airline. A purchase-sell operation is just a money transfer from one pocket to another. But still a special tax should be paid to the government for each operation.

So each flight is characterized by two towns it connects, the airline it belongs to and the tax amount that should be paid for a purchase-sell operation.

Your task is to find P — the minimum possible amount of money Don Berlione needs to spend to make it possible to leave only one airline carrying out flights (possibly with stopovers) from each town of Berland to any other. Also you need to suggest a plan of actions for Don Berlione.

 

Input

The first line of the input file contains three integer numbers N, M, K (1 ≤ N ≤ 2000; 1 ≤ M ≤ 2000; 0 ≤ K ≤ 200000), where N is the number of towns, M is the number of airlines, K is the number of flights. Each of the following K lines contains the description of the flight given by four integer numbers ai, bi, ci, pi, where ai, bi (ai != bi; 1≤ ai, bi≤ N) are the numbers of towns connected by the flight (towns are numbered from 1 to N), ci (1≤ ci≤ M) is the number of the airline owning the flight (airlines are numbered from 1 to M), pi (1≤ pi≤ 100000) is the tax amount required for the purchase-sell operation of the flight. Originally all flights are planned in such a way that it is possible to get from each town to any other using flights of one or several airlines. There can be several flights between a pair of towns.

 

Output

Write the desired minimum amount of money P to the first line of the output. After that write a pair of numbers R and Q to the same line, where R is the index of an airline which should be chosen by Don and Q is the number of purchase-sell operations. Write the description of operations to the following Q lines. Each operation should be characterized by a single integer number idxj, which means that the flight idxj should be sold to the company R. If there are several solutions for the problem, choose any of them.

 

Sample Input

Example(s)

sample input	sample output
4 3 4 2 3 1 6 4 3 2 7 1 2 2 3 1 3 3 5	5 2 1 4

解题：最小生成树的妙用啊。。。

 通过枚举航空公司，判断是否连通，不连通，用最小生成树中的边补连通。。。妙哉

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 600000;
class ARC {
public:
    int u,v;
    ARC(int x = 0,int y = 0) {
        u = x;
        v = y;
    }
};
class ARC1:public ARC {
public:
    int w,id;
    ARC1(int x = 0,int y = 0,int cw = 0,int cid = 0):ARC(x,y) {
        w = cw;
        id = cid;
    }
    bool operator<(const ARC1 &t) {
        return w < t.w;
    }
} g[maxn];
class ARC2:public ARC {
public:
    int next;
    ARC2(int x = 0,int y = 0,int nxt = -1):ARC(x,y) {
        next = nxt;
    }
} e[maxn];
int head[maxn],uf[maxn],tot,n,m,k;
void init() {
    for(int i = 0; i <= n; ++i) uf[i] = i;
}
int Find(int x) {
    return uf[x] = x == uf[x]?x:Find(uf[x]);
}
void add(int u,int v,int x) {
    e[tot] = ARC2(u,v,head[x]);
    head[x] = tot++;
}
vector<int>MST,ans,tans;
void Kruskal() {
    init();
    MST.clear();
    sort(g,g+k);
    for(int i = 0; i < k; ++i) {
        int x = Find(g[i].u),y = Find(g[i].v);
        if(x == y) continue;
        uf[x] = y;
        MST.push_back(i);
        if(MST.size() >= n-1) return;
    }
}
void solve() {
    int sum = 0x3f3f3f3f,id,tsum;
    for(int i = 1; i <= m; ++i) {
        init();
        tans.clear();
        for(int j = head[i]; ~j; j = e[j].next) {
            int x = Find(e[j].u),y = Find(e[j].v);
            if(x != y) uf[x] = y;
        }
        for(int j = tsum = 0; j < MST.size(); ++j) {
            int x = Find(g[MST[j]].u),y = Find(g[MST[j]].v);
            if(x == y) continue;
            tsum += g[MST[j]].w;
            uf[x] = y;
            tans.push_back(MST[j]);
        }
        if(tsum < sum) {
            sum = tsum;
            id = i;
            ans.clear();
            std::copy(tans.begin(),tans.end(),std::back_inserter(ans));
        }
    }
    printf("%d %d %d
",sum,id,ans.size());
    bool flag = false;
    sort(ans.begin(),ans.end());
    for(int i = 0; i < ans.size(); ++i) {
        if(flag) putchar(' ');
        printf("%d",g[ans[i]].id);
        flag = true;
    }
    putchar('
');
}
int main() {
    int a,b,c,p;
    scanf("%d %d %d",&n,&m,&k);
    memset(head,-1,sizeof(head));
    for(int i = tot = 0; i < k; ++i) {
        scanf("%d %d %d %d",&a,&b,&c,&p);
        g[i] = ARC1(a,b,p,i + 1);
        add(a,b,c);
    }
    Kruskal();
    solve();
    return 0;
}