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];
}
}
}
Solution
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;
}
}
Solution
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;
}
}
Solution
标签：三则,sort,int,队比,nums1,length,LeetCode,nums2 From： https://www.cnblogs.com/xxaxf/p/18133540