Skip to content

Commit 0295b26

Browse files
ZLBerZLBer
committed
weekly contest 323
1 parent b1536d3 commit 0295b26

File tree

3 files changed

+334
-2
lines changed

3 files changed

+334
-2
lines changed

‎README.md

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ Record leetcode contest and ideas every week, and encourage yourself to think mo
55
leetcode url: <https://leetcode.cn/u/cctest/>
66

77

8+
* 🐎️ [weekly contest 323](src/main/java/weekly/wk323.java) 排序 | 哈希 | 模拟 | 最小堆、Dijkstra最短路径
89
* 🐎️ [weekly contest 322](src/main/java/weekly/wk322.java) 遍历 | 排序 | BFS | 二分图+BFS
910
* ☀️ [weekly contest 320](src/main/java/weekly/wk320.java) 模拟 | DFS | 贪心 | DP
1011
* ☀️ [weekly contest 319](src/main/java/weekly/wk319.java) 模拟 | 暴力 | 置换环 | DP
@@ -39,8 +40,8 @@ leetcode url: <https://leetcode.cn/u/cctest/>
3940
* 🐶 [weekly contest 290](src/main/java/weekly/wk290.java)
4041
* 🐭 [weekly contest 280](src/main/java/weekly/wk289.java)
4142

42-
43-
* 🐸 [biweekly contest 91](src/main/java/weekly/wkb91.java) 排序 | DO | DFS | 找规律
43+
* 🐸 [biweekly contest 92](src/main/java/weekly/wkb93.java) 数组 | 排序 | 贪心 | 贪心
44+
* 🐸 [biweekly contest 91](src/main/java/weekly/wkb91.java) 排序 | DP | DFS | 找规律
4445
* 🐸 [biweekly contest 90](src/main/java/weekly/wkb90.java) hash | 遍历 | 分组求余 | 单调栈+优先队列
4546
* 🐸 [biweekly contest 89](src/main/java/weekly/wkb89.java) 判断 | 前缀和 | 贪心、二分 | 枚举+DFS
4647
* 🐘 [biweekly contest 88](src/main/java/weekly/wkb88.java) 模拟 | 指针 | 脑筋急转弯 | 线段树

‎src/main/java/weekly/wk323.java

