From fdafcff0ed741cc4ecb9243330b9c5b242e89605 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 8 Feb 2023 22:22:57 +0800
Subject: [PATCH] modify code

---
 .../Code01_NumberOfMusicPlaylists.java        |  72 +++++++++
 ...02_VerticalOrderTraversalOfBinaryTree.java |  82 ++++++++++
 .../Code03_WidthOfBinaryTree.java             |  54 +++++++
 .../Code04_MinimizeMalwareSpreadII.java       | 144 ++++++++++++++++++
 ...¥å…»çš„大厂算法é�¢è¯•é¢˜(正在直播) |  60 ++++++++
 5 files changed, 412 insertions(+)
 create mode 100644 算法周更�/class_2023_02_2_week/Code01_NumberOfMusicPlaylists.java
 create mode 100644 算法周更�/class_2023_02_2_week/Code02_VerticalOrderTraversalOfBinaryTree.java
 create mode 100644 算法周更�/class_2023_02_2_week/Code03_WidthOfBinaryTree.java
 create mode 100644 算法周更�/class_2023_02_2_week/Code04_MinimizeMalwareSpreadII.java

diff --git a/算法周更�/class_2023_02_2_week/Code01_NumberOfMusicPlaylists.java b/算法周更�/class_2023_02_2_week/Code01_NumberOfMusicPlaylists.java
new file mode 100644
index 0000000..303c56a
--- /dev/null
+++ b/算法周更�/class_2023_02_2_week/Code01_NumberOfMusicPlaylists.java
@@ -0,0 +1,72 @@
+package class_2023_02_2_week;
+
+// 你的音�播放器里有 N 首��的歌
+// 在旅途中，你的旅伴想�� L 首歌（�一定��，�，�许歌曲��
+// 请你为她按如下规则创建一个播放列表
+// �首歌至少播放一次
+// 一首歌�有在其他 K 首歌播放完之��能�次播放
+// 返回�以满足�求的播放列表的数�
+// 由于答案�能�常大，请返回它模 10^9 + 7 的结果
+// 测试链接 : https://leetcode.cn/problems/number-of-music-playlists/
+public class Code01_NumberOfMusicPlaylists {
+
+	public static int mod = 1000000007;
+
+	public static int limit = 100;
+
+	// 阶乘表
+	public static long[] fac = new long[limit + 1];
+
+	// 阶乘结果的乘法逆元表
+	public static long[] inv = new long[limit + 1];
+
+	static {
+		fac[0] = inv[0] = 1;
+		for (int i = 1; i <= limit; i++) {
+			fac[i] = ((long) i * fac[i - 1]) % mod;
+		}
+		// 费马�定�计算乘法逆元
+//		for (int i = 1; i <= limit; i++) {
+//			inv[i] = power(fac[i], mod - 2);
+//		}
+		// 费马�定�计算乘法逆元，优化如下
+		// 这一��：阶乘的逆元倒推
+		inv[limit] = power(fac[limit], mod - 2);
+		for (int i = limit; i > 1; i--) {
+			inv[i - 1] = ((long) i * inv[i]) % mod;
+		}
+	}
+
+	// x的n次方，% mod之�，是多少？
+	public static long power(long x, int n) {
+		long ans = 1;
+		while (n > 0) {
+			if ((n & 1) == 1) {
+				ans = (ans * x) % mod;
+			}
+			x = (x * x) % mod;
+			n >>= 1;
+		}
+		return ans;
+	}
+
+	// n * logn
+	public static int numMusicPlaylists(int n, int l, int k) {
+		long cur, ans = 0, sign = 1;
+		for (int i = 0; i <= n - k; i++, sign = sign == 1 ? (mod - 1) : 1) {
+			// cur -> 
+			// fac[n] -> n! % mod 的结果�
+			// inv[i] -> i! 的逆元�
+			// inv[n - k - i] -> (n - k - i)! 的逆元
+			// sign * 1 -> 1
+			//      * -1 -> mod - 1
+			cur = (sign * power(n - k - i, l - k)) % mod;
+			cur = (cur * fac[n]) % mod;
+			cur = (cur * inv[i]) % mod;
+			cur = (cur * inv[n - k - i]) % mod;
+			ans = (ans + cur) % mod;
+		}
+		return (int) ans;
+	}
+
+}
diff --git a/算法周更�/class_2023_02_2_week/Code02_VerticalOrderTraversalOfBinaryTree.java b/算法周更�/class_2023_02_2_week/Code02_VerticalOrderTraversalOfBinaryTree.java
new file mode 100644
index 0000000..da8e899
--- /dev/null
+++ b/算法周更�/class_2023_02_2_week/Code02_VerticalOrderTraversalOfBinaryTree.java
@@ -0,0 +1,82 @@
+package class_2023_02_2_week;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+// 给你二�树的根结点 root ，请你设计算法计算二�树的 垂��历 �列。
+// 对�于 (row, col) 的�个结点而言，
+// 其左��结点分别�于 (row + 1, col - 1) 和 (row + 1, col + 1)
+// 树的根结点�于 (0, 0) 。
+// 二�树的 垂��历 从最左边的列开始直到最�边的列结�，按列索引�一列上的所有结点，
+// 形�一个按出现�置从上到下排�的有�列表。如果�行�列上有多个结点，
+// 则按结点的值从�到大进行排�。
+// 返回二�树的 垂��历 �列。
+// 测试链接 : https://leetcode.cn/problems/vertical-order-traversal-of-a-binary-tree/
+public class Code02_VerticalOrderTraversalOfBinaryTree {
+
+	// ��交这个类
+	public static class TreeNode {
+		int val;
+		TreeNode left;
+		TreeNode right;
+	}
+
+	// �交以下所有的code
+	public static class Info {
+		public int row;
+		public int col;
+		public int val;
+
+		public Info(int r, int c, int v) {
+			row = r;
+			col = c;
+			val = v;
+		}
+	}
+
+	public static class InfoComparator implements Comparator<Info> {
+
+		@Override
+		public int compare(Info o1, Info o2) {
+			if (o1.col != o2.col) {
+				return o1.col - o2.col;
+			}
+			if (o1.row != o2.row) {
+				return o1.row - o2.row;
+			}
+			return o1.val - o2.val;
+		}
+
+	}
+
+	public static List<List<Integer>> verticalTraversal(TreeNode root) {
+		ArrayList<Info> collects = new ArrayList<>();
+		Info rootInfo = new Info(0, 0, root.val);
+		collects.add(rootInfo);
+		dfs(root, rootInfo, collects);
+		List<List<Integer>> ans = new ArrayList<>();
+		collects.sort(new InfoComparator());
+		for (int i = 0; i < collects.size(); i++) {
+			if (i == 0 || collects.get(i - 1).col != collects.get(i).col) {
+				ans.add(new ArrayList<>());
+			}
+			ans.get(ans.size() - 1).add(collects.get(i).val);
+		}
+		return ans;
+	}
+
+	public static void dfs(TreeNode root, Info rootInfo, ArrayList<Info> collects) {
+		if (root.left != null) {
+			Info leftInfo = new Info(rootInfo.row + 1, rootInfo.col - 1, root.left.val);
+			collects.add(leftInfo);
+			dfs(root.left, leftInfo, collects);
+		}
+		if (root.right != null) {
+			Info rightInfo = new Info(rootInfo.row + 1, rootInfo.col + 1, root.right.val);
+			collects.add(rightInfo);
+			dfs(root.right, rightInfo, collects);
+		}
+	}
+
+}
diff --git a/算法周更�/class_2023_02_2_week/Code03_WidthOfBinaryTree.java b/算法周更�/class_2023_02_2_week/Code03_WidthOfBinaryTree.java
new file mode 100644
index 0000000..31cf6b0
--- /dev/null
+++ b/算法周更�/class_2023_02_2_week/Code03_WidthOfBinaryTree.java
@@ -0,0 +1,54 @@
+package class_2023_02_2_week;
+
+import java.util.LinkedList;
+
+// 给你一棵二�树的根节点 root ，返回树的 最大宽度 。
+// 树的 最大宽度 是所有层中最大的 宽度 。
+// �一层的 宽度 被定义为该层最左和最�的�空节点（�，两个端点）之间的长度。
+// 将这个二�树视作与满二�树结构相�，两端点间会出现一些延伸到这一层的 null 节点，
+// 这些 null 节点也计入长度。
+// 题目数���答案将会在  32 � 带符�整数范围内。
+// 测试链接 : https://leetcode.cn/problems/maximum-width-of-binary-tree/
+public class Code03_WidthOfBinaryTree {
+
+	// ��交这个类
+	public static class TreeNode {
+		public int val;
+		public TreeNode left;
+		public TreeNode right;
+	}
+
+	// �交以下所有的方法
+	public static class Info {
+		// 当�节点
+		public TreeNode node;
+		// 编��
+		public int index;
+
+		public Info(TreeNode n, int i) {
+			node = n;
+			index = i;
+		}
+	}
+
+	public static int widthOfBinaryTree(TreeNode root) {
+		int ans = 1;
+		LinkedList<Info> queue = new LinkedList<>();
+		queue.add(new Info(root, 1));
+		while (!queue.isEmpty()) {
+			ans = Math.max(ans, queue.peekLast().index - queue.peekFirst().index + 1);
+			int size = queue.size();
+			for (int i = 0; i < size; i++) {
+				Info cur = queue.pollFirst();
+				if (cur.node.left != null) {
+					queue.addLast(new Info(cur.node.left, cur.index * 2));
+				}
+				if (cur.node.right != null) {
+					queue.addLast(new Info(cur.node.right, cur.index * 2 + 1));
+				}
+			}
+		}
+		return ans;
+	}
+
+}
\ No newline at end of file
diff --git a/算法周更�/class_2023_02_2_week/Code04_MinimizeMalwareSpreadII.java b/算法周更�/class_2023_02_2_week/Code04_MinimizeMalwareSpreadII.java
new file mode 100644
index 0000000..0873c2e
--- /dev/null
+++ b/算法周更�/class_2023_02_2_week/Code04_MinimizeMalwareSpreadII.java
@@ -0,0 +1,144 @@
+package class_2023_02_2_week;
+
+import java.util.Arrays;
+
+// 给定一个由 n 个节点组�的网络，用 n x n 个邻接矩阵 graph 表示
+// 在节点网络中，�有当 graph[i][j] = 1 时，节点 i 能够直接连接到�一个节点 j。
+// 一些节点 initial 最�被��软件感染。��两个节点直接连接，
+// 且其中至少一个节点�到��软件的感染，那么两个节点都将被��软件感染。
+// 这���软件的传播将继续，直到没有更多的节点�以被这�方�感染。
+// �设 M(initial) 是在��软件�止传播之�，整个网络中感染��软件的最终节点数。
+// 我们�以从 initial 中删除一个节点，
+// 并完全移除该节点以�从该节点到任何其他节点的任何连接。
+// 请返回移除�能够使 M(initial) 最�化的节点。
+// 如果有多个节点满足�件，返回索引 最�的节点 。
+// initial 中�个整数都��
+// 测试链接 : https://leetcode.cn/problems/minimize-malware-spread-ii/
+public class Code04_MinimizeMalwareSpreadII {
+
+	public int minMalwareSpread(int[][] graph, int[] initial) {
+		// 节点个数
+		int n = graph.length;
+		// 病毒数组，
+		// 病毒initial -> [3,6,9]
+		// virus[3] = true;
+		// virus[6] = true;
+		// virus[7] = false;
+		boolean[] virus = new boolean[n];
+		for (int i : initial) {
+			virus[i] = true;
+		}
+		// 建立并查集
+		// n大� 0~n-1
+		UnionFind uf = new UnionFind(n);
+		// 忽略感染点�其链接�
+		// �并集��
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < n; j++) {
+				// i, j ?
+				if (graph[i][j] == 1 && !virus[i] && !virus[j]) {
+					uf.union(i, j);
+				}
+			}
+		}
+		// 所有�感染点，该链接都链接了�
+		// 0,6,7,8 是一个集�
+		// 6被选�了代表点，无法控制，�由并查集自己决定
+		// infect[6] == -1 ，目�这个集�没有感染�
+		// infect[6] == -2 ，目�这个集�已��现了��一个感染�
+		// infect[6] == x x>=0，目�这个集�已��现了一个感染�，是x点
+		int[] infect = new int[n];
+		// 目�所有集�都没有感染�
+		Arrays.fill(infect, -1);
+		for (int v : initial) { // 枚举所有感染点�
+			// 当�感染点是v
+			// 跟v链接的所有点，next
+			// n = 7  编�0~6
+			// n = 13 编�0~12
+			for (int next = 0; next < n; next++) {
+				if (v != next && !virus[next] && graph[v][next] == 1) {
+					// next 无辜点
+					// 找到next集�所在的代表点，f
+					int f = uf.find(next);
+					if (infect[f] == -1) {
+						infect[f] = v;
+					} else { // != -1  �能 == -2 或者 >= 0 
+						// 之�的感染点 -> infect[f]
+						if (infect[f] != -2 && infect[f] != v) {
+							infect[f] = -2;
+						}
+						// infect[f] == -2
+						// infect[f] == v
+						// 这两�情况，一律�设置是符�预期的
+					}
+				}
+			}
+		}
+		int[] cnt = new int[n];
+		for (int i = 0; i < n; i++) {
+			if (infect[i] >= 0) {
+				cnt[infect[i]] += uf.size[i];
+			}
+		}
+		// 4 -> 13
+		// 0 -> 6
+		// 1 -> 5
+		// 13 -> 50
+		// 9 -> 20
+		// 0 1 4   9 13 14 15
+		// 6 5 13 20 50 34 7
+		Arrays.sort(initial);
+		int ans = initial[0];
+		int count = cnt[ans];
+		for (int i : initial) {
+			if (cnt[i] > count) {
+				ans = i;
+				count = cnt[i];
+			}
+		}
+		return ans;
+	}
+
+	public static class UnionFind {
+		public int[] father;
+		public int[] size;
+		public int[] help;
+
+		public UnionFind(int n) {
+			father = new int[n];
+			size = new int[n];
+			help = new int[n];
+			for (int i = 0; i < n; i++) {
+				father[i] = i;
+				size[i] = 1;
+			}
+		}
+
+		public int find(int i) {
+			int hi = 0;
+			while (i != father[i]) {
+				help[hi++] = i;
+				i = father[i];
+			}
+			while (hi != 0) {
+				father[help[--hi]] = i;
+			}
+			return i;
+		}
+
+		public 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];
+				}
+			}
+		}
+	}
+
+}
diff --git a/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播) b/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播)
index 8b87a4c..c63d9c8 100644
--- a/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播)
+++ b/算法课堂笔记/课堂内容汇总/�周有�养的大厂算法�试题(正在直播)
@@ -2911,5 +2911,65 @@ k�翻转 就是从 nums 中选择一个长度为 k 的 �数组
 
 
 
