PTA甲 1054~1057题解

最新推荐文章于 2024-11-05 17:16:24 发布

Oops!506

最新推荐文章于 2024-11-05 17:16:24 发布

阅读量94

点赞数

文章标签： c++ 算法数据结构

本文链接：https://blog.csdn.net/weixin_63448617/article/details/130568313

版权

1054 The Dominant Color

统计哪个颜色最多直接计数

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

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    map<int, int> mp;
    int n, m; cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int t; cin >> t;
            mp[t]++;
        }
    }
    
    int c, cnt = -1;
    for (const auto& [a, b] : mp) {
        if (b > cnt) {
            cnt = b;
            c = a;
        }
    }
    
    cout << c << '\n';

    return 0;
}

1055 The World’s Richest

转化为多路归并
问题转化为：一段年龄段内的前K大的人
关键点是年龄范围是 $[1, 200]$ ，以及K非常小。
可以把人按升序一个个插入到对应的年龄所在的桶，那么最终会得到200个桶（由桶顶向下递减）。
可以这样想：假如此次查询的年龄区间是 $[10, 20]$ ，那最大的，一定是 $[10, 20]$ 这11个桶的某个桶顶部最大，然后从顶部删掉，往复直至选够K个，其实就是归并排序（只不过归并排序是2个桶）。
所以 $M$ 次查询时间复杂度 $\cdot 200)$ ，再加上预处理桶排序的时间 $O(N\log{N})$ 。
易错的地方是先按钱再按年龄再按名字…

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

struct Person {
    int age, money;
    string name;
    explicit Person(int _a, int _m, const string& _n): age(_a), money(_m), name(_n)
    {}
};

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    int n, m; cin >> n >> m;
    vector<Person> v;
    for (int i = 0; i < n; i++) {
        string name; int age, money; cin >> name >> age >> money;
        v.emplace_back(age, money, name);
    }
    
    sort(v.begin(), v.end(), [&](const Person& lhs, const Person& rhs) -> bool {
        if (lhs.money == rhs.money) {
           if (lhs.age == rhs.age) return lhs.name > rhs.name;
           return lhs.age > rhs.age;
        }
        return lhs.money < rhs.money; 
    });
    
    vector<vector<Person>> bucket(210);
    for (const auto& p : v) {
        bucket[p.age].push_back(p);
    }
    
    for (int _ = 1; _ <= m; _++) {
        cout << "Case #" << _ << ":\n";
        int cnt, mi, mx; cin >> cnt >> mi >> mx;
        if (mi > mx) swap(mi, mx);
        if (cnt == 0) {
            cout << "None\n";
            continue;
        }
        vector<int> idx(210);
        
        for (int i = mi; i <= mx; i++) {
            idx[i] = bucket[i].size();
        }

        int sum = 0;

        for (;;) {
            int money = INT_MIN, id = INT_MAX;
            string name = "";
            // 多路归并
            for (int i = mx; i >= mi; i--) {
                if (idx[i] == 0) continue;
                const auto& p = bucket[i][idx[i] - 1];
                if (p.money > money) {
                    money = p.money;
                    name = p.name;
                    id = i;
                    continue;
                }
                if (p.money == money) {
                    name = p.name;
                    id = i;
                    continue;
                }
            }
            
            if (id == INT_MAX) break;
            idx[id]--;
            cout << name << ' ' << id << ' ' << money << '\n';
            if (++sum == cnt) break;
        }
        
        if (sum == 0) {
            cout << "None\n";
        }
    }

    return 0;
}

1056 Mice and Rice

题目很难读懂只要解释一下样例就懂了
初始分组[6 0 8] [7 10 5] [9 1 4] [2 3] 第一轮进行完只剩4个人了，第二轮3人+1人两组，第三轮就剩俩人了，再进行一轮就够了。
用两个队列模拟，统计每轮的淘汰者，然后再倒着编号就行了

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

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    int n, sz; cin >> n >> sz;
    vector<int> weight(n);
    queue<int> q[2];
    for (int i = 0; i < n; i++) cin >> weight[i];
    for (int i = 0; i < n; i++) {
        int x; cin >> x;
        q[0].push(x);
    }

    vector<vector<int>> res(1010);
    int turn = 0, idx = 0;
    while (true) {
        int mx = -1, id = -1;

        vector<int> loser;
        while (!q[turn].empty()) {
            auto x = q[turn].front();
            q[turn].pop();
            if (weight[x] > mx) {
                mx = weight[x];
                id = x;
            }
            loser.push_back(x);
            // 小组已满
            if (loser.size() == sz || q[turn].empty()) {
                // 已经出局
                for (int y : loser) {
                    if (y != id) res[idx].push_back(y);
                }
                // 进入下一局
                q[turn ^ 1].push(id);
                loser.clear();

                mx = id = -1;
            }
        }

        ++idx;
        turn ^= 1;
        if (q[turn].size() + q[turn ^ 1].size() == 1) break;
    }

    int winner = q[0].empty() ? q[1].front() : q[0].front();
    int rk = 1;
    vector<int> rank(n);
    rank[winner] = rk++;

    for (int i = idx - 1; i >= 0; i--) {
        for (int x : res[i]) {
            rank[x] = rk;
        }
        rk += res[i].size();
    }

    cout << rank[0];
    for (int i = 1; i < n; i++) cout << ' ' << rank[i];
    cout << '\n';

    return 0;
}

1057 Stack

题目可能会读错 PeekMedian是中位数不是中间位置的数…
树状数组可以统计比x小的数有几个，很显然随着x的增加，比x小的数是越来越多的，我们只要找第一个 $\ge$ target的数就可以了，是一个左边界二分。
$U = 10^5$
时间复杂度 $O(N\cdot \log{U} \cdot \log{U} )$

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

static constexpr int N = 1e5 + 10;

template<typename T>
class Fenwick {
public:
    explicit Fenwick(int _n): n(_n) {
        tree.resize(n + 10);
    }

    /**
     * @param index 注意 原数组下标从1~n
     */
    void add(int index, T value) {
        assert(index >= 1 && index <= n + 1);
        for (int i = index; i <= n; i += low_bit(i)) {
            tree[i] += value;
        }
    }

    /**
     * @return  求 原数组下标范围 [1, index] 的区间和
     */
    T sum(int index) {
        assert(index >= 0 && index <= n);
        T res = 0;
        for (int i = index; i; i -= low_bit(i)) {
            res += tree[i];
        }
        return res;
    }
private:
    static inline int low_bit(int x) {
        return x & -x;
    }

    vector<T> tree;
    int n;
};


int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);

    int m; cin >> m;
    stack<int> stk;
    Fenwick<int> fenwick(N);
    
    while (m--) {
        string op; cin >> op;
        if (op == "Pop") {
            if (stk.empty()) cout << "Invalid\n";
            else {
                fenwick.add(stk.top(), -1);
                cout << stk.top() << '\n';
                stk.pop();
            }
        } else if (op == "Push") {
            int x; cin >> x;
            fenwick.add(x, 1);
            stk.push(x);
        } else {
            auto sz = stk.size();
            if (sz == 0) {
                cout << "Invalid\n";
                continue;
            }
            int target = (sz & 1) ? (sz / 2 + 1) : (sz / 2);
            // 左边界二分
            int l = 1, r = N;
            while (l < r) {
                int mid = l + r >> 1;
                if (fenwick.sum(mid) >= target) r = mid;
                else l = mid + 1;
            }
            cout << r << '\n';
        }
    }

    return 0;
}