Codeforces Round #433 题解

原创于 2017-09-24 09:51:07 发布 · 414 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

ACM/ICPC_Codeforences

数据结构_主席树

本文提供了CodeForces 854比赛中的五道题目的详细解答过程，包括Fraction、Maxim Buys an Apartment、Planning、Jury Meeting和Boredom等题目，涉及模拟、贪心算法、动态规划及数据结构等多种算法和技术。

比赛链接：http://codeforces.com/contest/854

A. Fraction

解法：按照题意模拟即可。

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    for(int i=n/2; i>=1; i--){
        if(__gcd(i, n-i) == 1){
            printf("%d %d\n", i,n-i);
            return 0;
        }
    }
    return 0;
}

B. Maxim Buys an Apartment

题意：有n个屋子，其中k个屋子是有人住的，如果第i个屋子有人住，那么第i-1个屋子和第i+1个屋子就是特殊的，方便起见这里我们将特殊屋子的数量记为ans。然后给你n和k，让你输出最小的ans和最大的ans。

解法：如果k和n一样多或者是k为0显然输出0 0，然后就是贪心了，除去特殊情况后，最小全都是1，那么剩下的就是最大值了，当k≤n3时，最大值就是k×2，当k>n3时，最大值就是n−k，化简一下发现可以直接取min(n−k,k×2)。

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n, k, mx, mi;
    cin >> n >> k;
    if(k == 0 || k == n){
        printf("0 0\n");
        return 0;
    }
    else{
        mi = 1;
        mx = min(n-k, k*2);
    }
    cout << mi << " " << mx << endl;
    return 0;
}

C. Planning

题意：n个人分成两派, 问最后那一派获得胜利, 规则是这样的, 首先从1遍历到n 如果出现D, 那么他可以什么都不做, 也可以让某一个R退出比赛, 一轮过后假设还剩k个人 , 继续从1遍历到k.

解法:很显然要采取贪心的策略, 如果是D那么他肯定会使他右边离他最近的R推出比赛, 这样才能达到最策略, 右边没有了则从最左边开始取.直接模拟了

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
priority_queue <pair<int, int> > q;
int res[300005];
int main()
{
    int n, k;
    cin >> n >> k;
    for(int i=1; i<=k; i++){
        int x;
        scanf("%d", &x);
        q.push(make_pair(x, i));
    }
    LL ans = 0;
    for(int i=k+1; i<=n+k; i++){
        if(i<=n){
            int x;
            scanf("%d", &x);
            q.push(make_pair(x,i));
        }
        pair <int,int> a = q.top();
        q.pop();
        ans += 1LL*(i-a.second)*a.first;
        res[a.second] = i;
    }
    cout << ans << endl;
    for(int i=1; i<=n; i++) cout << res[i] << " ";
    cout << endl;
    return 0;
}

D. Jury Meeting
题意：有n个地点,m次航班，每次航班有4个信息，起飞日期di、出发地fi、目的地ti、花费ci，起飞和出发地至少有一个是地点0。现在n个地点，每个地点有一个人，他们要到地点0，当所有人都到达的时候，一起待k天，然后再分别回到n个地点。问说最小的花费是多少，如果达不到这个要求输出-1。
解法：我们可以使用 dp 两个方向进行dp1[i] 表示当 i 时间是从所有点出发到 0 点的最小花费 ,dp2[i] 表示 i 时间时从 0点到所有点的花费最小值这样我们就可以dp了然后就是如果不能到所有点我们就不更新如果可以到所有点我们就进行更新dp的最小值过程中保留一个 sum 记录最小花费即可。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 1e6+7;
struct node{
    int from, to, cost;
    node(){}
    node(int from, int to, int cost):from(from),to(to),cost(cost){}
};
vector <node> v[maxn];
int n, m, k;
LL dp1[maxn], dp2[maxn];//dp1[i]表示当i时间是从所有点出发到0的最小花费,dp2[i]表示当i时间是从0出发到所有点的最小花费
LL mi1[maxn], mi2[maxn];
bool vis[maxn];
LL min(LL x, LL y){
    if(x == -1) return y;
    if(y == -1) return x;
    if(x > y) return y;
    else return x;
}
int main()
{
    scanf("%d %d %d", &n,&m,&k);
    memset(dp1, -1, sizeof(dp1));
    memset(dp2, -1, sizeof(dp2));
    for(int i=0; i<m; i++){
        int t, x, y, z;
        scanf("%d %d %d %d", &t,&x,&y,&z);
        v[t].push_back(node(x,y,z));
    }
    memset(vis, 0, sizeof(vis));
    LL sum = 0;
    int cnt = 0;
    for(int i=1; i<maxn; i++){
        for(int j=0; j<v[i].size(); j++){
            node x = v[i][j];
            if(x.from){
                if(!vis[x.from]){
                    vis[x.from] = 1;
                    mi1[x.from] = x.cost;
                    cnt++;
                    sum += x.cost;
                }
                else{
                    if(mi1[x.from] > x.cost){
                        sum -= mi1[x.from];
                        mi1[x.from] = x.cost;
                        sum += x.cost;
                    }
                }
            }
        }
        if(cnt == n) dp1[i] = min(dp1[i], sum);
    }
    //
    memset(vis, 0, sizeof(vis));
    sum = 0;
    cnt = 0;
    for(int i=maxn-1; i>0; i--){
        for(int j=0; j<v[i].size(); j++){
            node x = v[i][j];
            if(x.to){
                if(!vis[x.to]){
                    vis[x.to] = 1;
                    mi2[x.to] = x.cost;
                    cnt++;
                    sum += x.cost;
                }
                else{
                    if(mi2[x.to] > x.cost){
                        sum -= mi2[x.to];
                        mi2[x.to] = x.cost;
                        sum += x.cost;
                    }
                }
            }
        }
        if(cnt == n){
            dp2[i] = min(dp2[i], sum);
        }
    }
    //
    LL ans = -1;
    for(int i=1; i<maxn; i++){
        int j = i+k+1;
        if(j >= maxn) continue;
        if(dp1[i]!=-1 && dp2[j]!=-1){
            ans = min(ans, dp1[i]+dp2[j]);
        }
    }
    printf("%lld\n", ans);
    return 0;
}

