ecjtu-summer training #11

A - Fence Repair

Farmer John wants to repair a small length of the fence around the pasture. He measures the fence and finds that he needs N (1 ≤ N ≤ 20,000) planks of wood, each having some integer length L_i (1 ≤ L_i ≤ 50,000) units. He then purchases a single long board just long enough to saw into the N planks (i.e., whose length is the sum of the lengths L_i). FJ is ignoring the "kerf", the extra length lost to sawdust when a sawcut is made; you should ignore it, too.

FJ sadly realizes that he doesn't own a saw with which to cut the wood, so he mosies over to Farmer Don's Farm with this long board and politely asks if he may borrow a saw.

Farmer Don, a closet capitalist, doesn't lend FJ a saw but instead offers to charge Farmer John for each of the N-1 cuts in the plank. The charge to cut a piece of wood is exactly equal to its length. Cutting a plank of length 21 costs 21 cents.

Farmer Don then lets Farmer John decide the order and locations to cut the plank. Help Farmer John determine the minimum amount of money he can spend to create the N planks. FJ knows that he can cut the board in various different orders which will result in different charges since the resulting intermediate planks are of different lengths.

Input

Line 1: One integer N, the number of planks
Lines 2.. N+1: Each line contains a single integer describing the length of a needed plank

Output

Line 1: One integer: the minimum amount of money he must spend to make N-1 cuts

Sample Input

3
8
5
8

Sample Output

34


优先队列，水题。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
#define ll long long
int main(){
    ll n,num;
    priority_queue<ll, vector<ll>, greater<ll> >que;
    cin>>n;
    for(int i = 1; i <= n; i ++)cin>>num,que.push(num);
    if(que.size()==1){
        cout << 0 << endl;
        return 0;
    }
    ll sum = 0;
    while(que.size() != 1){
        ll a = que.top();
        que.pop();
        ll cnt = que.top();
        que.pop();
        ll ans = a+cnt;
        sum+=ans;
        que.push(ans);
    }
    cout << sum << endl;
    return 0;
}

B - A Bug's Life

Description

Background
Professor Hopper is researching the sexual behavior of a rare species of bugs. He assumes that they feature two different genders and that they only interact with bugs of the opposite gender. In his experiment, individual bugs and their interactions were easy to identify, because numbers were printed on their backs.
Problem
Given a list of bug interactions, decide whether the experiment supports his assumption of two genders with no homosexual bugs or if it contains some bug interactions that falsify it.

Input

The first line of the input contains the number of scenarios. Each scenario starts with one line giving the number of bugs (at least one, and up to 2000) and the number of interactions (up to 1000000) separated by a single space. In the following lines, each interaction is given in the form of two distinct bug numbers separated by a single space. Bugs are numbered consecutively starting from one.

Output

The output for every scenario is a line containing "Scenario #i:", where i is the number of the scenario starting at 1, followed by one line saying either "No suspicious bugs found!" if the experiment is consistent with his assumption about the bugs' sexual behavior, or "Suspicious bugs found!" if Professor Hopper's assumption is definitely wrong.

Sample Input

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

Sample Output

Scenario #1:
Suspicious bugs found!

Scenario #2:
No suspicious bugs found!


