Skip to content

Commit d1be607

Browse files
youngyangyang04youngyangyang04
committed
Update
1 parent 06997eb commit d1be607

File tree

7 files changed

+603
-666
lines changed

7 files changed

+603
-666
lines changed

‎problems/kamacoder/0094.城市间货物运输I-SPFA.md‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -158,28 +158,24 @@
158158

159159
边：节点5 -> 节点6，权值为-2 ，minDist[6] > minDist[5] + (-2) ，更新 minDist[6] = minDist[5] + (-2) = 3 - 2 = 1
160160

161-
如图：
162-
163-
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240412110509.png)
164-
161+
如图，将节点3加入队列，因为节点6已经在队列里，所以不用重复添加
165162

163+
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240729161116.png)
166164

167-
因为节点3 和 节点6 都曾经加入过队列，不用重复加入，避免重复计算。
168-
169-
在代码中我们可以用一个数组 visited 来记录入过队列的元素，加入过队列的元素，不再重复入队列。
170-
165+
所以我们在加入队列的过程可以有一个优化，用visited数组记录已经加入队列的元素，已经在队列的元素不用重复加入
171166

172167
--------------
173168

174169
从队列中取出节点6，松弛节点6 作为出发点连接的边。
175170

176171
节点6作为终点，没有可以出发的边。
177172

173+
同理从队列中取出节点3，也没有可以出发的边
174+
178175
所以直接从队列中取出，如图：
179176

180177
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240411115424.png)
181178

182-
183179
----------
184180

185181
这样我们就完成了基于队列优化的bellman_ford的算法模拟过程。
@@ -190,12 +186,12 @@
190186

191187
在上面模拟过程中，我们每次都要知道 一个节点作为出发点连接了哪些节点。
192188

193-
如果想方便知道这些数据，就需要使用邻接表来存储这个图，如果对于邻接表不了解的话，可以看 [kama0047.参会dijkstra堆](./kama0047.参会dijkstra堆.md) 中 图的存储 部分。
189+
如果想方便知道这些数据，就需要使用邻接表来存储这个图，如果对于邻接表不了解的话，可以看 [kama0047.参会dijkstra堆](./0047.参会dijkstra堆.md) 中 图的存储 部分。
194190

195191

196192
整体代码如下：
197193

