贪心算法编程题

1. 扔骰子

题意：
牛妹在和牛牛玩扔骰子，他们的游戏规则有所不同；
每个人可以扔nn次mm面骰子，来获得nn个数
得分为任意选取nn个数中的某些数求和所不能得到的最小的正整数
得分大的人获胜
例如扔骰子33次得到了 11 22 55，那么这个人的得分是44

牛妹想知道这回合她是否能赢
牛妹的n个数存在数组a中，牛牛的n个数存在数组b中
数组下标从0开始

输入：

n,m与数组a，b

输出：
如果牛妹能在这回合胜利则输出HappyHappy，否则输出SadSad

示例1
输入

2,4,[1,2],[1,3]

输出

"Happy"

说明

牛妹能构成 11 22 33，牛妹的得分为4
而牛牛只能构成11 33 44，牛牛的得分为2
故牛妹胜利！

代码：

long long find(int *a, int len)
    {
        long long  result = 0;
        for(int i = 0; i < len; i ++)
            if(result + 1 < a[i])
                return result+1;
            else
                result += a[i];
        return result+1;
    }
    string Throwdice(int n, int m, int* a, int aLen, int* b, int bLen) {
        // sort (first, last)	对容器或普通数组中 [first, last) 范围内的元素进行排序，默认进行升序排序。
        //并且sort函数的头文件是#include <algorithm>。
        sort(a, a+aLen);
        sort(b, b+bLen);
        long long niumei = find(a, aLen);
        long long niuniu = find(b, bLen);
        if(niumei > niuniu)
            return "Happy";
        else
            return "Sad";
    }
};

2. Pokemon

题意：
牛牛是励志成为世界第一宝可梦大师的宝可梦训练家。现在他遇到了一个强劲的野生宝皮卡丘，野生宝皮卡丘的生命值是HP，攻击力是ACK，牛牛召唤的宝可梦是杰尼龟。杰尼龟的生命值是HP2，攻击力是ACK2，除此之外身为训练家还可以给宝可梦吃药让他满血复活(吃药发生在双方发动攻击之前，并且吃药一方不得在本回合发动攻击)。牛牛想知道他最少多少回合才能能打败野生宝皮卡丘？因为皮卡丘会电光一闪，所以皮卡丘总是比杰尼龟先发动攻击。如果牛牛无法战胜野生皮卡丘则返回-1。

示例1
输入

8,3,8,1

输出

14

说明

至少需要14回合战胜野生皮卡丘

示例2
输入

1,1,1,1

输出

-1

说明

皮卡丘先出招就直接打死了杰尼龟，所以无法获胜

代码：

long long Pokemonfight(long long HP, long long ACK, long long HP2, long long ACK2) {
        // write code here
        //杰尼龟一次击败皮卡丘
        if(ACK2 >= HP && HP2 > ACK) return 1;
        //皮卡丘第一次或者在第二次击败杰尼龟，因为第一次无法吃药
        if(HP2 <= 2*ACK) return -1;
        long long ans = 0;
        //杰尼龟打败皮卡丘所需要的战斗次数
        long long attack_round = HP / ACK2;
        if(HP % ACK2 != 0){
            ++attack_round;
        }
        //皮卡丘使得杰尼龟生命值为0的次数 
        long long rest_time = HP2 / ACK - 1;
        long long rest_round = 0;
        if(HP2 % ACK == 0){
            --rest_time;
        }
        //杰尼龟所需要满血复活的次数
        rest_round = (attack_round - 1) / rest_time;
        if((attack_round - 1) % rest_time == 0){
            --rest_round;
        }
        ans = rest_round + attack_round;
        return ans;
    }
};

3. 迷失的括号序列

题意：
牛妹有括号序列brackets，因为过了太久，导致里面有些括号看不清了，所以用??代替，她想知道这个括号序列能不能恢复成合法的括号序列。具体操作是将??改为’(‘或者’)’。brackets只由’?’,’(’,’)'构成。
合法的括号序列的定义：
1.空字符为合法括号序列
2.(+合法括号序列+) 为合法括号序列
3.()+合法括号序列为合法括号序列

示例1
输入

"()?)"

输出

"()()"

说明

把?替换为(即可

代码：

**class Solution {
public:
    /**
     *
     * @param brackets string字符串 brackets
     * @return string字符串
     */
    string MissingBrackets(string brackets) {
        // write code here
        if(brackets.length()%2 == 1) return "Impossible";
        int left = 0, right = 0;
        for(int i = 0; i < brackets.length(); ++i) {
            if(brackets[i] == '(') left++;
            if(brackets[i] == ')') right++;
        }
        if(left > brackets.length() / 2 || right > brackets.length() / 2) return "Impossible";
        int left_bracket = 0;
        for(int i = 0; i < brackets.length(); ++i) {
            if(brackets[i] == '?') {
                if(left < brackets.length()/2) brackets[i] = '(', left++;
                else brackets[i] = ')';
            }
            if(brackets[i] == '(') left_bracket++;
            if(brackets[i] == ')') left_bracket--;
            //说明右括号多了无法构成合法括号
            if(left_bracket < 0) return "Impossible";
        }
        return brackets;
    }
};**

4. 李华的纪念品

李华买纪念品的预算为kk，现给出他心动的纪念品清单：共有nn件，其中每件都各有其价格priceprice，重量weightweight，心动值vv（其中心动值为1~5之间的数值），需要注意的是：在心动值不同的情况下，李华会优先选择心动值大的纪念品；若心动值相同，李华会优先选择比较便宜的纪念品，具体见样例。同时给出李华在保证不累的情况下，最多能拿的物品重量mm。在不超过预算并且保证不累的情况下，李华最多可以带几件纪念品回家？

输入描述
第一行三个整数，为纪念品数量nn，最多能拿的物品重量mm和预算kk。
第二行到第n+1n+1行，分别为每件物品的价格priceprice，重量weightweight，心动值vv。

n<1e5n<1e5
m<100m<100
k<10000k<10000
price<10000price<10000
weight<100weight<100
1<v<51<v<5
输出描述
在不超过预算并且保证不累的情况下，最多能带回家的纪念品件数。

示例1
样例输入

3 10 1000
100 5 3
50 3 2
300 3 3

样例输出

2

说明

选第一件和第三件

算法
(贪心) O(nlog(n))O(nlog(n))
优先选择心动值大的、价格低的、重量轻的

代码：

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

const int N = 1e5 + 10;

int n, m, k;

struct Item {
    int p, w, v;

    bool operator< (const Item &item) const {
        if (v != item.v) return v > item.v;
        else if (p != item.p) return p < item.p;
        else return w < item.w;
    }
} items[N];


int main() {
    cin >> n >> m >> k;

    for (int i = 0; i < n; i ++ )
        cin >> items[i].p >> items[i].w >> items[i].v;

    sort(items, items + n);

    int ret = 0, weight = 0, money = 0;

    for (int i = 0; i < n; i ++ ) {
        auto &t = items[i];
        if (weight + t.w <= m && money + t.p <= k) {
            weight += t.w, money += t.p;
            ret ++ ;
        }
    }

    cout << ret;

    return 0;
}