E. Boredom

解法：查二维平面里有多少点，按行维护主席树，然后每次查一个区间，做差就可以求出二维平面里的点了，然后剩下的容斥一哈就行了，具体是把周围一圈剪掉，然后把四个角加上就好了，这就是个简单容斥。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+5;
const int maxm = maxn*40;
typedef long long LL;
int n, q, tot, a[maxn];
int T[maxn], lson[maxm], rson[maxm], c[maxm];
int build(int l, int r){
    int root = tot++;
    c[root] = 0;
    if(l != r){
        int mid=(l+r)/2;
        lson[root] = build(l, mid);
        rson[root] = build(mid+1, r);
    }
    return root;
}
int update(int root, int pos, int val){
    int newroot = tot++, tmp = newroot;
    c[newroot] = c[root]+val;
    int l=1, r=n;
    while(l<r){
        int mid=(l+r)/2;
        if(pos<=mid){
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        }
        else{
            rson[newroot]= tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid+1;
        }
        c[newroot] = c[root]+val;
    }
    return tmp;
}
int query(int root, int L, int R, int l, int r){
    if(L > R) return 0;
    if(L <= l && r <= R) return c[root];
    int mid = (l+r)/2;
    int ret = 0;
    if(L <= mid) ret += query(lson[root], L, R, l, mid);
    if(mid < R) ret += query(rson[root], L, R, mid+1, r);
    return ret;
}
int query2(int l, int r, int L, int R){
    if(l>r) return 0;
    return query(T[r],L,R,1,n)-query(T[l-1],L,R,1,n);
}
LL cal(LL x){
    return x*(x-1)/2;
}
int main()
{
    tot = 0;
    scanf("%d %d", &n,&q);
    T[0] = build(1, n);
    for(int i=1; i<=n; i++){
        scanf("%d", &a[i]);
        T[i] = update(T[i-1], a[i], 1);
    }
    while(q--){
        int l, r, d, u;
        LL cnt = 0, ans = 0;
        scanf("%d %d %d %d", &l,&r,&d,&u);
        cnt = query2(1, l-1, 1, n);
        ans -= cal(cnt);
        cnt = query2(d+1, n, 1, n);
        ans -= cal(cnt);
        cnt = query2(1, n, 1, r-1);
        ans -= cal(cnt);
        cnt = query2(1, n, u+1, n);
        ans -= cal(cnt);
        cnt = query2(1, l-1, 1, r-1);
        ans += cal(cnt);
        cnt = query2(1, l-1, u+1, n);
        ans += cal(cnt);
        cnt = query2(d+1, n, 1, r-1);
        ans += cal(cnt);
        cnt = query2(d+1, n, u+1, n);
        ans += cal(cnt);
        cnt = cal(n);
        ans += cnt;
        printf("%lld\n", ans);
    }
    return 0;
}