xc编程题

题目一

题目描述

游游今年就要毕业了，和同学们在携程上定制了日本毕业旅行。愉快的一天行程结束后大家回到了酒店房间，这时候同学们都很口渴，石头剪刀布选出游游去楼下的自动贩卖机给大家买可乐。
贩卖机只支持硬币支付，且收退都只支持10 ，50，100 三种面额。一次购买行为只能出一瓶可乐，且每次购买后总是找零最小枚数的硬币。（例如投入100圆，可乐30圆，则找零50圆一枚，10圆两枚）
游游需要购买的可乐数量是 m，其中手头拥有的 10,50,100 面额硬币的枚数分别是 a,b,c，可乐的价格是x(x是10的倍数)。
如果游游优先使用大面额购买且钱是够的情况下,请计算出需要投入硬币次数？

输入描述

依次输入，
需要可乐的数量为 m
10元的张数为 a
50元的张数为 b
100元的张树为 c
1瓶可乐的价格为 x

输出描述

输出当前金额下需要投入硬币的次数
例如需要购买2瓶可乐，每瓶可乐250圆，手里有100圆3枚，50圆4枚，10圆1枚。
购买第1瓶投递100圆3枚，找50圆
购买第2瓶投递50圆5枚
所以是总共需要操作8次金额投递操作

输入
2
1
4
3
250
输出
8

import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int res;

        int _m;
        _m = Integer.parseInt(in.nextLine().trim());

        int _a;
        _a = Integer.parseInt(in.nextLine().trim());

        int _b;
        _b = Integer.parseInt(in.nextLine().trim());

        int _c;
        _c = Integer.parseInt(in.nextLine().trim());

        int _x;
        _x = Integer.parseInt(in.nextLine().trim());

        res = buyCoke(_m, _a, _b, _c, _x);
        System.out.println(String.valueOf(res));
    }
    
    static int buyCoke(int m, int a, int b, int c, int x) {
        x = x / 10;
        int sum = m * x;
        if (x == 1){
            return sum;
        }
        int aNum = 0;
        int bNum = 0;
        int cNum = 0;
        if (c == 0 && b == 0){
            aNum = sum;
            return aNum;
        }else if (c == 0){
            return bPut(m, x, b);
        }else {
            // x < 10
            if (x <= 10){
                cNum = m;
                if (c >= cNum){
                    return cNum;
                }else {
                    cNum = c;
                    m = m - c;
                    if (x > 5){
                        return c + bPut(m, x, b);
                    }else {
                        b = b + c;
                        return c + bPut(m, x, b);
                    }
                }
            }else {
                //x>10
                int oneXc;
                if (x % 10 == 0){
                    oneXc = x / 10;
                }else {
                    oneXc = x / 10 + 1;
                }
                cNum = oneXc * m;
                if (c >= cNum){
                    return cNum;
                }else {
                    int cNumYU = c % oneXc;
                    if (cNumYU == 0){
                        m = m - c / oneXc;
                        return c + bPut(m, x, b);
                    }else {
                        int need = x - cNumYU;
                        if (need % 5 == 0){
                            int needB = need / 5;
                            if (needB <= b){
                                return c + needB + bPut(m - 1, x , b - needB);
                            }else {
                                sum = m * x - 10 * cNumYU - b * 5;
                                return c + b + sum;
                            }
                        }else {
                            int needB = need / 5 + 1;
                            if (needB <= b){
                                return c + needB + bPut(m - 1, x , b - needB);
                            }else {
                                sum = m * x - 10 * cNumYU - b * 5;
                                return c + b + sum;
                            }
                        }
                    }
                }
            }
        }
    }
    
    private static int bPut(int m, int x, int b){
        int sum = m * x;
        int bNum = 0;
        int aNum = 0;
        if (x > 5){
            int oneXb;
            if (x % 5 == 0){
                oneXb = x / 5;
                bNum = m * oneXb;
            }else {
                oneXb = x / 5 + 1;
                bNum = m * oneXb;
            }
            if (b >= bNum){
                return bNum;
            }else {
                if (b % oneXb == 0){
                    return (m - b / oneXb) * x;
                }else {
                    aNum = (m - b / oneXb) * x - (b - b % oneXb) * 5;
                    return b + aNum;
                }
            }
        }else {
            //x < 5
            if (b >= m){
                bNum = m;
                return bNum;
            }else {
                sum = sum - b * x;
                aNum = sum;
                return b + aNum;
            }
        }
    }
}