Lines changed: 201 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,201 @@
1+
package weekly;
2+
3+
import java.util.ArrayList;
4+
import java.util.Arrays;
5+
import java.util.HashMap;
6+
import java.util.HashSet;
7+
import java.util.LinkedList;
8+
import java.util.List;
9+
import java.util.Map;
10+
import java.util.PriorityQueue;
11+
import java.util.Queue;
12+
import java.util.Set;
13+
import java.util.TreeMap;
14+
15+
public class wk323 {
16+
//ranking: 1203 / 4671 菜死
17+
18+
19+
//排序
20+
public int deleteGreatestValue(int[][] grid) {
21+
int ans = 0;
22+
for (int i = 0; i < grid.length; i++) {
23+
Arrays.sort(grid[i]);
24+
}
25+
for (int i = 0; i < grid[0].length; i++) {
26+
int max = Integer.MIN_VALUE;
27+
for (int j = 0; j < grid.length; j++) {
28+
max = Math.max(max, grid[j][i]);
29+
}
30+
ans += max;
31+
}
32+
return ans;
33+
}
34+
35+
//哈希
36+
public int longestSquareStreak(int[] nums) {
37+
Set<Integer> set = new HashSet<>();
38+
for (int num : nums) {
39+
set.add(num);
40+
}
41+
int ans = -1;
42+
boolean[] visited = new boolean[nums.length];
43+
for (int i = 0; i < nums.length; i++) {
44+
int num = nums[i] * nums[i];
45+
int count = 1;
46+
while (set.contains(num)) {
47+
count++;
48+
num = num * num;
49+
}
50+
if (count >= 2) {
51+
ans = Math.max(count, ans);
52+
}
53+
}
54+
return ans;
55+
}
56+
57+
58+
//模拟分配
59+
class Allocator {
60+
int[] memo;
61+
62+
public Allocator(int n) {
63+
memo = new int[n];
64+
}
65+
66+
public int allocate(int size, int mID) {
67+
int count = 0;
68+
for (int i = 0; i < memo.length; i++) {
69+
if (memo[i] != 0) {
70+
count = 0;
71+
} else {
72+
count++;
73+
if (count == size) {
74+
for (int j = i; j > i - size; j--) {
75+
memo[j] = mID;
76+
}
77+
return i - size + 1;
78+
}
79+
}
80+
}
81+
return -1;
82+
}
83+
84+
public int free(int mID) {
85+
int count = 0;
86+
for (int i = 0; i < memo.length; i++) {
87+
if (memo[i] == mID) {
88+
memo[i] = 0;
89+
count++;
90+
}
91+
}
92+
return count;
93+
}
94+
/* public int allocate(int size, int mID) {
95+
int index = -1;
96+
for (Map.Entry<Integer, Integer> entry : treeMap.entrySet()) {
97+
//全分配
98+
if (entry.getValue() == size) {
99+
treeMap.remove(entry.getKey());
100+
index = entry.getKey();
101+
//半分配
102+
} else if (entry.getValue() > size) {
103+
treeMap.remove(entry.getKey());
104+
treeMap.put(entry.getKey() + size, entry.getValue() - size);
105+
index = entry.getKey();
106+
}
107+
}
108+
if (index > -1) {
109+
if (!map.containsKey(mID)) map.put(mID, new ArrayList<>());
110+
map.get(mID).add(index);
111+
}
112+
return index;
113+
}*/
114+
}
115+
116+
117+
//优先队列可降低复杂度
118+
//离线查询，排序查询，从小的开始处理
119+
/* public int[] maxPoints(int[][] grid, int[] queries) {
120+
int[][] qq = new int[queries.length][2];
121+
for (int i = 0; i < queries.length; i++) {
122+
qq[i] = new int[]{queries[i], i};
123+
}
124+
Arrays.sort(qq, (a, b) -> a[0] - b[0]);
125+
int m = grid.length, n = grid[0].length;
126+
127+
int[][] move = new int[][]{
128+
{0, 1}, {0, -1}, {1, 0}, {-1, 0}
129+
};
130+
int[] ans = new int[queries.length];
131+
Set<Integer> set = new HashSet<>();
132+
PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> a[0] - b[0]);
133+
priorityQueue.add(new int[]{grid[0][0], 0});
134+
for (int i = 0; i < qq.length; i++) {
135+
int[] a = qq[i];
136+
137+
while (!priorityQueue.isEmpty() && priorityQueue.peek()[0] < a[0]) {
138+
int[] poll = priorityQueue.poll();
139+
int index = poll[1];
140+
int x = index / n;
141+
int y = index % n;
142+
set.add(index);
143+
for (int[] next : move) {
144+
int nx = next[0] + x;
145+
int ny = next[1] + y;
146+
int s = nx * n + ny % n;
147+
if (nx >= 0 && nx < m && ny >= 0 && ny < n && !set.contains(s)) {
148+
priorityQueue.add(new int[]{grid[nx][ny], s});//这次可以检查
149+
if (grid[nx][ny] < a[0]) {
150+
set.add(s);
151+
}
152+
}
153+
}
154+
}
155+
ans[a[1]] = set.size();
156+
}
157+
return ans;
158+
}*/
159+
160+
161+
//转化成Dijkstra找最短路径问题
162+
public int[] maxPoints(int[][] grid, int[] queries) {
163+
int m = grid.length, n = grid[0].length;
164+
int[][] d = new int[m][n];
165+
PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> a[0] - b[0]);
166+
priorityQueue.add(new int[]{grid[0][0], 0, 0});
167+
d[0][0]=grid[0][0];
168+
int[][] move = new int[][]{
169+
{0, 1}, {0, -1}, {1, 0}, {-1, 0}
170+
};
171+
while (!priorityQueue.isEmpty()) {
172+
int[] poll = priorityQueue.poll();
173+
int val = poll[0];
174+
int x = poll[1];
175+
int y = poll[2];
176+
for (int[] ints : move) {
177+
int nx = ints[0] + x;
178+
int ny = ints[1] + y;
179+
if (nx >= 0 && nx < m && ny >= 0 && ny < n && d[nx][ny] == 0) {
180+
d[nx][ny] = Math.max(val, grid[nx][ny]);
181+
priorityQueue.add(new int[]{d[nx][ny],nx,ny});
182+
}
183+
}
184+
}
185+
int []sum=new int[(int)1e6];
186+
for (int i = 0; i < d.length; i++) {
187+
for (int j = 0; j < d[0].length; j++) {
188+
System.out.print(d[i][j]+" ");
189+
sum[d[i][j]]++;
190+
}
191+
System.out.println();
192+
}
193+
for (int i = 1; i < sum.length; i++) {
194+
sum[i]+=sum[i-1];
195+
}
196+
for (int i = 0; i < queries.length; i++) {
197+
queries[i]=sum[queries[i]-1];
198+
}
199+
return queries;
200+
}
201+
}

