LeetCode竞赛---第 366 场周赛

布满荆棘的人生 2024-04-24 23:18 59阅读 0赞

> Problem: [100103. 分类求和并作差][100103.]

? 题目：给你两个正整数 n 和 m 。

现定义两个整数 num1 和 num2 ，如下所示：

*  num1：范围 \[1, n\] 内所有 无法被 m 整除 的整数之和。
 *  num1：范围 \[1, n\] 内所有 无法被 m 整除 的整数之和。

返回整数 num1 - num2 。

**示例 1：**  
输入：n = 5, m = 6  
输出：15

**示例 2：**  
输入：n = 10, m = 3  
输出：19

✅ 模板：C++

class Solution {
        
    public:
        int differenceOfSums(int n, int m) {
        
            
        }
    };

? 思路：定义ans 和 res 记录答案，然后根据题目要求遍历数组即可

## Code ##

class Solution 
    {
        
    public:
      int differenceOfSums(int n, int m) 
      {
        
          int res = 0;
          int ans = 0;
          
          for(int i = 1 ; i <= n ; ++ i)
          {
        
              if(i % m == 0) ans += i;
              else res += i;
          }
          return res - ans;
      }
    };

? 运行结果如下：  
![在这里插入图片描述][8525bc63e3e6485bb60663dfecc8cf08.png]

> Problem: [100085. 最小处理时间][100085.]

? 题目：给你两个正整数 n 和 m 。

你有 n 颗处理器，每颗处理器都有 4 个核心。现有 n \* 4 个待执行任务，每个核心只执行 一个 任务。

给你一个下标从 0 开始的整数数组 processorTime ，表示每颗处理器最早空闲时间。另给你一个下标从 0 开始的整数数组 tasks ，表示执行每个任务所需的时间。返回所有任务都执行完毕需要的 最小时间 。

注意：每个核心独立执行任务。

**示例 1：**  
输入：processorTime = \[8,10\], tasks = \[2,2,3,1,8,7,4,5\]  
输出：16

**示例 2：**  
输入：processorTime = \[10,20\], tasks = \[2,3,1,2,5,8,4,3\]  
输出：23

✅ 模板：C++

class Solution {
        
    public:
        int minProcessingTime(vector<int>& processorTime, vector<int>& tasks) {
        
            
        }
    };

? 思路：对数组processorTime 和 数组 tasks 进行sort排序 然后以四为单位找到四个数的最大值存放到新的数组res数组里面，最后根据题意求出最大值ans即可

## Code ##

class Solution 
    {
        
    public:
      int minProcessingTime(vector<int>& processorTime, vector<int>& tasks) 
      {
        
          sort(processorTime.begin(),processorTime.end());
          sort(tasks.begin(),tasks.end());
         
          vector<int> res;
          int cnt = 0, ans = 0;
          for(int i = 0 ; i < tasks.size() ; ++ i)
          {
        
              cnt ++;
              if(tasks[i] > ans)
                  ans = tasks[i];
              if(cnt == 4)
              {
        
                  res.push_back(ans);
                  ans = 0;
                  cnt = 0;
              }
          }
          int anser = 0;
          for(int i = 0 ; i < res.size(); i ++)
          {
        
              if(res[i] + processorTime[res.size() - 1 - i] > anser)
                  anser = res[i] + processorTime[res.size() - 1 - i];
          }
          return anser;
      }
    };

? 运行结果如下：  
![在这里插入图片描述][a68b70b12b9e4a3a8b1825b034c0f209.png]  
剩下的两道题我是死活不会写…啊啊啊啊啊啊动态规划 + 脑筋急转弯吧，还是需要多学习

![在这里插入图片描述][10188df3a21343ebbc9dae229a44d397.png]

[100103.]: https://leetcode.cn/problems/divisible-and-non-divisible-sums-difference/description/
[8525bc63e3e6485bb60663dfecc8cf08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/28c4e5f4d0114b63ab2d3b4aee93ad6c.png
[100085.]: https://leetcode.cn/problems/minimum-processing-time/description/
[a68b70b12b9e4a3a8b1825b034c0f209.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/9f60865d76ca424f95e9f51b7d27bfa5.png
[10188df3a21343ebbc9dae229a44d397.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/24/41a1289d4b3e4a8db738e0115ef8a7dc.png