From 25ca0edcdaae2536c89d4ee41223c4a19611653b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Jul 2023 14:27:53 +0800
Subject: [PATCH] modify code

---
 .../Code01_GreedyPickThings.java              |  62 +++++
 .../Code02_RobotPassThroughBuilding.java      |  81 ++++++
 .../Code03_PutMarblesInBags.java              |  35 +++
 ...MaximumEmployeesToBeInvitedToAMeeting.java | 104 ++++++++
 ...05_FindCriticalAndPseudoCriticalEdges.java | 244 ++++++++++++++++++
 ...¥å…»çš„大厂算法é�¢è¯•é¢˜(正在直播) |  60 +++++
 6 files changed, 586 insertions(+)
 create mode 100644 算法周更�/class_2023_07_2_week/Code01_GreedyPickThings.java
 create mode 100644 算法周更�/class_2023_07_2_week/Code02_RobotPassThroughBuilding.java
 create mode 100644 算法周更�/class_2023_07_2_week/Code03_PutMarblesInBags.java
 create mode 100644 算法周更�/class_2023_07_2_week/Code04_MaximumEmployeesToBeInvitedToAMeeting.java
 create mode 100644 算法周更�/class_2023_07_2_week/Code05_FindCriticalAndPseudoCriticalEdges.java

