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]);
}