Contest 154

2019-09-16 17:22:28

总体感受：这次比赛的模版题也太多了吧，两条模版题没有想出来。总的来说，还是自己的刷题量还是严重的不够。

注意点：

1）提升刷题量和覆盖率非常重要；

2）在碰到大数处理的时候，还是会出现一些问题，有两个路径吧，一个是使用long来测试一下；二是使用bigInteger。

• 1191. K-Concatenation Maximum Sum

问题描述：

问题求解：

如果没有repeat操作，本题就是一个典型的dp问题，可以在O(n)内解决。事实上，如果进行了repeat依然可以在O(k * n)解决，但是本题的数据规模非常大，如果直接去计算那么必然会TLE。

这种repeat计算最大子数组和有个经典的解法，叫做 Kadens Algorithm 。使用该算法可以在O(n)的时间复杂度完成求解。

这个算法的核心思路是，如果sum of array > 0，那么中间就可以有k - 2个array，最后前后计算一下prefix和suffix即可；如果sum of array <= 0，那么中间必然不存在一个完整的array，那么最后的解就会出现array和横跨两个array的解中。

当然，本题最恶心的地方不只是这个算法本身，这里还有个大数处理的问题，本题采用的策略是使用long来保存数据，因为long的最长能保存10 ^ 18，本题中不会爆掉。

    public int kConcatenationMaxSum(int[] arr, int k) {
        long mod = (long) (1e9 + 7);
        long max_num = helper(arr);
        if (k == 1) return (int)max_num;
        long sum = 0;
        for (int num : arr) sum += num;
        long suffix = calcsuffix(arr);
        long prefix = calcprefix(arr);
        if (sum > 0) {
            return (int) (Math.max((suffix % mod + prefix % mod + (k - 2) * sum % mod) % mod, max_num));
        }
        else {
            return (int) (Math.max((suffix % mod + prefix % mod) % mod, max_num));
        }
    }

    private long helper(int[] nums) {
        long mod = (int)(1e9 + 7);
        long res = nums[0];
        long dp = nums[0];
        for (int i = 1; i < nums.length; i++) {
            dp = Math.max(nums[i], nums[i] + dp);
            res = Math.max(res, dp);
        }
        return res < 0 ? 0 : res % mod;
    }

    private long calcsuffix(int[] nums) {
        long res = Integer.MIN_VALUE;
        long curSum = 0;
        for (int num : nums) {
            curSum += num;
            res = Math.max(res, curSum);
        }
        return res;
    }

    private long calcprefix(int[] nums) {
        long res = Integer.MIN_VALUE;
        long curSum = 0;
        for (int i = nums.length - 1; i >= 0; i--) {
            curSum += nums[i];
            res = Math.max(res, curSum );
        }
        return res;
    }

• 1192. Critical Connections in a Network

问题描述：

问题求解：

本题也是一条模版题，是一条经典的求割边的问题，该问题有Tarjan算法，可以在O(n + e)的时间复杂度求解。

Tarjan算法的核心思路是维护两个数组discovery[]，low[]。disc[]数组里存放访问节点的时间戳，low[]数组里存放与节点邻接的(不包含父节点)最小时间戳的节点。

每次比较父节点和子节点，如果子节点没有访问到时间戳小的节点，那么这两个节点之间必然有一条割边。

    int timestamp = 1;
    public List<List<Integer>> criticalConnections(int n, List<List<Integer>> connections) {
        int[] disc = new int[n];
        int[] low = new int[n];
        List<List<Integer>> res = new ArrayList<>();
        List<Integer>[] graph = new ArrayList[n];
        for (int i = 0; i < n; i++) graph[i] = new ArrayList<>();
        for (int i = 0; i < connections.size(); i++) {
            int u = connections.get(i).get(0);
            int v = connections.get(i).get(1);
            graph[u].add(v);
            graph[v].add(u);
        }
        Arrays.fill(disc, -1);
        helper(graph, 0, disc, low, -1, res);
        return res;
    }

    private void helper(List<Integer>[] graph, int node, int[] disc, int[] low, int prev, List<List<Integer>> res) {
        disc[node] = timestamp;
        low[node] = timestamp;
        timestamp += 1;
        for (int u : graph[node]) {
            if (u == prev) continue;
            if (disc[u] == -1) {
                helper(graph, u, disc, low, node, res);
                if (low[u] > disc[node]) {
                    res.add(Arrays.asList(u, node));
                }
            }
            low[node] = Math.min(low[node], low[u]);
        }