CodeForces 76A Gift - 最小生成树

The kingdom of Olympia consists of N cities and M bidirectional roads. Each road connects exactly two cities and two cities can be connected with more than one road. Also it possible that some roads connect city with itself making a loop.

All roads are constantly plundered with bandits. After a while bandits became bored of wasting time in road robberies, so they suggested the king of Olympia to pay off. According to the offer, bandits want to get a gift consisted of gold and silver coins. Offer also contains a list of restrictions: for each road it is known g_i — the smallest amount of gold and s_i — the smallest amount of silver coins that should be in the gift to stop robberies on the road. That is, if the gift contains agold and b silver coins, then bandits will stop robberies on all the roads that g_i ≤ a and s_i ≤ b.

Unfortunately kingdom treasury doesn't contain neither gold nor silver coins, but there are Olympian tugriks in it. The cost of one gold coin in tugriks is G, and the cost of one silver coin in tugriks is S. King really wants to send bandits such gift that for any two cities there will exist a safe path between them. Your task is to find the minimal cost in Olympian tugriks of the required gift.

Input

The first line of the input contains two integers N and M (2 ≤ N ≤ 200, 1 ≤ M ≤ 50 000) — the number of cities and the number of roads, respectively. The second line contains two integers G and S (1 ≤ G, S ≤ 10⁹) — the prices of gold and silver coins in tugriks. The following M lines contain information about the offer. Each of the records in list is given as four integers x_i, y_i, g_i, s_i, where x_i and y_i are the numbers of cities that the road connects and g_i, s_i are minimal gold and silver coins requirements for the i-th road (1 ≤ x_i, y_i ≤ N, 1 ≤ g_i, s_i ≤ 10⁹). Cities are numbered from 1 to N. It is possible that there are more than one road between a pair of cities. It is possible that a road connects the city with itself.

Output

The output should contain the minimal cost of the gift in Olympian tugriks. If there is no gift that satisfies the given requirements output .

Example

Input

3 3
2 1
1 2 10 15
1 2 4 20
1 3 5 1

Output

30

---

　　题目大意是说每条边，带两条权值g,s，给定G和S，设a为所有使用的边中g的最大值，b为所有使用的边中s的最大值，求连通n个城市的最小的(a * G + b * S)

　　首先思考暴力吧，按照第一种权值给边排序，然后Kruskal乱搞，总时间复杂度$O\left(m^{2}\log m\right)$，高兴地发现这么会严重TLE。

　　继续思考，二分第一种权值，然后Kruskal顶上，总时间复杂度$O\left(m\cdot \log^{2}m\right)$，看起来可以过，然而我可以举出不满足二分条件的反例。假如G值特别小，S值特别大，边数远远大于点数，一条边g值比较大，但是s值非常的小，二分的话很可能会忽略这一条边，导致答案是错的。

　　继续思考人生。继续第一种思路，先按照第一种权值进行排序，考虑上一次的最小生成树，每次只会添加一条边，因此有两种方法可以在O(n)的时间内处理完。

1. 在一棵树上添加一条边，会形成一个环，找到这个环，删去其中s值最大的一条边（由于插入的边不能被删去，这个的过程就是树上两点间的简单路径找s值最大的一条边，这个过程可以用LCT做到单次操作$O\left(\log n\right)$）。因为上一个生成树最有n个点，n - 1条边，所以时间复杂度为O(n)
2. 用一个数组维护，然后插入排序，接着做一次最小生成树。时间复杂度仍然是O(n)

　  每次生成完一棵树就更新答案就行了。

　　贡献一堆WA，ans的初值不能设小了，至少(1 << 61)吧！

Code

 /**
  * CodeForces
  * Problem#76A
  * Accepted
  * Time:248ms
  * Memory:2820k
  */
 #include<iostream>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cctype>
 #include<cmath>
 #include<ctime>
 #include<map>
 #include<stack>
 #include<set>
 #include<queue>
 #include<vector>
 #ifndef WIN32
 #define AUTO "%lld"
 #else
 #define AUTO "%I64d"
 #endif
 using namespace std;
 typedef bool boolean;
 #define inf 0xfffffff
 #define smin(a, b) (a) = min((a), (b))
 #define smax(a, b) (a) = max((a), (b))
 template<typename T>
 inline boolean readInteger(T& u) {
     char x;
     int aFlag = ;
     while(!isdigit((x = getchar())) && x != '-' && x != -);
     if(x == -)    {
         ungetc(x, stdin);
         return false;
     }
     if(x == '-') {
         aFlag = -;
         x = getchar();
     }
     for(u = x - ''; isdigit((x = getchar())); u = u *  + x - '');
     u *= aFlag;
     ungetc(x, stdin);
     return true;
 }

 typedef class union_found{
     public:
         int *f;
         int points;
         union_found():f(NULL), points() {}
         union_found(int points):points(points) {
             f = new int[(const int)(points + )];
         }
         int find(int x) {
             if(f[x] != x)    return f[x] = find(f[x]);
             return f[x];
         }
         void unit(int fa, int so) {
             int ffa = find(fa);
             int fso = find(so);
             f[fso] = ffa;
         }
         boolean connected(int a, int b) {
             return find(a) == find(b);
         }
         void clear() {
             for(int i = ; i <= points; i++)
                 f[i] = i;
         }
 }union_found;

 typedef class Edge {
     public:
         int from;
         int end;
         int g;
         int s;
         Edge(int from = , int end = , int g = , int s = ):from(from), end(end), g(g), s(s) {    }
 }Edge;

 int n, m;
 long long G, S;
 Edge* edges;

 inline void init() {
     readInteger(n);
     readInteger(m);
     readInteger(G);
     readInteger(S);
     edges = new Edge[(const int)(m + )];
     for(int i = ; i <= m; i++) {
         readInteger(edges[i].from);
         readInteger(edges[i].end);
         readInteger(edges[i].g);
         readInteger(edges[i].s);
     }
 }

 boolean cmp(const Edge& a, const Edge& b) {
     if(a.g != b.g)    return a.g < b.g;
     return a.s < b.s;
 }

 int top = ;
 Edge *x;
 union_found uf;
 long long g0 = , s0 = ;
 long long res = (1LL << );
 inline void solve() {
     x = new Edge[(const int)(n + )];
     sort(edges + , edges + m + , cmp);
     uf = union_found(n);
     for(int i = ; i <= m; i++) {
         uf.clear();
         x[++top] = edges[i];
         for(int j = top; j > ; j--)
             if(x[j].s < x[j - ].s)
                 swap(x[j], x[j - ]);
         g0 = , s0 = ;
         int fin = ;
         for(int j = ; j <= top; j++) {
             if(!uf.connected(x[j].from, x[j].end)) {
                 x[++fin] = x[j];
                 smax(g0, (long long)x[j].g);
                 smax(s0, (long long)x[j].s);
                 uf.unit(x[j].from, x[j].end);
                 if(fin == n - )    break;
             }
         }
         if(fin == n - )
             smin(res, g0 * G + s0 * S);
         top = fin;
     }
     if(res == (1LL << ))
         printf("-1\n");
     else printf(AUTO"\n", res);
 }

 int main() {
     init();
     solve();
     return ;
 }