• I


    题目链接
    Long long ago there is a strong tribe living on the earth. They always have wars and eonquer others.
    One day, there is another tribe become their target. The strong tribe has decide to terminate them!!!
    There are m villages in the other tribe. Each village contains a troop with attack power EAttacki
    ,
    and defense power EDefensei
    . Our tribe has n troops to attack the enemy. Each troop also has the
    attack power Attacki
    , and defense power Defensei
    . We can use at most one troop to attack one enemy
    village and a troop can only be used to attack only one enemy village. Even if a troop survives an
    attack, it can’t be used again in another attack.
    The battle between 2 troops are really simple. The troops use their attack power to attack against
    the other troop simultaneously. If a troop’s defense power is less than or equal to the other troop’s
    attack power, it will be destroyed. It’s possible that both troops survive or destroy.
    The main target of our tribe is to destroy all the enemy troops. Also, our tribe would like to have
    most number of troops survive in this war.
    Input
    The first line of the input gives the number of test cases, T. T test cases follow. Each test case start
    with 2 numbers n and m, the number of our troops and the number of enemy villages. n lines follow,
    each with Attacki and Defensei
    , the attack power and defense power of our troops. The next m
    lines describe the enemy troops. Each line consist of EAttacki and EDefensei
    , the attack power and
    defense power of enemy troops
    Output
    For each test ease, output one line containing ‘Case #x: y’, where x is the test case number (starting
    from 1) and y is the max number of survive troops of our tribe. If it‘s impossible to destroy all enemy
    troops, output ‘-1’ instead.
    Limits:
    1 ≤ T ≤ 100,
    1 ≤ n, m ≤ 105
    ,
    1 ≤ Attacki
    , Defensei
    , EAttacki
    , EDefensei ≤ 109
    ,
    Sample Input
    2
    3 2
    5 7
    7 3
    1 2
    4 4
    2 2
    2 1
    3 4
    1 10
    5 6
    Sample Output
    Case #1: 3
    Case #2: -1
    [思路]:显而易见,这题肯定要贪心,如果存在攻击力防御力都大于的情况,那么肯定取最接近怪物的那个英雄
    如果不存在攻击力防御力都大于的情况,那么我们就取防御力最小攻击力比怪物大的情况。那么问题是我们怎么
    维护这个值呢?我的想法是先将怪物的攻击力防御力相反,然后放到怪物跟英雄中排序,然后线段树维护的是防御力
    即这个防御力的英雄的个数,然后只要能查询区间最左边不为0的值对应的点就是我们要选择的英雄

    附上代码

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <vector>
    #include <algorithm>
    using namespace std;
    const int MAXN = 2e5 + 5;
    struct NODE{
        int flag, att, def;//flag - 0 or 1
        //0 - my 1
        friend bool operator<(const NODE &a, const NODE &b){
            return a.att > b.att;
        }
    }arr[MAXN];
    int n, m;
    struct Segtree{
        struct NODE{
            int l, r, num;
        }tree[MAXN << 2];
        void build(int root, int l, int r){
            tree[root].l = l, tree[root].r = r;
            if(l == r) {
                tree[root].num = 0;
                return ;
            }
            int mid = (l + r) >> 1;
            build(root << 1, l, mid);
            build(root << 1 | 1, mid + 1, r);
            tree[root].num = tree[root << 1].num + tree[root << 1 | 1].num;
        }
        void update(int root, int cnt, int val){
            if(tree[root].l == tree[root].r){
                tree[root].num += val;
                return ;
            }
            int mid = (tree[root].l + tree[root].r) >> 1;
            if(cnt <= mid){
                update(root << 1, cnt, val);
            }
            else{
                update(root << 1 | 1, cnt, val);
            }
            tree[root].num = tree[root << 1].num + tree[root << 1 | 1].num;
        }
        int l_query(int root, int l, int r){
            int mid = (tree[root].l + tree[root].r) >> 1;
            if(tree[root].l == tree[root].r && tree[root].num > 0){
                return tree[root].l;
            }
            else if(tree[root].l == tree[root].r && tree[root].num == 0){
                return -1;
            }
            if(l > mid){
                if(tree[root << 1 | 1].num > 0){
                    return l_query(root << 1 | 1, l, r);
                }
                else{
                    return -1;
                }
            }
            else if(r <= mid){
                if(tree[root << 1].num > 0){
                    return l_query(root << 1, l, r);
                }
                else{
                    return -1;
                }
            }
            else{
                int lnum, rnum;
                lnum = rnum = -1;
                if(tree[root << 1].num > 0)
                lnum = l_query(root << 1, l, mid);
                if(tree[root << 1 | 1].num > 0)
                rnum = l_query(root << 1 | 1, mid + 1, r);
                if(lnum == -1 && rnum == -1){
                    return -1;
                }
                else if(lnum == -1){
                    return rnum;
                }
                else if(rnum == -1){
                    return lnum;
                }
                else if(lnum > 0 && rnum > 0){
                    return min(lnum, rnum);
                }
            }
        }
    }seg;
    int main(){
        ios::sync_with_stdio(false);
        cin.tie(0);
        int T, cases = 0;
        cin >> T;
        while(T --){
            vector<int>vec;
            vec.clear();
            cin >> n >> m;
            for(int i = 0; i < n; i ++){
                //scanf("%d%d", &arr[i].att, &arr[i].def);
                cin >> arr[i].att >> arr[i].def;
                arr[i].flag = 0;
                vec.push_back(arr[i].def);
            }
            for(int i = n; i < n + m; i ++){
                cin >> arr[i].att >> arr[i].def;
                arr[i].flag = 1;
                swap(arr[i].att, arr[i].def);
                vec.push_back(arr[i].def);
            }
            sort(arr, arr + n + m);
            sort(vec.begin(), vec.end());
            vec.erase(unique(vec.begin(), vec.end()), vec.end());
            seg.build(1, 1, vec.size() + 5);
            bool f = false;
            int re = 0;
            for(int i = 0; i < n + m; i ++){
                if(arr[i].flag == 1){
                    int x = lower_bound(vec.begin(), vec.end(), arr[i].def) - vec.begin() + 1;
                    int a = seg.l_query(1, x + 1, vec.size() + 1);
                    int b = seg.l_query(1, 1, x);
                    if(a == -1 && b == -1){
                        cout << "Case #" << ++cases <<": " << -1 << endl;
                        f = true;
                        break;
                    }
                    else if(a != -1){
                        seg.update(1, a, -1);
                    }
                    else if(a == -1){
                        re ++;
                        seg.update(1, b, -1);
                    }
                }
                else{
                    int x = lower_bound(vec.begin(), vec.end(), arr[i].def) - vec.begin() + 1;
                    seg.update(1, x, 1);
                }
            }
            if(!f){
                cout << "Case #" << ++cases <<": " << n - re << endl;
            }
        }
        return 0;
    }
    
    
  • 相关阅读:
    raid0
    GitHub 标星 11000+,阿里开源的微服务组件如何连续 10 年扛住双十一大促?
    写给大家看的“不负责任” K8s 入门文档
    快速迁移 Next.js 应用到函数计算
    轻松搭建基于 Serverless 的 Go 应用(Gin、Beego 举例)
    阿里巴巴副总裁肖力:云原生安全下看企业新边界——身份管理
    从零开始入门 K8s | K8s 安全之访问控制
    深度解读!阿里统一应用管理架构升级的教训与实践
    CNCF 2019 年度报告重磅发布 | 云原生生态周报 Vol. 41
    HTML+CSS技术实现网页滑动门效果
  • 原文地址:https://www.cnblogs.com/qq136155330/p/11874711.html
Copyright © 2020-2023  润新知