• 怒刷LeetCode的第10天（Java版）

    目录

    第一题

    题目来源

    题目内容

    解决方法

    方法一：两次拓扑排序

    第二题

    题目来源

    题目内容

    解决方法

    方法一：分治法

    方法二：优先队列（Priority Queue）

    方法三：迭代

    第三题

    题目来源

    题目内容

    解决方法

    方法一：迭代

    方法二：递归

    方法三：双指针

    方法四：栈

    第一题

    题目来源

    2603. 收集树中金币 - 力扣（LeetCode）

    题目内容

    解决方法

    方法一：两次拓扑排序

    这个解法的思路如下：

    1. 首先，初始化一个邻接表 g，用于存储树的结构，以及一个数组 degree，用于记录每个节点的度数。
    2. 遍历边的数组 edges，将每条边的两个节点之间建立连接关系，并更新节点的度数。
    3. 初始化一个队列 queue，用于存储无金币的叶子节点。
    4. 遍历所有节点，如果一个节点的度数为1并且该节点没有金币，则将其加入队列。
    5. 开始循环，直到队列为空。在每次迭代中，取出队列的首个节点 u。
    6. 将节点 u 的度数减1，剩余节点数 rest 减1。
    7. 遍历与节点 u 相邻的所有节点 v，将其度数减1。
    8. 如果节点 v 的度数为1并且该节点没有金币，则将其加入队列。
    9. 重复步骤 5-8，直到队列为空。
    10. 重复两次以下步骤（总共遍历两次）： a. 初始化一个新的队列 queue。 b. 遍历所有节点，将度数为1的节点加入队列。 c. 开始循环，直到队列为空。 d. 取出队列的首个节点 u，将其度数减1，剩余节点数 rest 减1。 e. 遍历与节点 u 相邻的所有节点 v，将其度数减1。 f. 重复步骤 d-e，直到队列为空。
    11. 返回结果，如果剩余节点数 rest 为0，则路径长度为0；否则，路径长度为 (rest - 1) * 2。

    这样，通过删除树中无金币的叶子节点和维护节点的度数，可以得到最小路径长度。

    1. class Solution {
    2.     public int collectTheCoins(int[] coins, int[][] edges) {
    3.         int n = coins.length;
    4.         List[] g = new List[n];
    5.         for (int i = 0; i < n; ++i) {
    6.             g[i] = new ArrayList();
    7.         }
    8.         int[] degree = new int[n];
    9.         for (int[] edge : edges) {
    10.             int x = edge[0], y = edge[1];
    11.             g[x].add(y);
    12.             g[y].add(x);
    13.             ++degree[x];
    14.             ++degree[y];
    15.         }
    16.  
    17.         int rest = n;
    18.         /* 删除树中所有无金币的叶子节点，直到树中所有的叶子节点都是含有金币的 */
    19.         Queue queue = new ArrayDeque();
    20.         for (int i = 0; i < n; ++i) {
    21.             if (degree[i] == 1 && coins[i] == 0) {
    22.                 queue.offer(i);
    23.             }
    24.         }
    25.         while (!queue.isEmpty()) {
    26.             int u = queue.poll();
    27.             --degree[u];
    28.             --rest;
    29.             for (int v : g[u]) {
    30.                 --degree[v];
    31.                 if (degree[v] == 1 && coins[v] == 0) {
    32.                     queue.offer(v);
    33.                 }
    34.             }
    35.         }
    36.         /* 删除树中所有的叶子节点, 连续删除2次 */
    37.         for (int x = 0; x < 2; ++x) {
    38.             queue = new ArrayDeque();
    39.             for (int i = 0; i < n; ++i) {
    40.                 if (degree[i] == 1) {
    41.                     queue.offer(i);
    42.                 }
    43.             }
    44.             while (!queue.isEmpty()) {
    45.                 int u = queue.poll();
    46.                 --degree[u];
    47.                 --rest;
    48.                 for (int v : g[u]) {
    49.                     --degree[v];
    50.                 }
    51.             }
    52.         }
    53.  
    54.         return rest == 0 ? 0 : (rest - 1) * 2;
    55.     }
    56. }

    复杂度分析：

    1、构建邻接表和计算节点度数的复杂度：

    • 遍历边的数组 edges，时间复杂度为 O(m)，其中 m 是边的数量。
    • 初始化邻接表 g 的空间复杂度为 O(n)，其中 n 是节点的数量。
    • 更新节点度数的过程需要遍历所有边，时间复杂度为 O(m)。

    2、删除无金币叶子节点的过程的复杂度：

    • 初始化队列的时间复杂度为 O(n)，其中 n 是节点的数量。
    • 每个节点最多被处理一次，因此删除过程的时间复杂度为 O(n)。

    3、连续删除两次叶子节点的过程的复杂度：

    • 需要进行两次完整的节点遍历，因此时间复杂度为 O(2n) = O(n)，其中 n 是节点的数量。

    综上所述，整个解法的时间复杂度为 O(m + n)，其中 m 是边的数量，n 是节点的数量。空间复杂度为 O(n)，用于存储邻接表和节点度数。

    LeetCode运行结果：

    第二题

    题目来源

    23. 合并 K 个升序链表 - 力扣（LeetCode）

    题目内容

    解决方法

    方法一：分治法

    这是一个合并K个升序链表的问题，可以使用分治法来解决。使用了分治法来将k个链表分成两部分进行合并，然后再将合并后的结果继续与剩下的链表合并，直到最终合并成一个升序链表。在每个合并的过程中，可以使用双指针来逐个比较两个链表的节点值，将较小的节点连接到结果链表上。

    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. public class Solution {
    12.     public ListNode mergeKLists(ListNode[] lists) {
    13.         if (lists == null || lists.length == 0) {
    14.             return null;
    15.         }
    16.  
    17.         return merge(lists, 0, lists.length - 1);
    18.     }
    19.  
    20.     private ListNode merge(ListNode[] lists, int start, int end) {
    21.         if (start == end) {
    22.             return lists[start];
    23.         }
    24.  
    25.         int mid = start + (end - start) / 2;
    26.         ListNode left = merge(lists, start, mid);
    27.         ListNode right = merge(lists, mid + 1, end);
    28.  
    29.         return mergeTwoLists(left, right);
    30.     }
    31.  
    32.     private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    33.         if (l1 == null) {
    34.             return l2;
    35.         }
    36.         if (l2 == null) {
    37.             return l1;
    38.         }
    39.  
    40.         if (l1.val < l2.val) {
    41.             l1.next = mergeTwoLists(l1.next, l2);
    42.             return l1;
    43.         } else {
    44.             l2.next = mergeTwoLists(l1, l2.next);
    45.             return l2;
    46.         }
    47.     }
    48. }

    复杂度分析：

    • 这个解法的时间复杂度是 O(Nlogk)，其中 N 是所有链表的节点总数，k 是链表的数量。因为在每层合并的过程中，需要遍历 N 个节点来比较值，并且每次合并的链表数量减半，因此总共需要合并 logk 层。所以时间复杂度是 O(Nlogk)。
    • 空间复杂度是 O(logk)，主要是递归调用栈的空间。在每一层递归中，都会创建两个新的递归函数调用，所以递归的层数最多是 logk。因此，空间复杂度是 O(logk)。

    需要注意的是，这里的空间复杂度是指除了返回的合并后的链表之外的额外空间使用量。

    LeetCode运行结果：

    方法二：优先队列（Priority Queue）

    使用了优先队列来维护当前k个链表中的最小节点。首先，将所有链表的头节点加入到优先队列中。然后，不断从优先队列中取出最小的节点，将其加入到合并后的链表中，并将该节点的下一个节点加入到队列中。重复这个过程直到队列为空。 

    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. public class Solution {
    12.     public ListNode mergeKLists(ListNode[] lists) {
    13.         if (lists == null || lists.length == 0) {
    14.             return null;
    15.         }
    16.  
    17.         // 创建一个优先队列，按照节点值的大小进行排序
    18.         PriorityQueue queue = new PriorityQueue<>((a, b) -> a.val - b.val);
    19.  
    20.         // 将所有链表的头节点加入到优先队列中
    21.         for (ListNode node : lists) {
    22.             if (node != null) {
    23.                 queue.offer(node);
    24.             }
    25.         }
    26.  
    27.         // 创建一个dummy节点作为合并后的链表头部
    28.         ListNode dummy = new ListNode(0);
    29.         ListNode curr = dummy;
    30.  
    31.         // 不断从优先队列中取出最小的节点，将其加入到合并后的链表中，然后将该节点的下一个节点加入到队列中
    32.         while (!queue.isEmpty()) {
    33.             ListNode node = queue.poll();
    34.             curr.next = node;
    35.             curr = curr.next;
    36.  
    37.             if (node.next != null) {
    38.                 queue.offer(node.next);
    39.             }
    40.         }
    41.  
    42.         return dummy.next;
    43.     }
    44. }

    复杂度分析：

    • 这个基于优先队列的解法的时间复杂度是O(Nlogk)，其中N是所有链表的节点总数，k是链表的数量。主要的时间消耗在于构建优先队列和从队列中取出最小节点，而构建优先队列的时间复杂度是O(klogk)，每次取出最小节点的操作时间复杂度是O(logk)。由于总共需要取出N个节点，因此总体的时间复杂度是O(Nlogk)。
    • 空间复杂度是O(k)，主要是优先队列所占用的空间。在最坏情况下，优先队列中最多会有k个节点，因此空间复杂度是O(k)。

    需要注意的是，这里的空间复杂度是指除了返回的合并后的链表之外的额外空间使用量。

    LeetCode运行结果：

    方法三：迭代

    使用了迭代的方式逐一合并链表。

    1. 首先设定一个变量 interval，初始值为1，表示每次合并的链表数量。
    2. 然后进行循环，直到 interval 大于等于链表数组的长度。在每次循环中，按照 interval 的步长对链表数组进行逐一合并。每次合并两个链表，将合并结果放回原始数组的相应位置。
    3. 通过每次将 interval 值翻倍，循环进行迭代合并，直到 interval 大于等于链表数组的长度，最终得到合并后的链表。
    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. class Solution {
    12.     public ListNode mergeKLists(ListNode[] lists) {
    13.         if (lists == null || lists.length == 0) {
    14.             return null;
    15.         }
    16.         
    17.         int interval = 1;
    18.         while (interval < lists.length) {
    19.             for (int i = 0; i + interval < lists.length; i += 2 * interval) {
    20.                 lists[i] = mergeTwoLists(lists[i], lists[i + interval]);
    21.             }
    22.             interval *= 2;
    23.         }
    24.         
    25.         return lists[0];
    26.     }
    27.     
    28.     private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    29.         ListNode dummy = new ListNode(0);
    30.         ListNode curr = dummy;
    31.         
    32.         while (l1 != null && l2 != null) {
    33.             if (l1.val < l2.val) {
    34.                 curr.next = l1;
    35.                 l1 = l1.next;
    36.             } else {
    37.                 curr.next = l2;
    38.                 l2 = l2.next;
    39.             }
    40.             curr = curr.next;
    41.         }
    42.         
    43.         if (l1 != null) {
    44.             curr.next = l1;
    45.         }
    46.         
    47.         if (l2 != null) {
    48.             curr.next = l2;
    49.         }
    50.         
    51.         return dummy.next;
    52.     }
    53. }

    复杂度分析：

    • 时间复杂度：这个解法的时间复杂度是O(Nklogk)，其中N是每个链表的平均长度，k是链表的数量。通过每次将 interval 值翻倍，循环进行迭代合并，直到 interval 大于等于链表数组的长度，最终得到合并后的链表。在每一层循环中的操作总时间复杂度仍然是O(Nk)，因为每一层的合并操作需要遍历所有链表节点。
    • 空间复杂度：这个解法的空间复杂度是O(1)，没有使用额外的数据结构。只需要常数级别的额外空间来保存临时变量。

    综上所述，优先队列解法和分治法解法的时间复杂度相同，但优先队列解法的空间复杂度略高于分治法解法。而迭代解法的时间复杂度稍高于前两种解法，并且空间复杂度较低。

    LeetCode运行结果：

    第三题

    题目来源

    24. 两两交换链表中的节点 - 力扣（LeetCode）

    题目内容

    解决方法

    方法一：迭代

    迭代的思路是遍历链表，每次处理两个相邻节点进行交换。具体步骤如下：

    1、定义一个哑节点(dummy)作为新链表的头节点，并将其指向原始链表的头节点head。

    2、定义一个指针prev指向哑节点，用于连接新链表中的节点。

    3、当原始链表中至少有两个节点时，重复以下操作：

    • 使用指针curr1指向当前要交换的第一个节点，即prev.next。
    • 使用指针curr2指向当前要交换的第二个节点，即curr1.next。
    • 将prev的下一个节点指向curr2，完成节点交换。
    • 将curr1的下一个节点指向curr2的下一个节点，完成节点交换。
    • 将curr2的下一个节点指向curr1，完成节点交换。
    • 更新prev指针和curr1指针，使它们分别指向交换后的第二个节点和下一组要交换的第一个节点。

    4、返回哑节点(dummy)的下一个节点作为新链表的头节点。

    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. class Solution {
    12. public ListNode swapPairs(ListNode head) {
    13.     ListNode dummy = new ListNode(0);
    14.     dummy.next = head;
    15.     ListNode prev = dummy;
    16.     
    17.     while (head != null && head.next != null) {
    18.         ListNode curr1 = head;
    19.         ListNode curr2 = head.next;
    20.         
    21.         prev.next = curr2;
    22.         curr1.next = curr2.next;
    23.         curr2.next = curr1;
    24.         
    25.         prev = curr1;
    26.         head = curr1.next;
    27.     }
    28.     
    29.     return dummy.next;
    30. }
    31.  
    32. }

    复杂度分析：

    • 时间复杂度：O(n)，其中n是链表中的节点数。需要遍历链表中的每个节点一次。
    • 空间复杂度：O(1)。只需要常数级别的额外空间。

    LeetCode运行结果：

    方法二：递归

    递归的思路是将链表分成两部分：第一个节点和剩余节点。然后，交换这两部分，并递归地对剩余节点进行两两交换。具体步骤如下：

    1. 当链表为空或只有一个节点时，无需交换，直接返回该节点。
    2. 令first指向链表的头节点，second指向first的下一个节点。
    3. 交换first和second节点，即将second的next指向first，并将first的next指向递归处理剩余节点的结果。
    4. 返回second节点作为新链表的头节点。
    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. class Solution {
    12. public ListNode swapPairs(ListNode head) {
    13.     if (head == null || head.next == null) {
    14.         return head;
    15.     }
    16.     
    17.     ListNode first = head;
    18.     ListNode second = head.next;
    19.     
    20.     first.next = swapPairs(second.next);
    21.     second.next = first;
    22.     
    23.     return second;
    24. }
    25. }

    复杂度分析：

    • 时间复杂度：O(n)，其中n是链表中的节点数。每次递归都会处理一个节点，并且递归调用的层数最多为n/2。
    • 空间复杂度：O(n)，其中n是链表中的节点数。递归调用的栈空间最多为n/2。

    LeetCode运行结果：

    方法三：双指针

    除了递归和迭代之外，还可以使用双指针的方法来交换链表中的节点。该方法使用两个指针prev和curr分别指向当前要交换的两个节点的前一个节点和第一个节点。通过不断地交换节点，并更新指针，实现链表中节点的两两交换。

    注意：它与迭代方法的思路类似，但在细节上有所改动。

    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. class Solution {
    12. public ListNode swapPairs(ListNode head) {
    13.     // 创建哑节点(dummy)作为新链表的头节点，并将其指向原始链表的头节点head
    14.     ListNode dummy = new ListNode(0);
    15.     dummy.next = head;
    16.     
    17.     // 定义两个指针prev和curr，分别指向当前要交换的两个节点的前一个节点和第一个节点
    18.     ListNode prev = dummy;
    19.     ListNode curr = head;
    20.     
    21.     while (curr != null && curr.next != null) {
    22.         // 获取要交换的两个节点
    23.         ListNode node1 = curr;
    24.         ListNode node2 = curr.next;
    25.         
    26.         // 进行节点交换
    27.         prev.next = node2;
    28.         node1.next = node2.next;
    29.         node2.next = node1;
    30.         
    31.         // 更新prev和curr指针，进行下一组节点交换
    32.         prev = node1;
    33.         curr = node1.next;
    34.     }
    35.     
    36.     return dummy.next;
    37. }
    38.  
    39. }

    复杂度分析：

    • 时间复杂度：O(n)  遍历链表中的每个节点一次，所以时间复杂度是线性的。
    • 空间复杂度：O(1)  只使用了常数级别的额外空间，不随输入规模增加而变化。

    LeetCode运行结果：

    方法四：栈

    除了递归、双指针和迭代之外，还可以使用栈来实现链表节点的两两交换。

    这种栈的方法将链表中的节点依次入栈，每次栈中至少有两个节点时，就进行交换操作。通过维护栈来实现链表节点的两两交换。

    1. /**
    2.  * Definition for singly-linked list.
    3.  * public class ListNode {
    4.  *     int val;
    5.  *     ListNode next;
    6.  *     ListNode() {}
    7.  *     ListNode(int val) { this.val = val; }
    8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    9.  * }
    10.  */
    11. class Solution {
    12. public ListNode swapPairs(ListNode head) {
    13.     // 创建一个栈
    14.     Deque stack = new ArrayDeque<>();
    15.     ListNode dummy = new ListNode(0);
    16.     dummy.next = head;
    17.     
    18.     ListNode curr = dummy;
    19.     
    20.     while (curr != null && curr.next != null) {
    21.         // 将当前节点的后继节点和后继的后继节点入栈
    22.         stack.push(curr.next);
    23.         stack.push(curr.next.next);
    24.         
    25.         // 当栈中至少有两个节点时，进行节点交换
    26.         if (stack.size() >= 2) {
    27.             curr.next = stack.pop();
    28.             curr.next.next = stack.pop();
    29.             curr = curr.next.next;
    30.         } else {
    31.             break;
    32.         }
    33.     }
    34.     
    35.     return dummy.next;
    36. }
    37.  
    38. }

    复杂度分析：

    • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表中的每个节点一次。
    • 空间复杂度：O(n)，需要使用一个栈来存储节点。

    需要注意的是，递归的深度与链表的长度相关，当链表较长时可能会导致栈溢出，因此在实际使用时需要注意链表的长度限制。如果链表长度较大，建议使用其他方法实现节点的交换。

    LeetCode运行结果：

  • 相关阅读:
    北斗导航 | 中长基线 RTK 定位研究（BDS-3）
    【论文阅读】时序动作检测系列论文精读（2018年）
    分享我做Dotnet9博客网站时积累的一些资料
    C++——多态、虚表、单继承、多继承、覆盖、联编
    前端 WebSocket 的使用
    人大金仓分析型数据库使用之创建和管理表空间
    KNN（上）：数据分析 | 数据挖掘 | 十大算法之一
    【问题记录】audio标签变更currentTime属性值无效，currentTime变为0
    机器学习笔记：Huber Loss & smooth L1 loss
    神经网络优化算法有哪些,人工神经网络优化算法
  • 原文地址：https://blog.csdn.net/m0_74293254/article/details/133131887