带权并查集，数组开两倍大小，这样就可以用两个集合了，相对的就是x,y+N,和x+N,y。一个集合就是x,y和x+N,y+N。

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#define ll long long
using namespace std;
const int MAX = 2010;
const int N = 1000010;
int a[MAX], fa[N*2];
int find(int x) {
    return fa[x] = (fa[x] == x) ? x : find(fa[x]);
}
int unite(int x, int y) {
    x = find(x);
    y = find(y);
    if(x < y) fa[y] = x;
    else fa[x] = y;
}
int main() {
    int t, n, m;
    scanf("%d",&t);
    for(int k = 1; k <= t; k ++) {
        scanf("%d%d",&n,&m);
        for(int i = 0; i < N*2; i ++) fa[i] = i;
        bool flag = true;
        for(int i = 1; i <= m; i ++) {
            int x, y;
            scanf("%d%d",&x,&y);
            if(!flag)continue;
            x = find(x),y = find(y);
            if(x == y) flag = false;
            else {
                unite(x,N+y);
                unite(x+N,y);
            }
        }
        if(k!=1)printf("
");
        printf("Scenario #%d:
",k);
        if(flag) printf("No suspicious bugs found!
");
        else printf("Suspicious bugs found!
");
    }
    return 0;
}

C - Jessica's Reading Problem

Jessica's a very lovely girl wooed by lots of boys. Recently she has a problem. The final exam is coming, yet she has spent little time on it. If she wants to pass it, she has to master all ideas included in a very thick text book. The author of that text book, like other authors, is extremely fussy about the ideas, thus some ideas are covered more than once. Jessica think if she managed to read each idea at least once, she can pass the exam. She decides to read only one contiguous part of the book which contains all ideas covered by the entire book. And of course, the sub-book should be as thin as possible.

A very hard-working boy had manually indexed for her each page of Jessica's text-book with what idea each page is about and thus made a big progress for his courtship. Here you come in to save your skin: given the index, help Jessica decide which contiguous part she should read. For convenience, each idea has been coded with an ID, which is a non-negative integer.

Input

The first line of input is an integer P (1 ≤ P ≤ 1000000), which is the number of pages of Jessica's text-book. The second line contains P non-negative integers describing what idea each page is about. The first integer is what the first page is about, the second integer is what the second page is about, and so on. You may assume all integers that appear can fit well in the signed 32-bit integer type.

Output

Output one line: the number of pages of the shortest contiguous part of the book which contains all ideals covered in the book.

Sample Input

5
1 8 8 8 1

Sample Output

2

贪心，先让l和r等于1，然后r++，在[l,r]区间内，如果全部包括了，就从a[l]开始便利只要a[l]出现次数大于1就l++。每次满足保存一个最新值。

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <map>
#include <set>
#define ll long long
using namespace std;
const int MAX = 1000010;
int a[MAX];
map<int,int> mp;
set<int> st;
int main() {
    int p;
    while(scanf("%d",&p) !=EOF) {
        for(int i = 1; i <= p; i ++) {
            scanf("%d",&a[i]);
            st.insert(a[i]);
        }
        int k = st.size();
        st.clear();
        int l = 1, r = 1, minn = MAX*10;
        while(r <= p) {
            st.insert(a[r]);
            mp[a[r]] ++;
            if(st.size() == k) {
                while(mp[a[l]] >= 2) {
                    mp[a[l]]--;l++;
                }
                if(r-l+1 < minn) minn = r-l+1;
            }
            r++;
        }
        printf("%d
",minn);
        st.clear();
        mp.clear();
        memset(a,0,sizeof(a));
    }
    return 0;
}

D - Communication System

Description

We have received an order from Pizoor Communications Inc. for a special communication system. The system consists of several devices. For each device, we are free to choose from several manufacturers. Same devices from two manufacturers differ in their maximum bandwidths and prices.
By overall bandwidth (B) we mean the minimum of the bandwidths of the chosen devices in the communication system and the total price (P) is the sum of the prices of all chosen devices. Our goal is to choose a manufacturer for each device to maximize B/P.

Input

The first line of the input file contains a single integer t (1 ≤ t ≤ 10), the number of test cases, followed by the input data for each test case. Each test case starts with a line containing a single integer n (1 ≤ n ≤ 100), the number of devices in the communication system, followed by n lines in the following format: the i-th line (1 ≤ i ≤ n) starts with mi (1 ≤ mi ≤ 100), the number of manufacturers for the i-th device, followed by mi pairs of positive integers in the same line, each indicating the bandwidth and the price of the device respectively, corresponding to a manufacturer.

Output

Your program should produce a single line for each test case containing a single number which is the maximum possible B/P for the test case. Round the numbers in the output to 3 digits after decimal point.

Sample Input

1 3
3 100 25 150 35 80 25
2 120 80 155 40
2 100 100 120 110

Sample Output

0.649

英语渣渣的我看了大半个小时才看懂。用贪心来做，取每个设备的宽带的最大值，在这些最大值的宽带里取最小的那个当成总宽带，然后遍历全部，让价格加上每个设备的宽带大于总宽带的最小价格。

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#define ll long long
using namespace std;
const double ef = 1e-9;
const int MAX = 11000;
vector<pair<double,double> >vs[MAX];
int main() {
    int t, n, m;
    ios::sync_with_stdio(false);
    cin>>t;
    while(t--) {
        cin>>n;
        int b = 100000;
        for(int i = 1; i <= n; i ++) {
            cin >> m;
            int MM = -1;
            for(int j = 1; j <= m; j ++) {
                double x, y;
                cin >> x >> y;
                if(x > MM) MM = x;
                vs[i].push_back(make_pair(x,y));
            }
            if(MM < b) b = MM;
        }
        double p = 0.0;
        for(int i = 1; i <= n; i ++) {
            double pp = 100000;
            for(int j = 0; j < vs[i].size(); j ++) {
                if(vs[i][j].first >= b){
                    if(pp > vs[i][j].second) pp = vs[i][j].second;
                }
            }
            // cout << pp << endl;
            p += pp;
        }
        printf("%.3f
",b/p);
        //cout << b<< ' ' << p << endl;
        for(int i = 1; i <= n; i ++) vs[i].clear();
    }
    return 0;
}

E - Telephone Lines

Description

Farmer John wants to set up a telephone line at his farm. Unfortunately, the phone company is uncooperative, so he needs to pay for some of the cables required to connect his farm to the phone system.

There are N (1 ≤ N ≤ 1,000) forlorn telephone poles conveniently numbered 1..N that are scattered around Farmer John's property; no cables connect any them. A total of P (1 ≤ P ≤ 10,000) pairs of poles can be connected by a cable; the rest are too far apart.

The i-th cable can connect the two distinct poles A_i and B_i, with length L_i (1 ≤ L_i ≤ 1,000,000) units if used. The input data set never names any {A_i, B_i} pair more than once. Pole 1 is already connected to the phone system, and pole N is at the farm. Poles 1 and N need to be connected by a path of cables; the rest of the poles might be used or might not be used.

As it turns out, the phone company is willing to provide Farmer John with K (0 ≤ K < N) lengths of cable for free. Beyond that he will have to pay a price equal to the length of the longest remaining cable he requires (each pair of poles is connected with a separate cable), or 0 if he does not need any additional cables.

Determine the minimum amount that Farmer John must pay.

Input

* Line 1: Three space-separated integers: N, P, and K
* Lines 2..P+1: Line i+1 contains the three space-separated integers: A_i, B_i, and L_i

Output

* Line 1: A single integer, the minimum amount Farmer John can pay. If it is impossible to connect the farm to the phone company, print -1.

Sample Input

5 7 1
1 2 5
3 1 4
2 4 8
3 2 3
5 2 9
3 4 7
4 5 6

Sample Output

4


英语好渣，比赛时一直没看懂题意，赛后才知道是求每个方案中总长度最大的最小数。
比如第一组数据走1->2->5  分别是5 9k是1 ，9去掉，答案就是5 走1->3->2->5 分别是4 3 9 ，  9去掉答案是4,4比前面的5小，所以最终答案是4.
做法是dijkstra+二分来做。其实就是求最小的m使得从1到n的路径中比m大的数要小于等于k。
用数组的dijkstra会超时，这时就需要用优先队列来做了，因为数组的复杂度是：O（|V|^2）,优先队列的是O(|E|log|V|)。

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <queue>
#define INF 0x3f3f3f3f
#define ll long long
using namespace std;
const int MAX = 1010;
struct Nod {
    int to, cost;
};
typedef pair<int,int> P;
int n,p,k;
vector<Nod> G[MAX];
int d[MAX];
int dij(int s, int x) {
    priority_queue<P, vector<P>, greater<P> > que;
    memset(d,0x3f,sizeof(d));
    d[s] = 0;
    que.push(P(0,s));
    while(!que.empty()) {
        P p = que.top(); que.pop();
        int v = p.second;
        if(d[v] < p.first) continue;
        for(int i = 0; i < G[v].size(); i ++) {
            Nod e = G[v][i];
            int dd = d[v] + (e.cost > x ? 1 : 0);
            if(d[e.to] > dd) {
                d[e.to] = dd;
                que.push(P(d[e.to],e.to));
            }
        }
    }
    return d[n-1];
}
int main() {
    //ios::sync_with_stdio(false);
    while(cin>>n>>p>>k) {
        for(int i = 1; i <= p; i ++) {
            int u, v, w;
            cin >> u >> v >> w;
            --u;--v;
            G[u].push_back((Nod){v,w});
            G[v].push_back((Nod){u,w});
        }
        int l = 0, r = 1000010, cnt = -1;
        while(l <= r) {
            int m = (l+r) >> 1;
            int ans = dij(0,m);
            // printf("%d  %d 
",m,ans);
            if(ans <= k){
                cnt = m;r = m-1;
            }else l = m+1;
        }
        printf("%d
",cnt);
    }
    return 0;
}