学习日记,java学习

news2025/1/14 0:57:57

题目

生病了,可能是羊了,喉咙好干,好难受

每日一题

1010. 总持续时间可被 60 整除的歌曲

难度中等268收藏分享切换为英文接收动态反馈

在歌曲列表中，第 i 首歌曲的持续时间为 time[i] 秒。

返回其总持续时间（以秒为单位）可被 60 整除的歌曲对的数量。形式上，我们希望下标数字 i 和 j 满足 i < j 且有 (time[i] + time[j]) % 60 == 0。

示例 1：

输入：time = [30,20,150,100,40]
输出：3
解释：这三对的总持续时间可被 60 整除：
(time[0] = 30, time[2] = 150): 总持续时间 180
(time[1] = 20, time[3] = 100): 总持续时间 120
(time[1] = 20, time[4] = 40): 总持续时间 60

示例 2：

输入：time = [60,60,60]
输出：3
解释：所有三对的总持续时间都是 120，可以被 60 整除。

提示：

1 <= time.length <= 6 * 104
1 <= time[i] <= 500

我的第一的想法是直接暴力枚举,这数据范围,n*n的时间我还以为可以过的

结果确实时间超限,后面想办法简化,想到了hash表,两个数的和可不可以被60整除,就看他们两个的除以60的和就可以了,那我们遍历一遍除以60得出余数为1到59的每个的个数

用大小为60 的数组来保证

n下标代表余数为n即可

p[h]和p[60-h]是可以凑成一对的

直接可以得出p[h]*p[h-1]对数

有两个特殊的p[30]和p[0]他们是要和自己来配对的

我们随机挑一个, 可以与p[0]-1个配对

再挑一个可以与p[0]-2个配对(有一个与自己是配完了的)

可以看到

是一个递增累加,用到公式 n*(an+1)/2

ok到这可以上代码了


int numPairsDivisibleBy60(int* time, int timeSize){
   long ans=0;
   long ko[60]={0};
   for(int h=0;h<timeSize;h++){
      ko[time[h]%60]++;
     
   }
   
    for(int h=1;h<=29;h++){
        ans+=ko[h]*ko[60-h];   
         
    }
    ans+=(ko[0]*(ko[0]-1))/2;
    ans+=(ko[30]*(ko[30]-1))/2;
  return ans;
}

代码是十分的简单 ,关键是简化的思路

2432. 处理用时最长的那个任务的员工

难度简单48收藏分享切换为英文接收动态反馈

共有 n 位员工，每位员工都有一个从 0 到 n - 1 的唯一 id 。

给你一个二维整数数组 logs ，其中 logs[i] = [idi, leaveTimei] ：

idi 是处理第 i 个任务的员工的 id ，且
leaveTimei 是员工完成第 i 个任务的时刻。所有 leaveTimei 的值都是唯一的。

注意，第 i 个任务在第 (i - 1) 个任务结束后立即开始，且第 0 个任务从时刻 0 开始。

返回处理用时最长的那个任务的员工的 id 。如果存在两个或多个员工同时满足，则返回几人中最小的 id 。

示例 1：

输入：n = 10, logs = [[0,3],[2,5],[0,9],[1,15]]
输出：1
解释：
任务 0 于时刻 0 开始，且在时刻 3 结束，共计 3 个单位时间。
任务 1 于时刻 3 开始，且在时刻 5 结束，共计 2 个单位时间。
任务 2 于时刻 5 开始，且在时刻 9 结束，共计 4 个单位时间。
任务 3 于时刻 9 开始，且在时刻 15 结束，共计 6 个单位时间。
时间最长的任务是任务 3 ，而 id 为 1 的员工是处理此任务的员工，所以返回 1 。

示例 2：

输入：n = 26, logs = [[1,1],[3,7],[2,12],[7,17]]
输出：3
解释：
任务 0 于时刻 0 开始，且在时刻 1 结束，共计 1 个单位时间。
任务 1 于时刻 1 开始，且在时刻 7 结束，共计 6 个单位时间。
任务 2 于时刻 7 开始，且在时刻 12 结束，共计 5 个单位时间。
任务 3 于时刻 12 开始，且在时刻 17 结束，共计 5 个单位时间。
时间最长的任务是任务 1 ，而 id 为 3 的员工是处理此任务的员工，所以返回 3 。

示例 3：

输入：n = 2, logs = [[0,10],[1,20]]
输出：0
解释：
任务 0 于时刻 0 开始，且在时刻 10 结束，共计 10 个单位时间。
任务 1 于时刻 10 开始，且在时刻 20 结束，共计 10 个单位时间。
时间最长的任务是任务 0 和 1 ，处理这两个任务的员工的 id 分别是 0 和 1 ，所以返回最小的 0 。

提示：

2 <= n <= 500
1 <= logs.length <= 500
logs[i].length == 2
0 <= idi <= n - 1
1 <= leaveTimei <= 500
idi != idi + 1
leaveTimei 按严格递增顺序排列

主要是把题目看懂吧,题目本身是十分简单的

所以看题目很重要的

问题是返回,用时最长的那个任务的执行人

任务的时长计算就是当前任务结束的时间和前一个任务结束时间中间的间隔

而且返回是id最小的,id是time[n][0]

欧克,题目看完了,遍历一遍就可以结束了

int hardestWorker(int n, int** logs, int logsSize, int* logsColSize){
   int a=logs[0][0];
   int max=logs[0][1];
   for(int h=1;h<logsSize;h++){
        if(logs[h][1]-logs[h-1][1]>max){
            a=logs[h][0];
            max=logs[h][1]-logs[h-1][1];
        }
        if(logs[h][1]-logs[h-1][1]==max){
                if(a>logs[h][0]){
                     a=logs[h][0];
            max=logs[h][1]-logs[h-1][1];
                }
        }
   }
   return a;
}

欧克

接下来,是java的学习进度

到今天是学习到了,继承了

把笔记给记录一下