Contest 155

2019-09-27 22:39:24

总体感受：这次比赛心态不够好，最后导致没有很好的完成比赛。

注意点：

1）保持心态稳定，是情商的体现；

2）hard题的覆盖还是明显不够；

• 1201. Ugly Number III

问题描述：

问题求解：

本体中的数据规模已经决定了使用O(n)的解法是肯定会超时的。那么自然而然就是使用二分查找了。

这里有个地方需要注意的是数字超过limit，需要转成long进行计算。

另外，二分以后一律采用模版lower_bound计算。

    public int nthUglyNumber(int n, int a, int b, int c) {
        int l = 0;
        int r = (int)(2 * 1e9);
        while (r - l > 1) {
            int mid = l + (r - l) / 2;
            int num = get_cnt(mid, a, b, c);
            if (num >= n) r = mid;
            else l = mid;
        }
        return r;
    }

    private long gcd(long x, long y) {
        return y == 0 ? x : gcd(y, x % y);
    }

    private long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    private int get_cnt(long n, long a, long b, long c) {
        return (int)(n / a + n / b + n / c - n / lcm(a, b) - n / lcm(a, c) -  n / lcm(b, c) + n / lcm(a, lcm(b, c)));
    }

• 1202. Smallest String With Swaps

问题描述：

问题求解：

本题一看就知道是并查集可以解决的，但是当时卡在了如何将一个组内的数字回填回去。

其实，很简单，就是将idx也记录下来最后将组内的字符串排序后按照排序的idx回填回去就好了。

当然，也是可以使用dfs解决的。

public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
        int n = s.length();
        char[] res = new char[n];
        List<Integer>[] g = new List[n];
        for (int i = 0; i < n; i++) {
            g[i] = new ArrayList<>();
        }
        for (List<Integer> pair : pairs) {
            int u = pair.get(0);
            int v = pair.get(1);
            g[u].add(v);
            g[v].add(u);
        }
        List<Integer> idxs = new ArrayList<>();
        StringBuffer sb = new StringBuffer();
        Set<Integer> seen = new HashSet<>();
        for (int i = 0; i < n; i++) {
            if (seen.contains(i)) continue;
            idxs.clear();
            sb.setLength(0);
            dfs(g, s, i, idxs, sb, seen);
            char[] collect = sb.toString().toCharArray();
            Collections.sort(idxs);
            Arrays.sort(collect);
            for (int j = 0; j < idxs.size(); j++) {
                res[idxs.get(j)] = collect[j];
            }
        }
        return new String(res);
    }

    private void dfs(List<Integer>[] g, String s, int curr, List<Integer> idxs, StringBuffer sb, Set<Integer> seen) {
        if (seen.contains(curr)) return;
        seen.add(curr);
        idxs.add(curr);
        sb.append(s.charAt(curr));
        for (int v : g[curr]) {
            dfs(g, s, v, idxs, sb, seen);
        }
    }