+第057节 2023年2月第2周�行算法题目解�
+
+你的音�播放器里有 N 首��的歌
+在旅途中，你的旅伴想�� L 首歌（�一定��，�，�许歌曲��
+请你为她按如下规则创建一个播放列表
+�首歌至少播放一次
+一首歌�有在其他 K 首歌播放完之��能�次播放
+返回�以满足�求的播放列表的数�
+由于答案�能�常大，请返回它模 10^9 + 7 的结果
+测试链接 : https://leetcode.cn/problems/number-of-music-playlists/
+
+给你二�树的根结点 root ，请你设计算法计算二�树的 垂��历 �列。
+对�于 (row, col) 的�个结点而言，
+其左��结点分别�于 (row + 1, col - 1) 和 (row + 1, col + 1)
+树的根结点�于 (0, 0) 。
+二�树的 垂��历 从最左边的列开始直到最�边的列结�，按列索引�一列上的所有结点，
+形�一个按出现�置从上到下排�的有�列表。如果�行�列上有多个结点，
+则按结点的值从�到大进行排�。
+返回二�树的 垂��历 �列。
+测试链接 : https://leetcode.cn/problems/vertical-order-traversal-of-a-binary-tree/
+
+给你一棵二�树的根节点 root ，返回树的 最大宽度 。
+树的 最大宽度 是所有层中最大的 宽度 。
+�一层的 宽度 被定义为该层最左和最�的�空节点（�，两个端点）之间的长度。
+将这个二�树视作与满二�树结构相�，两端点间会出现一些延伸到这一层的 null 节点，
+这些 null 节点也计入长度。
+题目数���答案将会在  32 � 带符�整数范围内。
+测试链接 : https://leetcode.cn/problems/maximum-width-of-binary-tree/
+
+给定一个由 n 个节点组�的网络，用 n x n 个邻接矩阵 graph 表示
+在节点网络中，�有当 graph[i][j] = 1 时，节点 i 能够直接连接到�一个节点 j。
+一些节点 initial 最�被��软件感染。��两个节点直接连接，
+且其中至少一个节点�到��软件的感染，那么两个节点都将被��软件感染。
+这���软件的传播将继续，直到没有更多的节点�以被这�方�感染。
+�设 M(initial) 是在��软件�止传播之�，整个网络中感染��软件的最终节点数。
+我们�以从 initial 中删除一个节点，
+并完全移除该节点以�从该节点到任何其他节点的任何连接。
+请返回移除�能够使 M(initial) 最�化的节点。
+如果有多个节点满足�件，返回索引 最�的节点 。
+initial 中�个整数都��
+测试链接 : https://leetcode.cn/problems/minimize-malware-spread-ii/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+