第 208 场力扣周赛题解

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

思路：直接模拟题意即可，没有任何坑点。

class Solution {
    public int minOperations(String[] logs) {

        int station = 0;
        int n = logs.length;

        for (int i = 0; i < n; i++) {
            if (change(logs[i]) == 0) {
                if (station == 0)
                    continue;
                else
                    station--;
            } else if (change(logs[i]) == 1)
                continue;
            else
                station++;
        }

        return station;
    }

    private int change(String s) {
        int n = s.length();
        if (n == 3 && s.charAt(0) == '.' && s.charAt(1) == '.') return 0;
        if (n == 2 && s.charAt(0) == '.') return 1;
        return 2;
    }
}

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

思路：计算在所有游客登轮船的每一轮的花费，从中找取最大值即可。

class Solution {
    public int minOperationsMaxProfit(int[] customers, int boardingCost, int runningCost) {

        int ans = -1, sum = 0, now = 0, res = -1;
        int n = customers.length;
        for (int i = 0; i < n; i++) {
            now += customers[i];
            int num = Math.min(4, now);
            sum += num * boardingCost;
            sum -= runningCost;
            //System.out.println(ans+" "+num * boardingCost+" "+runningCost);
            if (sum > ans) {
                ans = sum;
                res = i + 1;
            }
            now -= num;
        }
        int p = n;
        //System.out.println(now);
        while (now > 0) {
            int num = Math.min(4, now);
            sum += num * boardingCost;
            sum -= runningCost;
            if (sum > ans) {
                ans = sum;
                res = p + 1;
            }
            now -= num;
            p++;
        }

        //System.out.println(ans);

        return res;

    }
}

5525. 皇位继承顺序

思路：感觉这道题就是单纯的考察数据结构的运用，我主要采用了三个map解决该题：

idToName:存储时间戳到名字的映射。

nameToId：名字到时间戳的映射。

nameToChild：名字与孩子时间戳的映射（由于孩子是按时间出生的，所以刚还其list是有序的）

class ThroneInheritance {

    private int time;
    private Set<Integer> st;
    private List<String> list;
    private Map<String, Integer> nameToId;
    private Map<Integer, String> idToName;
    private Map<String, List<Integer>> nameToChild;

    public ThroneInheritance(String kingName) {
        time = 0;
        st = new HashSet<>();
        nameToId = new HashMap<>();
        idToName = new HashMap<>();
        nameToChild = new HashMap<>();
        idToName.put(time, kingName);
        nameToId.put(kingName, time++);
        nameToChild.put(kingName, new ArrayList<>());
    }

    public void birth(String parentName, String childName) {
        idToName.put(time, childName);
        nameToId.put(childName, time++);
        nameToChild.get(parentName).add(time - 1);
        nameToChild.put(childName, new ArrayList<>());
    }

    public void death(String name) {
        if (nameToId.containsKey(name))
            st.add(nameToId.get(name));
    }

    public List<String> getInheritanceOrder() {
        list = new ArrayList<>();
        dfs(idToName.get(0));
        return list;
    }

    private void dfs(String s) {
        if (!st.contains(nameToId.get(s)))
            list.add(s);
        for (int i = 0; i < nameToChild.get(s).size(); i++) {
            String nxt = idToName.get(nameToChild.get(s).get(i));
            dfs(nxt);
        }
    }
}

5526. 最多可达成的换楼请求数目

思路：暴力选择哪几个请求，并判断是否合法即可。

class Solution {
    public int maximumRequests(int n, int[][] requests) {

        int ans = 0;
        int m = requests.length;
        int[] ingree = new int[n];
        int[] outgree = new int[n];

        for (int i = 1; i < (1 << m); i++) {
            int num = 0;
            Arrays.fill(ingree, 0);
            Arrays.fill(outgree, 0);
            for (int j = 0; j < m; j++) {
                if ((i & (1 << j)) != 0) {
                    num++;
                    outgree[requests[j][0]]++;
                    ingree[requests[j][1]]++;
                }
            }
            boolean flag = true;
            for (int j = 0; j < n; j++) {
                if (ingree[j] != outgree[j]) {
                    flag = false;
                    break;
                }
            }
            if (flag)
                ans = Math.max(ans, num);
        }

        return ans;
    }
}