diff --git a/算法周更�/class_2023_07_2_week/Code01_GreedyPickThings.java b/算法周更�/class_2023_07_2_week/Code01_GreedyPickThings.java
new file mode 100644
index 0000000..81254fb
--- /dev/null
+++ b/算法周更�/class_2023_07_2_week/Code01_GreedyPickThings.java
@@ -0,0 +1,62 @@
+package class_2023_07_2_week;
+
+// 阿里巴巴走进了装满��的��洞。��洞里�有N堆金�
+// 第i堆金�的总��和总价值分别是m[i]�v[i]
+// 阿里巴巴有一个承��为T的背包，但并�一定有办法将全部的金�都装进去
+// 他想装走尽�能多价值的金�
+// 所有金�都�以��分割，分割完的金���价值比（也就是��价格）��
+// 请问阿里巴巴最多�以拿走多少价值的金�？
+// 测试链接 : https://www.luogu.com.cn/problem/P2240
+// 请�学们务必�考如下代�中关于输入�输出的处�
+// 这是输入输出处�效率很高的写法
+// �交以下的code，�交时请把类�改�"Main"，�以直接通过
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code01_GreedyPickThings {
+
+	public static int MAXN = 101;
+
+	// mv[i][0]
+	// mv[i][1]
+	public static int[][] mv = new int[MAXN][2];
+
+	public static int n, t;
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			n = (int) in.nval;
+			in.nextToken();
+			t = (int) in.nval;
+			for (int i = 0; i < n; i++) {
+				in.nextToken();
+				mv[i][0] = (int) in.nval;
+				in.nextToken();
+				mv[i][1] = (int) in.nval;
+			}
+			Arrays.sort(mv, 0, n, (a, b) -> (b[1] * a[0]) - (a[1] * b[0]));
+			double ans = 0;
+			int i = 0;
+			int used = 0;
+			for (; i < n && used + mv[i][0] <= t; i++) {
+				used += mv[i][0];
+				ans += mv[i][1];
+			}
+			if (i < n) {
+				ans += (double) mv[i][1] * (t - used) / (double) mv[i][0];
+			}
+			out.println(String.format("%.2f", ans));
+			out.flush();
+		}
+	}
+
+}
diff --git a/算法周更�/class_2023_07_2_week/Code02_RobotPassThroughBuilding.java b/算法周更�/class_2023_07_2_week/Code02_RobotPassThroughBuilding.java
new file mode 100644
index 0000000..25d9587
--- /dev/null
+++ b/算法周更�/class_2023_07_2_week/Code02_RobotPassThroughBuilding.java
@@ -0,0 +1,81 @@
+package class_2023_07_2_week;
+
+// �自字节
+// 机器人正在玩一个��的基于DOS的游�
+// 游�中有N+1座建筑，从0到N编�，从左到�排列
+// 编�为0的建筑高度为0个��，编�为i的建筑的高度为H(i)个��
+// 起�， 机器人在编�为0的建筑处
+// �一步，它跳到下一个（�边）建筑。�设机器人在第k个建筑，且它现在的能�值是E
+// 下一步它将跳到第个k+1建筑
+// 它将会得到或者失去正比于与H(k+1)与E之差的能�
+// 如果 H(k+1) > E 那么机器人就失去H(k+1)-E的能�值，�则它将得到E-H(k+1)的能�值
+// 游�目标是到达第个N建筑，在这个过程中，能�值�能为负数个��
+// 现在的问题是机器人以多少能�值开始游�，��以���功完�游�
+// 测试链接 : https://www.nowcoder.com/questionTerminal/7037a3d57bbd4336856b8e16a9cafd71
+// 请�学们务必�考如下代�中关于输入�输出的处�
+// 这是输入输出处�效率很高的写法
+// �交以下的code，�交时请把类�改�"Main"，�以直接通过
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_RobotPassThroughBuilding {
+
+	public static int MAXN = 100001;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int n;
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			n = (int) in.nval;
+			int l = 0;
+			int r = 0;
+			int max = 0;
+			for (int i = 0; i < n; i++) {
+				in.nextToken();
+				arr[i] = (int) in.nval;
+				r = Math.max(r, arr[i]);
+				max = r;
+			}
+			int m, ans = -1;
+			while (l <= r) {
+				m = (l + r) / 2;
+				if (ok(m, max)) {
+					ans = m;
+					r = m - 1;
+				} else {
+					l = m + 1;
+				}
+			}
+			out.println(ans);
+			out.flush();
+		}
+	}
+
+	public static boolean ok(int sum, int max) {
+		// 注��
+		// 如果你给的能�值很大，那么这个能�增长的将�常�怖
+		// 甚至有�能超出long的范围，这就是为什么改�long也�对
+		// 所以�加sum <= max这一�判断，一旦能�累加和超过高度的最大值
+		// ��肯定通关了，�以��返回
+		// 总之是很阴
+		for (int i = 0; i < n && sum >= 0 && sum <= max; i++) {
+			if (sum <= arr[i]) {
+				sum -= arr[i] - sum;
+			} else {
+				sum += sum - arr[i];
+			}
+		}
+		return sum >= 0;
+	}
+
+}
diff --git a/算法周更�/class_2023_07_2_week/Code03_PutMarblesInBags.java b/算法周更�/class_2023_07_2_week/Code03_PutMarblesInBags.java
new file mode 100644
index 0000000..62e7539
--- /dev/null
+++ b/算法周更�/class_2023_07_2_week/Code03_PutMarblesInBags.java
@@ -0,0 +1,35 @@
+package class_2023_07_2_week;
+
+import java.util.Arrays;
+
+// 你有 k 个背包。给你一个下标从 0 开始的整数数组 weights
+// 其中 weights[i] 是第 i 个��的��。�时给你整数 k
+// 请你按照如下规则将所有的��放进 k 个背包。
+// 没有背包是空的。
+// 如果第 i 个��和第 j 个��在�一个背包里
+// 那么下标在 i 到 j 之间的所有��都必须在这�一个背包中
+// 如果一个背包有下标从 i 到 j 的所有��，那么这个背包的价格是 weights[i] + weights[j] 。
+// 一个��分�方案的 分数 是所有 k 个背包的价格之和。
+// 请你返回所有分�方案中，最大分数 与 最�分数 的 差值 为多少。
+// 测试链接 : https://leetcode.cn/problems/put-marbles-in-bags/
+public class Code03_PutMarblesInBags {
+
+	public long putMarbles(int[] weights, int k) {
+		int n = weights.length;
+		long[] sums = new long[n - 1];
+		for (int i = 1; i < n; i++) {
+			sums[i - 1] = (long) weights[i - 1] + weights[i];
+		}
+		Arrays.sort(sums);
+		long ans = 0;
+		// � ........ 大
+		// 0          n-2
+//		    1        n-3
+//		      2    n-4
+		for (int i = 0, j = n - 2, p = 1; p < k; i++, j--, p++) {
+			ans += sums[j] - sums[i];
+		}
+		return ans;
+	}
+
+}
diff --git a/算法周更�/class_2023_07_2_week/Code04_MaximumEmployeesToBeInvitedToAMeeting.java b/算法周更�/class_2023_07_2_week/Code04_MaximumEmployeesToBeInvitedToAMeeting.java
new file mode 100644
index 0000000..ba3024a
--- /dev/null
+++ b/算法周更�/class_2023_07_2_week/Code04_MaximumEmployeesToBeInvitedToAMeeting.java
@@ -0,0 +1,104 @@
+package class_2023_07_2_week;
+
+// 一个公�准备组织一场会议，邀请��上有 n �员工
+// 公�准备了一张 圆形 的桌�，�以�下 任�数目 的员工
+// 员工编�为 0 到 n - 1 。��员工都有一� 喜欢 的员工
+// ��员工 当且仅当 他被安排在喜欢员工的�边，他�会�加会议
+// ��员工喜欢的员工 �会 是他自己。
+// 给你一个下标从 0 开始的整数数组 favorite
+// 其中 favorite[i] 表示第 i �员工喜欢的员工。请你返回�加会议的 最多员工数目
+// 测试链接 : https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/
+public class Code04_MaximumEmployeesToBeInvitedToAMeeting {
+
+	public static int maximumInvitations(int[] favorite) {
+		int[][] loved = beLoved(favorite);
+		int[] degree = degree(loved);
+		int n = favorite.length;
+		int[] queue = new int[n];
+		int l = 0;
+		int r = 0;
+		for (int i = 0; i < n; i++) {
+			if (degree[i] == 0) {
+				queue[r++] = i;
+			}
+		}
+		boolean[] zeroVisited = new boolean[n];
+		while (l < r) {
+			int cur = queue[l++];
+			zeroVisited[cur] = true;
+			if (--degree[favorite[cur]] == 0) {
+				queue[r++] = favorite[cur];
+			}
+		}
+		boolean[] cycleVisited = new boolean[n];
+		int arrangeTwoCycle = 0;
+		int arrangeMoreCycle = 0;
+		for (int i = 0; i < n; i++) {
+			if (!zeroVisited[i] && !cycleVisited[i]) {
+				cycleVisited[i] = true;
+				if (favorite[favorite[i]] == i) {
+					cycleVisited[favorite[i]] = true;
+					arrangeTwoCycle += maxFollow(i, zeroVisited, loved) + maxFollow(favorite[i], zeroVisited, loved);
+				} else {
+					int cur = favorite[i];
+					int curAns = 1;
+					while (cur != i) {
+						cycleVisited[cur] = true;
+						curAns++;
+						cur = favorite[cur];
+					}
+					arrangeMoreCycle = Math.max(arrangeMoreCycle, curAns);
+				}
+			}
+		}
+		return Math.max(arrangeTwoCycle, arrangeMoreCycle);
+	}
+
+	// 生�被喜欢表
+	// favorite[3] = 7
+	// favorite[5] = 7
+	// size[
+	public static int[][] beLoved(int[] favorite) {
+		int n = favorite.length;
+		int[] size = new int[n];
+		// size[7] : 有多少人喜欢7
+		for (int love : favorite) {
+			size[love]++;
+		}
+		// 7 : 3 5
+		// 9 : 0 1 4
+		int[][] loved = new int[n][];
+		for (int i = 0; i < n; i++) {
+			loved[i] = new int[size[i]];
+		}
+		for (int i = 0; i < n; i++) {
+			loved[favorite[i]][--size[favorite[i]]] = i;
+		}
+		return loved;
+	}
+
+	// 求�个点的入度
+	public static int[] degree(int[][] loved) {
+		int n = loved.length;
+		int[] degree = new int[n];
+		for (int i = 0; i < n; i++) {
+			degree[i] = loved[i].length;
+		}
+		return degree;
+	}
+
+	// cur�在环上的追�者链�最大长度
+	public static int maxFollow(int cur, boolean[] zeroed, int[][] from) {
+		if (from[cur].length == 0) {
+			return 1;
+		}
+		int ans = 0;
+		for (int pre : from[cur]) {
+			if (zeroed[pre]) {
+				ans = Math.max(ans, maxFollow(pre, zeroed, from));
+			}
+		}
+		return ans + 1;
+	}
+
+}
diff --git a/算法周更�/class_2023_07_2_week/Code05_FindCriticalAndPseudoCriticalEdges.java b/算法周更�/class_2023_07_2_week/Code05_FindCriticalAndPseudoCriticalEdges.java
new file mode 100644
index 0000000..e43c350
--- /dev/null
+++ b/算法周更�/class_2023_07_2_week/Code05_FindCriticalAndPseudoCriticalEdges.java
@@ -0,0 +1,244 @@
+package class_2023_07_2_week;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.ArrayList;
+
+// 给你一个 n 个点的带�无�连通图，节点编�为 0 到 n-1
+// �时还有一个数组 edges ，其中 edges[i] = [fromi, toi, weighti]
+// 表示在 fromi 和 toi 节点之间有一�带�无�边
+// 最�生�树 (MST) 是给定图中边的一个�集
+// 它连接了所有节点且没有环，而且这些边的�值和最�
+// 请你找到给定图中最�生�树的所有关键边和伪关键边
+// 如果从图中删去��边，会导致最�生�树的�值和增加，那么我们就说它是一�关键边
+// 伪关键边则是�能会出现在�些最�生�树中但�会出现在所有最�生�树中的边
+// 请注�，你�以分别以任�顺�返回关键边的下标和伪关键边的下标
+// 测试链接 : https://leetcode.cn/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/
+// 本题用到并查集�最�生�树�求�通图中的桥
+// 并查集�最�生�树，在体系学习�
+// 求桥，在�周有�养的大厂算法�试题，2022年10月第1周
+// 链���星，2022年10月第1周
+// 务必打好基础，��看这个题的解�
+// 这个实现打败100%的�交者
+public class Code05_FindCriticalAndPseudoCriticalEdges {
+
+	public static int MAXN = 101;
+
+	public static int MAXM = 201;
+
+	// 边状�的记录
+	// status[ei] = 0，代表ei这个边既�是关键边也�是伪关键边
+	// status[ei] = 1，代表ei这个边是伪关键边
+	// status[ei] = 2，代表ei这个边是关键边
+	public static int[] status = new int[MAXM];
+
+	// 并查集相关
+	public static int[] father = new int[MAXN];
+	public static int[] size = new int[MAXN];
+	public static int[] help = new int[MAXN];
+	public static int sets = 0;
+
+	// 并查集�始化
+	public static void buildUnoinSet(int n) {
+		for (int i = 0; i < n; i++) {
+			father[i] = i;
+			size[i] = 1;
+		}
+		sets = n;
+	}
+
+	// 并查集�上找代表节点
+	public static int find(int i) {
+		int r = 0;
+		while (i != father[i]) {
+			help[r++] = i;
+			i = father[i];
+		}
+		while (r > 0) {
+			father[help[--r]] = i;
+		}
+		return i;
+	}
+
+	// 并查集�并集�
+	public static void union(int i, int j) {
+		int fi = find(i);
+		int fj = find(j);
+		if (fi != fj) {
+			if (size[fi] >= size[fj]) {
+				father[fj] = fi;
+				size[fi] += size[fj];
+			} else {
+				father[fi] = fj;
+				size[fj] += size[fi];
+			}
+			sets--;
+		}
+	}
+
+	// 边相关
+	public static int[][] edges = new int[MAXM][4];
+
+	public static int m;
+
+	public static void buildEdges(int[][] e) {
+		for (int i = 0; i < m; i++) {
+			edges[i][0] = i;
+			edges[i][1] = e[i][0];
+			edges[i][2] = e[i][1];
+			edges[i][3] = e[i][2];
+		}
+		Arrays.sort(edges, 0, m, (a, b) -> a[3] - b[3]);
+	}
+
+	// 通过集�编�建图相关
+	// 链���星建图
+	// 为啥用这玩�儿建图？没啥，就是想秀
+	public static int[] head = new int[MAXN];
+	// int[] to : i�边是去哪的�
+	public static int[][] info = new int[MAXM][3];
+	public static int[] next = new int[MAXM];
+	public static int edgeSize;
+
+	public static void buildGraph(int k) {
+		for (int i = 0; i < k; i++) {
+			head[i] = -1;
+			edgeSize = 0;
+		}
+	}
+
+	public static void addEdge(int a, int b, int ei) {
+		next[edgeSize] = head[a];
+		info[edgeSize][0] = ei;
+		info[edgeSize][1] = a;
+		info[edgeSize][2] = b;
+		head[a] = edgeSize++;
+	}
+
+	// 哈希表相关
+	// 一个集�，给一个编�
+	public static int[] id = new int[MAXN];
+
+	// 找桥相关
+	public static int[] dfn = new int[MAXN];
+	public static int[] low = new int[MAXN];
+	public static int cnt;
+
+	public static void findBridge(int k) {
+		Arrays.fill(dfn, 0, k, 0);
+		Arrays.fill(low, 0, k, 0);
+		cnt = 0;
+		for (int init = 0; init < k; init++) {
+			if (dfn[init] == 0) {
+				tarjan(init, init, -1, -1);
+			}
+		}
+	}
+
+	public static void tarjan(int init, int cur, int father, int ei) {
+		dfn[cur] = low[cur] = ++cnt;
+		for (int i = head[cur]; i != -1; i = next[i]) {
+			int edgei = info[i][0];
+			int nodei = info[i][2];
+			if (nodei != father) {
+				if (dfn[nodei] == 0) {
+					tarjan(init, nodei, cur, edgei);
+					low[cur] = Math.min(low[cur], low[nodei]);
+				} else {
+					low[cur] = Math.min(low[cur], dfn[nodei]);
+				}
+			}
+		}
+		if (low[cur] == dfn[cur] && cur != init) {
+			status[ei] = 2;
+		}
+	}
+
+	public static List<List<Integer>> findCriticalAndPseudoCriticalEdges(int n, int[][] e) {
+		m = e.length;
+		Arrays.fill(status, 0, m, 0);
+		buildUnoinSet(n);
+		buildEdges(e);
+		List<Integer> bridge = new ArrayList<>();
+		List<Integer> pseudo = new ArrayList<>();
+		int start = 0;
+		while (sets != 1) {
+			int end = start + 1;
+			while (end < m && edges[start][3] == edges[end][3]) {
+				end++;
+			}
+			// start....end-1 start...
+			connect(start, end);
+			for (int i = start; i < end; i++) {
+				int ei = edges[i][0];
+				if (status[ei] == 2) {
+					bridge.add(ei);
+				} else if (status[ei] == 1) {
+					pseudo.add(ei);
+				}
+				union(edges[i][1], edges[i][2]);
+			}
+			start = end;
+		}
+		return Arrays.asList(bridge, pseudo);
+	}
+
+	// 大团�，一个集�，缩�一个点
+	// 当�的边，[start...end)
+	// �图�大团�的图，找桥�
+	public static void connect(int start, int end) {
+		for (int i = start; i < end; i++) {
+			id[find(edges[i][1])] = -1;
+			id[find(edges[i][2])] = -1;
+		}
+		int k = 0;
+		for (int i = start; i < end; i++) {
+			if (id[find(edges[i][1])] == -1) {
+				id[find(edges[i][1])] = k++;
+			}
+			if (id[find(edges[i][2])] == -1) {
+				id[find(edges[i][2])] = k++;
+			}
+		}
+		buildGraph(k);
+		// 大团�，有边�用链���星建图，大团�的图�
+		for (int i = start; i < end; i++) {
+			int index = edges[i][0];
+			int a = id[find(edges[i][1])];
+			int b = id[find(edges[i][2])];
+			if (a != b) {
+				status[index] = 1;
+				addEdge(a, b, index);
+				addEdge(b, a, index);
+			}
+		}
+		findBridge(k);
+		// 处���连接
+		// 什么是��连接？�是自己指�自己，那�自环
+		// ��连接指的是:
+		// 集�a到集�b有一�边，边的��是p
+		// 于是，a的邻接表里有(p,b)，b的邻接表里有(p,a)
+		// 集�a到集�b�有一�边，边的��是t
+		// 于是，a的邻接表里有(t,b)，b的邻接表里有(t,a)
+		// 那么p和t都是��链接，因为�独删掉p或者t，�会影��通性
+		// 而在求桥的模版中，是默认没有��链接的
+		// 如果有��链接就直接用模版，那么会出现��链接被认为是桥的情况
+		// 所以这里��独判断，如果有��链接被设置�了桥，�把它改�伪关键边的状�
+		Arrays.sort(info, 0, edgeSize, (a, b) -> a[1] != b[1] ? (a[1] - b[1]) : (a[2] - b[2]));
+		int right, left = 0;
+		while (left < edgeSize) {
+			right = left + 1;
+			while (right < edgeSize && info[left][1] == info[right][1]) {
+				right++;
+			}
+			for (int i = left + 1; i < right; i++) {
+				if (info[i][2] == info[i - 1][2]) {
+					status[info[i][0]] = 1;
+					status[info[i - 1][0]] = 1;
+				}
+			}
+			left = right;
+		}
+	}
+
+}
diff --git a/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播) b/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播)
index 3eebdc7..dcd15f1 100644
--- a/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播)
+++ b/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播)
@@ -4074,6 +4074,66 @@ forceField[i] = [x,y,side]
 
 
 