198-
```CPP
194+
```
199195
#include <iostream>
200196
#include <vector>
201197
#include <queue>
@@ -215,7 +211,9 @@ int main() {
215211
int n, m, p1, p2, val;
216212
cin >> n >> m;
217213
218-
vector<list<Edge>> grid(n + 1); // 邻接表
214+
vector<list<Edge>> grid(n + 1);
215+
216+
vector<bool> isInQueue(n + 1); // 加入优化，已经在队里里的元素不用重复添加
219217
220218
// 将所有边保存起来
221219
for(int i = 0; i < m; i++){
@@ -230,24 +228,26 @@ int main() {
230228
minDist[start] = 0;
231229
232230
queue<int> que;
233-
que.push(start); // 队列里放入起点
231+
que.push(start);
234232
235233
while (!que.empty()) {
236234
237235
int node = que.front(); que.pop();
238-
236+
isInQueue[node] = false; // 从队列里取出的时候，要取消标记
239237
for (Edge edge : grid[node]) {
240238
int from = node;
241239
int to = edge.to;
242240
int value = edge.val;
243241
if (minDist[to] > minDist[from] + value) { // 开始松弛
244-
minDist[to] = minDist[from] + value;
245-
que.push(to);
242+
minDist[to] = minDist[from] + value;
243+
if (isInQueue[to] == false) { // 已经在队列里的元素不用重复添加
244+
que.push(to);
245+
isInQueue[to] = true;
246+
}
246247
}
247248
}
248249
249250
}
250-
251251
if (minDist[end] == INT_MAX) cout << "unconnected" << endl; // 不能到达终点
252252
else cout << minDist[end] << endl; // 到达终点最短路径
253253
}

‎problems/kamacoder/0147.三珠互斥.md‎

Lines changed: 41 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,12 @@
11

2+
# 三珠互斥
3+
24
1. 如果k * 3 大于 n 了，那说明一定没结果，如果没想明白，大家举个例子试试看
35
2. 分别求出三个红珠子之间的距离
46
3. 对这三段距离从小到大排序 y1, y2, y3
57
4. 如果第一段距离y1 小于k，说明需要交换 k - y 次， 同理 第二段距离y2 小于k，说明需要交换 k - y2 次
68
5. y1 y2 都调整好了，不用计算y3，因为 y3是距离最大
79

8-
910
```CPP
1011
#include<bits/stdc++.h>
1112
using namespace std;
@@ -29,12 +30,49 @@ int main(){
2930
sort(dis.begin(), dis.end());
3031

3132
int result = 0;
32-
3333
if (dis[0] < k) result += (k - dis[0]);
3434
if (dis[1] < k) result += (k - dis[1]);
35-
35+
3636
cout << result << endl;
3737
}
3838
return 0;
3939
}
4040
```
41+
42+
Java代码：
43+
44+
```Java
45+
import java.util.*;
46+
47+
public class Main {
48+
public static void main(String[] args) {
49+
Scanner scanner = new Scanner(System.in);
50+
int t = scanner.nextInt();
51+
52+
while (t-- > 0) {
53+
int n = scanner.nextInt();
54+
int k = scanner.nextInt();
55+
int a1 = scanner.nextInt();
56+
int a2 = scanner.nextInt();
57+
int a3 = scanner.nextInt();
58+
if (k * 3 > n) {
59+
System.out.println(-1);
60+
continue;
61+
}
62+
63+
List<Integer> dis = new ArrayList<>(3);
64+
dis.add(Math.min(Math.abs(a1 - a2), n - Math.abs(a1 - a2)));
65+
dis.add(Math.min(Math.abs(a1 - a3), n - Math.abs(a1 - a3)));
66+
dis.add(Math.min(Math.abs(a3 - a2), n - Math.abs(a3 - a2)));
67+
68+
Collections.sort(dis);
69+
70+
int result = 0;
71+
if (dis.get(0) < k) result += (k - dis.get(0));
72+
if (dis.get(1) < k) result += (k - dis.get(1));
73+
74+
System.out.println(result);
75+
}
76+
}
77+
}
78+
```

‎problems/kamacoder/0148.扑克牌同花顺.md‎

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,6 @@
11

2+
# 扑克牌同花顺
3+
24
首先我们要定义一个结构体，来存放我们的数据
35

46
`map<花色，{同一花色牌集合，同一花色的牌对应的牌数量}>`
@@ -51,3 +53,70 @@ int main() {
5153
cout << sum << endl;
5254
}
5355
```
56+
57+
Java代码如下：
58+
59+
```Java
60+
61+
import java.util.*;
62+
63+
public class Main {
64+
static String[] cards = {"H", "S", "D", "C"}; // 花色数组
65+
66+
static class Color {
67+
Set<Integer> st; // 同一花色牌的集合
68+
Map<Integer, Long> cnt; // 同一花色牌对应的数量
69+
70+
Color() {
71+
st = new HashSet<>(); // 初始化集合
72+
cnt = new HashMap<>(); // 初始化映射
73+
}
74+
}
75+
76+
static Map<String, Color> umap = new HashMap<>(); // 用于存储每种花色对应的Color对象
77+
78+
public static void main(String[] args) {
79+
Scanner scanner = new Scanner(System.in);
80+
int n = scanner.nextInt(); // 读取牌的数量
81+
82+
for (int i = 0; i < n; i++) {
83+
int x = scanner.nextInt(); // 读取牌的值
84+
int y = scanner.nextInt(); // 读取牌的数量
85+
String card = scanner.next(); // 读取牌的花色
86+
87+
umap.putIfAbsent(card, new Color()); // 如果不存在该花色，则创建一个新的Color对象
88+
umap.get(card).st.add(x); // 将牌的值加入集合
89+
umap.get(card).cnt.put(x, umap.get(card).cnt.getOrDefault(x, 0L) + y); // 更新牌的数量
90+
}
91+
92+
long sum = 0; // 结果累加器
93+
94+
// 遍历每一种花色
95+
for (String cardOne : cards) {
96+
Color colorOne = umap.getOrDefault(cardOne, new Color()); // 获取对应花色的Color对象
97+
98+
// 遍历同花色的每一张牌
99+
for (int number : colorOne.st) {
100+
long numberCount = colorOne.cnt.get(number); // 获取当前牌的数量
101+
102+
// 计算从当前牌到number+4的最小数量
103+
long cal = numberCount;
104+
for (int j = number + 1; j <= number + 4; j++) {
105+
cal = Math.min(cal, colorOne.cnt.getOrDefault(j, 0L)); // 更新cal为最小值
106+
}
107+
108+
// 将结果累加到sum
109+
sum += cal;
110+
111+
// 将统计过的同花顺数量减去
112+
for (int j = number + 1; j <= number + 4; j++) {
113+
colorOne.cnt.put(j, colorOne.cnt.getOrDefault(j, 0L) - cal);
114+
}
115+
}
116+
}
117+
118+
System.out.println(sum); // 输出结果
119+
}
120+
}
121+
122+
```

‎problems/kamacoder/好数组.md‎ renamed to ‎problems/kamacoder/0149.好数组.md‎

Lines changed: 49 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11

2+
# 149. 好数组
23

3-
算是贪心
4+
贪心思路：
45

56
整体思路是移动到中间位置（中位数），一定是 移动次数最小的。
67

@@ -11,9 +12,7 @@
1112
代码如下：
1213

1314
```CPP
14-
1515
#include<bits/stdc++.h>
16-
1716
using namespace std;
1817

1918
int main() {
@@ -54,3 +53,50 @@ int main() {
5453
return 0;
5554
}
5655
```
56+
57+
Java代码如下：
58+
59+
```Java
60+
61+
import java.util.*;
62+
63+
public class Main {
64+
public static void main(String[] args) {
65+
Scanner scanner = new Scanner(System.in);
66+
int n = scanner.nextInt();
67+
long[] arr = new long[n];
68+
for (int i = 0; i < n; ++i) {
69+
arr[i] = scanner.nextLong();
70+
}
71+
Arrays.sort(arr);
72+
73+
if (arr[0] == arr[n - 1]) {
74+
System.out.println(1);
75+
return;
76+
}
77+
long cnt = 0L;
78+
long cnt1 = 0L;
79+
80+
// 如果要保留一个不改变，要不不改最小的，要不不改最大的。
81+
82+
// 取中间偏前的位置
83+
long mid = arr[(n - 2) / 2];
84+
85+
// 不改最大的
86+
for (int i = 0; i < n - 1; i++) {
87+
cnt += Math.abs(arr[i] - mid);
88+
}
89+
90+
// 取中间偏后的位置
91+
mid = arr[n / 2];
92+
93+
// 不改最小的
94+
for (int i = 1; i < n; i++) {
95+
cnt1 += Math.abs(arr[i] - mid);
96+
}
97+
98+
System.out.println(Math.min(cnt, cnt1));
99+
}
100+
}
101+
102+
```

‎problems/kamacoder/0150.极长连续段的权值.md‎

Lines changed: 37 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,7 @@
11

2+
# 150. 极长连续段的权值
23

3-
按照动态规划的思路，每增加一位，对已有结果会有什么变化呢？
4-
5-
输入 字符串s 里面有 0 和 1
6-
7-
我们先计算出 s[i-1] 的 子串权值和 a
8-
9-
如果 s[i] 和 s[i - 1] 相同
10-
11-
下标0 到 i 这段字符串 的子串权值和就是 a + 1，即算上s[i]本身的连续串数量加上
12-
13-
如果 s[i] 和 s[i - 1] 不相同
14-
15-
16-
17-
18-
4+
动态规划，枚举最后边节点的情况：
195

206
```CPP
217
#include <iostream>
@@ -32,9 +18,11 @@ int main() {
3218
long long a = 1;
3319

3420
for (int i = 1; i < n; ++i) {
21+
// 加上本身长度为1的子串
3522
if (s[i] == s[i - 1]) {
3623
a += 1;
37-
result += a;
24+
result += a;
25+
// 以最右节点为终点，每个子串的级长连续段都+1，再加本身长度为1的子串
3826
} else {
3927
a = a + i + 1;
4028
result += a;
@@ -44,3 +32,35 @@ int main() {
4432
return 0;
4533
}
4634
```
35+
36+
Java代码如下：
37+
38+
```Java
39+
import java.util.Scanner;
40+
41+
public class Main {
42+
public static void main(String[] args) {
43+
Scanner scanner = new Scanner(System.in);
44+
int n = scanner.nextInt();
45+
String s = scanner.next();
46+
47+
long result = 1;
48+
long a = 1;
49+
50+
for (int i = 1; i < n; ++i) {
51+
// 加上本身长度为1的子串
52+
if (s.charAt(i) == s.charAt(i - 1)) {
53+
a += 1;
54+
result += a;
55+
// 以最右节点为终点，每个子串的级长连续段都+1，再加本身长度为1的子串
56+
} else {
57+
a = a + i + 1;
58+
result += a;
59+
}
60+
}
61+
62+
System.out.println(result);
63+
}
64+
}
65+
66+
```

0 commit comments

Comments
 (0)