力扣周赛第208场 - 今日份快乐！

最新推荐文章于 2022-02-04 07:27:46 发布

大萝卜大大大萝卜

最新推荐文章于 2022-02-04 07:27:46 发布

阅读量243

点赞数

分类专栏：刷题

本文链接：https://blog.csdn.net/qq_34648520/article/details/108827572

版权

刷题专栏收录该内容

3 篇文章 0 订阅

订阅专栏

力扣周赛第208场 - 今日份快乐！

今天是具有纪念意义的一天！首次在周赛中做出来了两道题，四舍五入等于三个题吧！因为第三个题在11：57分的时候提交报错了，然后找了一下错误，在12：01提交成功（明明我从IDEA复制代码的时候还是12：00！哼！），结果运行超时了，不过136个测试用例通过了126个~咋这么一说好像也没有多厉害呢…但是要知道之前做周赛都是只做出来一个题啊！最多的时候也就是做出来一个题，第二个题超时，这次做题的时候真真切切看到了这段时间的进步，然后做题的时候思路也很明朗，不管！反正就是开心！嗷！而且提交上去的两个题都是提交一次就通过了哎！平时刷题都很少这么顺利的哈哈哈哈

下面是周赛题目和做法~

5523. 文件夹操作日志搜集器

	public int minOperations(String[] logs) {
        //哎呀这不就是树结构嘛！就是让我咋走我咋走，走到新文件就创建一个节点添加进去就行啦
        if (logs.length == 0) return 0;
        FileNode main = new FileNode("Main", null);
        FileNode curNode = main;
        for (int i = 0; i < logs.length; i++) {
            curNode = moveNode(curNode,logs[i]);
        }

        return goMain(curNode, 0);
    }

    private int goMain(FileNode curNode, int step) {
        if (curNode.father == null) return step;
        return goMain(curNode.father,step+1);
    }

    public FileNode moveNode(FileNode node, String log) {
        if (log.equals("../")) {
            if (node.father != null) {
                return node.father;
            }
            return node;
        }
        if (log.equals("./")) {
            return node;
        }
        return new FileNode(log.substring(0,log.length() - 1),node);
    }

    class FileNode {
        String name;
        List<FileNode> children;
        FileNode father;

        public FileNode(String name, FileNode father) {
            this.name = name;
            this.father = father;
        }
    }

5524. 经营摩天轮的最大利润

嗯就是这个超出时间限制了

	public int minOperationsMaxProfit(int[] customers, int boardingCost, int runningCost) {
        //嗯...超出时间限制了耶
        // 126 / 136 个通过测试用例
        // 你简直是太棒了喂！
        //什么时候利润最大...动态规划？贪心算法？感觉不是很像动态规划呀
        //怎么知道利润在此时最大呢？就是如果盈利就应该工作，如果不盈利就不工作
        //嗷那就把每次拉完客的盈利记录下来，然后获取最大值就行了啊！机智！

        //每次运行，计算出下次的客人即可，然后
        int remaining = 0;
        for (int i = 0; i < customers.length; i++) {
            int curTotal = remaining + customers[i];
            if (curTotal > 4) {
                remaining = curTotal - 4;
                cus.addLast(4);
            } else {
                cus.addLast(curTotal);
            }
        }
        if (remaining > 0) {
            while (remaining > 0) {
                if (remaining > 4) {
                    cus.addLast(4);
                    remaining -= 4;
                } else {
                    cus.addLast(remaining);
                    remaining = 0;
                }
            }
        }
        go(boardingCost, runningCost);

        int amount1 = -1;
        int maxCount = -1;
        if (amount.size() > 0) {
            Iterator<Integer> iterator = amount.iterator();
            for (int i = 0; i < amount.size(); i++) {
                Integer next = iterator.next();
                if (next > amount1) {
                    amount1 = next;
                    maxCount = i + 1;
                }
            }
        }

        return amount1 > 0 ? maxCount : -1;
    }

    private void go(int boardingCost, int runningCost) {
        if (cus.size() <= 0) return;
        Integer count = cus.pop();
        int curAmount = count * boardingCost - runningCost;
        Integer last = 0;
        if (amount.size() > 0) {
            last = amount.getLast();
        }
        amount.addLast(curAmount + last);
        go(boardingCost,runningCost);
    }
    LinkedList<Integer> cus = new LinkedList<>();

    LinkedList<Integer> amount = new LinkedList<>();

5525. 皇位继承顺序

	class ThroneInheritance {
        Person king;
        HashMap<String, Person> map = new HashMap<>();

        class Person {
            String name;
            List<Person> children = new LinkedList<>();
            boolean living = true;

            public Person(String name) {
                this.name = name;
                map.put(name,this);
            }
        }
        //当前King
        //King的后代以及King的后代的后代，即有一个人这样的节点

        public ThroneInheritance(String kingName) {
            king = new Person(kingName);
        }

        public void birth(String parentName, String childName) {
            Person parent = map.get(parentName);
            Person child = new Person(childName);
            parent.children.add(child);
        }

        public void death(String name) {
            Person person = map.get(name);
            person.living = false;
        }

        public List<String> getInheritanceOrder() {
            List<String> list = new LinkedList<>();
            return getInheritanceOrder(map.get("king"),list);
        }

        public List<String> getInheritanceOrder(Person parent, List<String> order) {
            if (parent.living) order.add(parent.name);
            if (parent.children != null && parent.children.size() > 0) {
                for (Person child : parent.children) {
                    getInheritanceOrder(child, order);
                }
            }
            return order;
        }
    }