‎src/main/java/weekly/wkb93.java

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
package weekly;
2+
3+
import java.util.ArrayList;
4+
import java.util.Collections;
5+
import java.util.Comparator;
6+
import java.util.HashMap;
7+
import java.util.List;
8+
import java.util.Map;
9+
import java.util.PriorityQueue;
10+
import java.util.TreeMap;
11+
12+
public class wkb93 {
13+
14+
15+
//ranking: 280 / 2929
16+
17+
//不会正则直接判断
18+
public int maximumValue(String[] strs) {
19+
int max = 0;
20+
for (int i = 0; i < strs.length; i++) {
21+
boolean flag = true;
22+
for (int j = 0; j < strs[i].length(); j++) {
23+
if (!Character.isDigit(strs[i].charAt(j))) {
24+
flag = false;
25+
}
26+
}
27+
if (flag) {
28+
max = Math.max(max, Integer.parseInt(strs[i]));
29+
} else {
30+
max = Math.max(strs[i].length(), max);
31+
}
32+
}
33+
return max;
34+
}
35+
36+
37+
//找邻居+排序
38+
public int maxStarSum(int[] vals, int[][] edges, int k) {
39+
Map<Integer, List<Integer>> map = new HashMap<>();
40+
for (int[] edge : edges) {
41+
if (!map.containsKey(edge[0])) map.put(edge[0], new ArrayList<>());
42+
if (!map.containsKey(edge[1])) map.put(edge[1], new ArrayList<>());
43+
map.get(edge[0]).add(vals[edge[1]]);
44+
map.get(edge[1]).add(vals[edge[0]]);
45+
}
46+
for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
47+
Collections.sort(entry.getValue(), Collections.reverseOrder());
48+
}
49+
int ans = Integer.MIN_VALUE;
50+
for (int val : vals) {
51+
ans = Math.max(ans, val);
52+
}
53+
for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
54+
int sum = vals[entry.getKey()];
55+
int count = 1;
56+
for (Integer val : entry.getValue()) {
57+
if (sum + val < sum || count >= k) {
58+
break;
59+
}
60+
sum += val;
61+
k++;
62+
}
63+
ans = Math.max(sum, ans);
64+
}
65+
return ans;
66+
}
67+
68+
69+
//贪心间隔跳
70+
public int maxJump(int[] stones) {
71+
72+
int ans = stones[1] - stones[0];
73+
for (int i = 2; i < stones.length; i++) {
74+
ans = Math.max(ans, stones[i] - stones[i - 2]);
75+
}
76+
return ans;
77+
78+
}
79+
80+
/* public long minimumTotalCost(int[] nums1, int[] nums2) {
81+
long ans = 0;
82+
List<Integer> list = new ArrayList<>();
83+
for (int i = 0; i < nums1.length; i++) {
84+
if (nums1[i] == nums2[i]) {
85+
list.add(i);
86+
}
87+
}
88+
boolean[] visited = new boolean[nums1.length];
89+
for (int i = list.size() - 1; i >= 0; i--) {
90+
if (visited[i]) continue;
91+
for (int j = i - 1; j >= 0; j--) {
92+
if (visited[j]) continue;
93+
if (nums1[list.get(i)] != nums1[list.get(j)]) {
94+
visited[i] = true;
95+
visited[j] = true;
96+
ans += (i + j);
97+
}
98+
}
99+
}
100+
}*/
101+
102+
public long minimumTotalCost(int[] nums1, int[] nums2) {
103+
int swapCount = 0;
104+
int ans = 0;
105+
int modCount = 0;
106+
int mod = 0;
107+
int[] cnt = new int[nums1.length + 1];
108+
109+
for (int i = 0; i < nums1.length; i++) {
110+
if (nums1[i] == nums2[i]) {
111+
swapCount++;
112+
ans += i;
113+
cnt[nums1[i]]++;
114+
if (cnt[nums1[i]] > modCount) {
115+
modCount = cnt[nums1[i]];
116+
mod = nums1[i];
117+
}
118+
}
119+
}
120+
System.out.println(ans);
121+
for (int i = 0; i < nums1.length && mod * 2 > swapCount; i++) {
122+
if (nums1[i] != nums2[i] && nums1[i] != mod && nums2[i] != mod) {
123+
ans += i;
124+
swapCount++;
125+
}
126+
}
127+
return modCount * 2 > swapCount ? -1 : ans;
128+
}
129+
130+
}

0 commit comments

Comments
 (0)