题目二

题目描述

正值下班高峰时期，现有可载客司机数2N人，调度中心将调度相关司机服务A、B两个出行高峰区域。
第 i 个司机前往服务A区域可得收入为 income[i][0]，前往服务B区域可得收入为 income[i][1]。
返回将每位司机调度完成服务后，所有司机总可得的最高收入金额，要求每个区域都有 N 位司机服务。

输入描述

10 20
20 40
/#
如上：
第一个司机服务 A 区域，收入为 10元
第一个司机服务 B 区域，收入为 20元
第二个司机服务 A 区域，收入为 20元
第二个司机服务 B 区域，收入为 40元
输入参数以 ‘#’ 结束输入

输出描述

最高总收入为 10 + 40= 50，每个区域都有一半司机服务
参数及相关数据异常请输出：error

样例输入
10 30
100 200
150 50
60 20
#
样例输出
440

提示

最优策略
1 <= income.length <= 100
income.length 为偶数
1 <= income[i][0], income[i][1] <= 1000

public class Main{
    public static void main(String[] args) {
        int count = 1;
        Map<Integer, Integer> map = new HashMap<>();
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()){
            String s = in.nextLine();
            if (s.equals("#")){
                break;
            }
            int[] sal = Arrays.stream(s.split(" ")).mapToInt(Integer::parseInt).toArray();
            map.put(-count, sal[0]);
            map.put(count, sal[1]);
            count++;
        }
        LinkedList<Map.Entry<Integer, Integer>> list = sortColl(map);
        System.out.println(maxCost(list, map));
    }
    private static LinkedList<Map.Entry<Integer, Integer>> sortColl(Map<Integer, Integer> map){
        LinkedList<Map.Entry<Integer, Integer>> list = new LinkedList<>(map.entrySet());
        Collections.sort(list , new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o2.getValue() - o1.getValue();
            }
        });
        return list;
    }
    private static int maxCost(LinkedList<Map.Entry<Integer, Integer>> list, Map<Integer, Integer> map){
        int len = list.size();
        int left = 0;
        int right = 0;
        int maxCost = 0;
        while (left < len / 4 && right < len / 4){
            Map.Entry<Integer, Integer> entry = list.getFirst();
            maxCost = maxCost + entry.getValue();
            int key = entry.getKey();
            if (key < 0){
                left++;
            }else {
                right++;
            }
            map.remove(key);
            map.remove(-key);
            list = sortColl(map);
        }
        while (!map.isEmpty()){
            Map.Entry<Integer, Integer> entry1 = list.getFirst();
            int key = entry1.getKey();
            int value = entry1.getValue();
            if (left < len / 4){
                if (key < 0){
                    maxCost = maxCost + value;
                    map.remove(key);
                    map.remove(-key);
                    list = sortColl(map);
                }else {
                    maxCost = maxCost + map.get(-key);
                    map.remove(key);
                    map.remove(-key);
                    list = sortColl(map);
                }
            }else {
                if (key > 0){
                    maxCost = maxCost + value;
                    map.remove(key);
                    map.remove(-key);
                    list = sortColl(map);
                }else {
                    maxCost = maxCost + map.get( -key);
                    map.remove(key);
                    map.remove(-key);
                    list = sortColl(map);
                }
            }
        }
        return maxCost;
    }
}

以上，所采用的方法为暴力解法，每次都需要更新map和list，大家有更好的解法希望能够指导！