LeetCode三则

1.

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1:
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2:
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

/**
 * @author XiSoil
 * @date 2024/04/13 20:43
 *执行分布用时1ms,击败的100.00%Java用户
 *消耗内存分布44.80MB,击败的64.20%Java用户
 **/
public class Solution {

    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int sort[] = new int[nums1.length + nums2.length];
        int i = 0, j = 0, k = 0;
        while (i < nums1.length && j < nums2.length) {
            if (nums1[i] < nums2[j]) {
                sort[k] = nums1[i];
                i++;
            } else {
                sort[k] = nums2[j];
                j++;
            }
            k++;
        }
        while (i < nums1.length) {
            sort[k] = nums1[i];
            i++;
            k++;
        }
        while (j < nums2.length) {
            sort[k] = nums2[j];
            j++;
            k++;
        }
        if (sort.length % 2 == 0) {
            return (double) (sort[sort.length / 2 - 1] + sort[sort.length / 2]) / 2;
        } else {
            return (double) sort[sort.length / 2];
        }
    }
}

2.

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

public class Solution {
/**
 * @author XiSoil
 * @date 2024/04/13 22:28
 *执行分布用时0ms,击败的100.00%Java用户
 *消耗内存分布39.48MB,击败的16.42%Java用户
 **/
    public int climbStairs(int n) {
        int a = 1, b = 2;
        if (n == 1) {
            return a;
        }
        if (n == 2) {
            return b;
        }
        int c = 0;
        for (int i = 3; i <= n; i++) {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}

3.

一场比赛中共有 n 支队伍，按从 0 到  n - 1 编号。每支队伍也是 有向无环图（DAG） 上的一个节点。

给你一个整数 n 和一个下标从 0 开始、长度为 m 的二维整数数组 edges 表示这个有向无环图，其中 edges[i] = [ui, vi] 表示图中存在一条从 ui 队到 vi 队的有向边。

从 a 队到 b 队的有向边意味着 a 队比 b 队 强 ，也就是 b 队比 a 队 弱 。

在这场比赛中，如果不存在某支强于 a 队的队伍，则认为 a 队将会是 冠军 。

如果这场比赛存在 唯一 一个冠军，则返回将会成为冠军的队伍。否则，返回 -1 。

注意

环 是形如 a1, a2, ..., an, an+1 的一个序列，且满足：节点 a1 与节点 an+1 是同一个节点；节点 a1, a2, ..., an 互不相同；对于范围 [1, n] 中的每个 i ，均存在一条从节点 ai 到节点 ai+1 的有向边。
有向无环图 是不存在任何环的有向图。

示例 1：
输入：n = 3, edges = [[0,1],[1,2]]
输出：0
解释：1 队比 0 队弱。2 队比 1 队弱。所以冠军是 0 队。

示例 2：
输入：n = 4, edges = [[0,2],[1,3],[1,2]]
输出：-1
解释：2 队比 0 队和 1 队弱。3 队比 1 队弱。但是 1 队和 0 队之间不存在强弱对比。所以答案是 -1 。

提示：
1 <= n <= 100
m == edges.length
0 <= m <= n * (n - 1) / 2
edges[i].length == 2
0 <= edge[i][j] <= n - 1
edges[i][0] != edges[i][1]
生成的输入满足：如果 a 队比 b 队强，就不存在 b 队比 a 队强
生成的输入满足：如果 a 队比 b 队强，b 队比 c 队强，那么 a 队比 c 队强

 

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[][] edges0 = {};
        int n0 = 1;
        int[][] edges1 = {{0, 1}, {1, 2}};
        int n1 = 3;
        int[][] edges2 = {{0, 2}, {1, 3}, {1, 2}};
        int n2 = 4;
        int[][] edges3 = {{0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}};
        int n3 = 6;
        int[][] edges4 = {{0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 0}};
        int n4 = 6;

        System.out.println(solution.findChampion(n0, edges0)); // 输出：0
        System.out.println(solution.findChampion(n1, edges1)); // 输出：0
        System.out.println(solution.findChampion(n2, edges2)); // 输出：-1
        System.out.println(solution.findChampion(n3, edges3)); // 输出：0
        System.out.println(solution.findChampion(n4, edges4)); // 输出：-1
    }

    public int findChampion(int n, int[][] edges) {
        // 创建一个布尔数组，用于标记每个参与者是否是失败者
        boolean[] isLoser = new boolean[n];

        // 遍历边缘数组，标记每个失败者
        for (int[] edge : edges) {
            isLoser[edge[1]] = true; // 边缘数组中第二个元素标记为失败者
        }

        // 统计非失败者的数量和下标
        int notLoserCount = 0;
        int notLoserIndex = -1;

        // 遍历所有参与者
        for (int i = 0; i < n; i++) {
            if (!isLoser[i]) {
                notLoserCount++; // 非失败者数量加1
                notLoserIndex = i; // 记录非失败者的下标
            }
        }

        // 如果只有一个非失败者，返回该非失败者的下标；否则返回 -1
        return notLoserCount == 1 ? notLoserIndex : -1;
    }

}