上岸算法 I LeetCode Weekly Contest 244解题报告

No.1 重新分配字符使所有字符串都相等

解题思路

统计每个字母的个数，判断是否能被字符串的个数整除即可。

代码展示

public class MyActivity extends AppCompatActivity {
@Override  //override the function
    protected void onCreate(@Nullable Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       try {
            OkhttpManager.getInstance().setTrustrCertificates(getAssets().open("mycer.cer");
            OkHttpClient mOkhttpClient= OkhttpManager.getInstance().build();
        } catch (IOException e) {
            e.printStackTrace();
        }
}

No.2 可移除字符的最大数目

解题思路

二分法。对于给定的删除个数，可以 O(N) 地判断删除这些元素后，p 是否 s 的子序列。

代码展示

class Solution {
    public int maximumRemovals(String s, String p, int[] removable) {
        int l = 0, r = removable.length;
        while (l + 1 < r) {
            int mid = (l + r) / 2;
            if (check(s, p, removable, mid)) {
                l = mid;
            } else {
                r = mid;
            }
        }
        return check(s, p, removable, r) ? r : l;
    }

    private boolean check(String s, String p, int[] removable, int cnt) {
        Set<Integer> remove = new HashSet<>();
        for (int i = 0; i < cnt; i++) {
            remove.add(removable[i]);
        }
        int j = 0;
        for (int i = 0; i < s.length() && j < p.length(); i++) {
            if (remove.contains(i)) {
                continue;
            }
            if (s.charAt(i) == p.charAt(j)) {
                j++;
            }
        }
        return j == p.length();
    }
}

No.3 合并若干三元组以形成目标三元组

解题思路

枚举一遍即可，取最大值。

代码展示

class Solution {
    public boolean mergeTriplets(int[][] triplets, int[] target) {
        int[] state = new int[3];
        for (var triplet : triplets) {
            if (triplet[0] <= target[0] && triplet[1] <= target[1] && triplet[2] <= target[2]) {
                state[0] = Math.max(state[0], triplet[0]);
                state[1] = Math.max(state[1], triplet[1]);
                state[2] = Math.max(state[2], triplet[2]);
            }
        }
        return Arrays.equals(state, target);
    }
}

No.4 最佳运动员的比拼回合

解题思路

暴力枚举 + 状态压缩。

我们只需记录 firstPlayer 和 secondPlayer 的位置，枚举所有可能的胜负情况。

代码展示

class Solution {
    public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
        int t = n, round = 0;
        int min = -1, max = -1;
        TreeSet<Pair> states = new TreeSet<>();
        states.add(new Pair(firstPlayer, secondPlayer));
        while (!states.isEmpty()) {
            round++;
            TreeSet<Pair> newStates = new TreeSet<>();
            int newT = (t + 1) / 2;
            for (var state : states) {
                int l = state.first;
                int r = state.second;
                if (l + r == t + 1) {
                    min = min < 0 ? round : min;
                    max = round;
                    continue;
                }
                int len = t / 2;
                for (int i = 0; i < (1 << len); i++) {
                    TreeSet<Integer> rem = new TreeSet<>();
                    for (int j = 0; j < len; j++) {
                        rem.add((i & (1 << j)) > 0 ? j + 1 : t - j);
                    }
                    if (t % 2 == 1) {
                        rem.add(newT);
                    }
                    if (!rem.contains(l) || !rem.contains(r) || rem.size() != newT) {
                        continue;
                    }
                    int[] seq = rem.stream().mapToInt(elem -> elem.intValue()).toArray();
                    int nl = -1, nr = -1;
                    for (int j = 0; j < newT; j++) {
                        if (seq[j] == l) {
                            nl = j + 1;
                        }
                        if (seq[j] == r) {
                            nr = j + 1;
                        }
                    }
                    newStates.add(new Pair(nl, nr));
                }
            }
            t = newT;
            states = newStates;
        }

        return new int[] { min, max };
    }

    static class Pair implements Comparable<Pair> {

        int first, second;

        Pair(int first, int second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Pair) {
                Pair o = (Pair) obj;
                return first == o.first && second == o.second;
            }
            return false;
        }

        @Override
        public int hashCode() {
            return first & second;
        }

        @Override
        public int compareTo(Pair o) {
            if (first != o.first) {
                return first - o.first;
            }
            return second - o.second;
        }
    }
}