+第076节 2023年7月2周�行算法题目解�
+
+阿里巴巴走进了装满��的��洞。��洞里�有N堆金�
+第i堆金�的总��和总价值分别是m[i]�v[i]
+阿里巴巴有一个承��为T的背包，但并�一定有办法将全部的金�都装进去
+他想装走尽�能多价值的金�
+所有金�都�以��分割，分割完的金���价值比（也就是��价格）��
+请问阿里巴巴最多�以拿走多少价值的金�？
+测试链接 : https://www.luogu.com.cn/problem/P2240
+
+�自字节
+机器人正在玩一个��的基于DOS的游�
+游�中有N+1座建筑，从0到N编�，从左到�排列
+编�为0的建筑高度为0个��，编�为i的建筑的高度为H(i)个��
+起�， 机器人在编�为0的建筑处
+�一步，它跳到下一个（�边）建筑。�设机器人在第k个建筑，且它现在的能�值是E
+下一步它将跳到第个k+1建筑
+它将会得到或者失去正比于与H(k+1)与E之差的能�
+如果 H(k+1) > E 那么机器人就失去H(k+1)-E的能�值，�则它将得到E-H(k+1)的能�值
+游�目标是到达第个N建筑，在这个过程中，能�值�能为负数个��
+现在的问题是机器人以多少能�值开始游�，��以���功完�游�
+测试链接 : https://www.nowcoder.com/questionTerminal/7037a3d57bbd4336856b8e16a9cafd71
+
+你有 k 个背包。给你一个下标从 0 开始的整数数组 weights
+其中 weights[i] 是第 i 个��的��。�时给你整数 k
+请你按照如下规则将所有的��放进 k 个背包。
+没有背包是空的。
+如果第 i 个��和第 j 个��在�一个背包里
+那么下标在 i 到 j 之间的所有��都必须在这�一个背包中
+如果一个背包有下标从 i 到 j 的所有��，那么这个背包的价格是 weights[i] + weights[j] 。
+一个��分�方案的 分数 是所有 k 个背包的价格之和。
+请你返回所有分�方案中，最大分数 与 最�分数 的 差值 为多少。
+测试链接 : https://leetcode.cn/problems/put-marbles-in-bags/
+
+一个公�准备组织一场会议，邀请��上有 n �员工
+公�准备了一张 圆形 的桌�，�以�下 任�数目 的员工
+员工编�为 0 到 n - 1 。��员工都有一� 喜欢 的员工
+��员工 当且仅当 他被安排在喜欢员工的�边，他�会�加会议
+��员工喜欢的员工 �会 是他自己。
+给你一个下标从 0 开始的整数数组 favorite
+其中 favorite[i] 表示第 i �员工喜欢的员工。请你返回�加会议的 最多员工数目
+测试链接 : https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/
+
+给你一个 n 个点的带�无�连通图，节点编�为 0 到 n-1
+�时还有一个数组 edges ，其中 edges[i] = [fromi, toi, weighti]
+表示在 fromi 和 toi 节点之间有一�带�无�边
+最�生�树 (MST) 是给定图中边的一个�集
+它连接了所有节点且没有环，而且这些边的�值和最�
+请你找到给定图中最�生�树的所有关键边和伪关键边
+如果从图中删去��边，会导致最�生�树的�值和增加，那么我们就说它是一�关键边
+伪关键边则是�能会出现在�些最�生�树中但�会出现在所有最�生�树中的边
+请注�，你�以分别以任�顺�返回关键边的下标和伪关键边的下标
+测试链接 : https://leetcode.cn/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/
+
+
+
+
+
+
+