数据结构学习笔记3--数组（leetcode2054. 两个最好的不重叠活动【未解出】）

package arrays;
public class ArrayTest07 
{public static void main(String[] args) {
int num1=10;
int num2=10;
int num3=10;
add(num1,num2,num3);
}
private static void add(int ...num) {
// TODO Auto-generated method stubint 
sum=0;
for(int n:num){
sum+=n;
}
System.out.print(sum);
}
private static void add(String str,int ...num) {
// TODO Auto-generated method stubint sum=0;
for(int n:num){
sum+=n;
}
System.out.print(sum);
}
}

可变参数的一些题目

顺序匹配

重载了5个函数，运行哪个

1.完全匹配

2.最近最优原则匹配

byte ->short -> int -> long -> float ->double不存在该类型参数向上匹配

3.包装类

Integer Short.......

包装类的调用顺序与基本类不同，Short可以被调用

4.可变参数

package arrays;
public class ArrayTest07 {
public static void main(String[] args) {
short s=20;
fun(10,s);
}
private static void fun(int num1,short num2) {
System.out.print("int short");
}
private static void fun(int num1,int num2) {
System.out.print("int int");
}
private static void fun(int num1,long num2) {
System.out.print("int long");
}
private static void fun(Integer num1,Short num2) {
System.out.print("Integer Short");
}
private static void fun(int ...num) {
System.out.print("可变参数");
}
}

子类用数组重载父类

可变参数遇到单独数字会自动包装成数组

而数组只能匹配数组

package arrays;public class ArrayTest07 {
public static void main(String[] args) {
F f = new S();
f.fun(10,10);
S s =new S();
//s.fun(10,10);此行会报错
}
class F{
void fun(int x,int ...y) {
System.out.print("F");
}
}
class S extends F{
@Overridevoid 
fun(int x,int[] y) {
System.out.print("S");
}
}
}

传输一个null值

null可以转换为任意的引用类型

以下程序存在二义性

package arrays;public class ArrayTest07 {
public static void main(String[] args) {
fun(10,null);//报错
}
private static void fun(int num1,int ...num) {
System.out.print("int short");
}
private static void fun(int num1,String ...num) {
System.out.print("int int");
}
}

函数会优先调用第二个

因为最近最优原则

package arrays;public class ArrayTest07 {
public static void main(String[] args) {
fun(null,10);
}
private static void fun(Object num1,Object ...num) {
System.out.print("int short");
}
private static void fun(String num1,Object x,Object ...y) {
System.out.print("int int");
}
}

如果改成下面的代码，则会出现二义性错误

package arrays;public class ArrayTest07 {
public static void main(String[] args) {
fun(null,10);
}
private static void fun(Integer num1,Object ...num) {
System.out.print("int short");
}
private static void fun(String num1,Object x,Object ...y) {
System.out.print("int int");
}
}

稀疏矩阵（数组）

用二维数组去模拟棋盘---->会存储很多的0来代表未落子

稀疏数组固定为3列

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5YWz5rOo5ZiJ54S25LuK5aSp5ZCD5LuA5LmI,size_20,color_FFFFFF,t_70,g_se,x_16

二维数组转稀疏矩阵

// 创建一个原始的二维数组 11 * 11
        int chessArr1[][] = new int[11][11];
        // 将二维数组 转 稀疏数组
        // 1. 先遍历二维数组 得到非0数据的个数(有效数据的个数)
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    sum++;
                }
            }
        }
        // 2. 创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        // 给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum; 
        // 遍历二维数组，将非0的值（有效数据的值）存放到 sparseArr中
        int count = 0; //count 用于记录是第几个非0数据
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

稀疏矩阵转二维数组

//1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        //如果大部分的数据（无效数据）不为0；需先遍历二维数组进行赋值
        //2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可
        //sparseArr[i][0]为有效数据所在的行号
        //sparseArr[i][1]为有效数据所在的列号
        //sparseArr[i][2]为有效数据的值
        for(int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

Leetcode2054. 两个最好的不重叠活动

给你一个下标从 0 开始的二维整数数组 events ，其中 events[i] = [startTimei, endTimei, valuei] 。第 i 个活动开始于 startTimei ，结束于 endTimei ，如果你参加这个活动，那么你可以得到价值 valuei 。你最多可以参加两个时间不重叠活动，使得它们的价值之和最大。

请你返回价值之和的最大值。

注意，活动的开始时间和结束时间是包括在活动时间内的，也就是说，你不能参加两个活动且它们之一的开始时间等于另一个活动的结束时间。更具体的，如果你参加一个活动，且结束时间为 t ，那么下一个活动必须在 t + 1 或之后的时间开始。

示例 1:

输入：events = [[1,3,2],[4,5,2],[2,4,3]]
输出：4
解释：选择绿色的活动 0 和 1 ，价值之和为 2 + 2 = 4 。

示例 2：

输入：events = [[1,3,2],[4,5,2],[1,5,5]]
输出：5
解释：选择活动 2 ，价值和为 5 。

示例 3：

输入：events = [[1,5,3],[1,5,1],[6,6,5]]
输出：8
解释：选择活动 0 和 2 ，价值之和为 3 + 5 = 8 。

提示：

2 <= events.length <= 105
events[i].length == 3
1 <= startTimei <= endTimei <= 109
1 <= valuei <= 106

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-best-non-overlapping-events
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

未解出

大佬的题解如下

作者：FalseBlank
链接：https://leetcode-cn.com/problems/two-best-non-overlapping-events/solution/java-pai-xu-er-fen-qian-zhui-zui-da-zhi-wwi92/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。