【2024年华为OD机试】 (B卷,100分)- 矩形相交的面积（Java JS PythonC/C++）

一、问题描述

题目描述

给出3组点坐标(x, y, w, h)，-1000<x,y<1000，w,h为正整数。
(x, y, w, h)表示平面直角坐标系中的一个矩形：
x, y为矩形左上角坐标点，w, h向右w，向下h。
(x, y, w, h)表示x轴(x, x+w)和y轴(y, y-h)围成的矩形区域；
(0, 0, 2, 2)表示 x轴(0, 2)和y 轴(0, -2)围成的矩形区域；
(3, 5, 4, 6)表示x轴(3, 7)和y轴(5, -1)围成的矩形区域；
求3组坐标构成的矩形区域重合部分的面积。

输入描述

3行输入分别为3个矩形的位置，分别代表“左上角x坐标”，“左上角y坐标”，“矩形宽”，“矩形高” -1000 <= x,y < 1000

输出描述

输出3个矩形相交的面积，不相交的输出0。

用例

输入

1 6 4 4
3 5 3 4
0 3 7 3

输出

2

说明
题目解析
为图示加上坐标

如上图所示，交叉区域的

长：Math.min(x1+w1, x2+w2, x3+w3) - Math.max(x1, x2, x3)

宽：Math.min(y1, y2, y3) - Math.max(y1-h1, y2-h2, y3-h3)

如果长度 <=0 或者 宽度<=0，则三个矩形不存在交叉区域，返回0

题目解析

本题要求计算三个矩形相交部分的面积。解题思路如下：

1. 解析输入：

   • 读取三个矩形的坐标和尺寸，分别表示为 (x1, y1, w1, h1)，(x2, y2, w2, h2)，(x3, y3, w3, h3)。

2. 计算相交区域：

   • 相交区域的x坐标范围：
     • 最小x坐标：Math.max(x1, x2, x3)
     • 最大x坐标：Math.min(x1+w1, x2+w2, x3+w3)
   • 相交区域的y坐标范围：
     • 最小y坐标：Math.max(y1-h1, y2-h2, y3-h3)
     • 最大y坐标：Math.min(y1, y2, y3)

3. 计算相交区域的长和宽：

   • 长：最大x坐标 - 最小x坐标
   • 宽：最大y坐标 - 最小y坐标

4. 判断相交区域是否存在：

   • 如果长 <= 0 或者 宽 <= 0，则三个矩形不存在相交区域，返回0。

5. 计算相交区域的面积：

   • 面积 = 长 * 宽

通过这种方法，我们可以有效地计算出三个矩形相交部分的面积。时间复杂度为O(1)，因为只需要进行几次简单的数学计算。

二、JavaScript算法源码

以下是这段 JavaScript 代码的详细中文注释与讲解。此代码的功能是计算三个矩形的重叠面积。

代码结构

这段代码分为两个主要部分：

1. 输入获取与事件监听：

   • 使用 readline 模块从控制台读取输入。
   • 监听输入事件，当输入达到 3 行时，触发计算逻辑。

2. 核心计算逻辑 (calSquare)：

   • 解析输入的矩形数据。
   • 计算三个矩形的重叠面积。

代码：

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline"); // 引入 readline 模块，用于读取控制台输入

// 创建 readline 接口
const rl = readline.createInterface({
  input: process.stdin,  // 输入流为标准输入
  output: process.stdout, // 输出流为标准输出
});

// 存储输入行的数组
const lines = [];

// 监听输入事件
rl.on("line", (line) => {
  lines.push(line); // 将每一行输入存入 lines 数组

  // 当输入达到 3 行时，触发计算逻辑
  if (lines.length === 3) {
    // 将每行输入按空格分割，并转换为数字数组
    let arr = lines.map((line) => line.split(" ").map((ele) => parseInt(ele)));

    // 调用核心计算函数，并输出结果
    console.log(calSquare(arr));

    // 清空 lines 数组，准备接收下一组输入
    lines.length = 0;
  }
});

// 核心计算函数：计算三个矩形的重叠面积
function calSquare(arr) {
  // 解构赋值，获取三个矩形的坐标和尺寸
  let [rect1, rect2, rect3] = arr;

  // 解构赋值，获取每个矩形的左上角坐标 (x, y) 以及宽度 (w) 和高度 (h)
  let [x1, y1, w1, h1] = rect1;
  let [x2, y2, w2, h2] = rect2;
  let [x3, y3, w3, h3] = rect3;

  // 计算重叠区域的宽度
  let width =
    Math.min(x1 + w1, x2 + w2, x3 + w3) - // 三个矩形右边界的最小值
    Math.max(x1, x2, x3); // 三个矩形左边界的最大值
  if (width <= 0) return 0; // 如果宽度小于等于 0，说明没有重叠区域，返回 0

  // 计算重叠区域的高度
  let height =
    Math.min(y1, y2, y3) - // 三个矩形上边界的最小值
    Math.max(y1 - h1, y2 - h2, y3 - h3); // 三个矩形下边界的最大值
  if (height <= 0) return 0; // 如果高度小于等于 0，说明没有重叠区域，返回 0

  // 返回重叠区域的面积
  return width * height;
}

详细讲解：

1. 输入获取与事件监听

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

• readline 模块：
  • 用于从控制台逐行读取输入。
  • createInterface 方法创建一个接口，绑定标准输入和输出。

const lines = [];

rl.on("line", (line) => {
  lines.push(line);

  if (lines.length === 3) {
    let arr = lines.map((line) => line.split(" ").map((ele) => parseInt(ele)));

    console.log(calSquare(arr));

    lines.length = 0;
  }
});

• lines 数组：

  • 用于存储每一行的输入。

• rl.on("line", ...)：

  • 监听输入事件，每次输入一行时触发回调函数。
  • 将每一行输入存入 lines 数组。

• lines.length === 3：

  • 当输入达到 3 行时，触发计算逻辑。

• lines.map(...)：

  • 将每行输入按空格分割，并转换为数字数组。
  • 例如，输入 1 2 3 4 会被转换为 [1, 2, 3, 4]。

• lines.length = 0：

  • 清空 lines 数组，准备接收下一组输入。

2. 核心计算逻辑 (calSquare)

function calSquare(arr) {
  let [rect1, rect2, rect3] = arr;

  let [x1, y1, w1, h1] = rect1;
  let [x2, y2, w2, h2] = rect2;
  let [x3, y3, w3, h3] = rect3;

• 解构赋值：
  • 从输入数组中提取三个矩形的数据。
  • 每个矩形的数据包括左上角坐标 (x, y)、宽度 w 和高度 h。

let width =
  Math.min(x1 + w1, x2 + w2, x3 + w3) - // 三个矩形右边界的最小值
  Math.max(x1, x2, x3); // 三个矩形左边界的最大值
if (width <= 0) return 0; // 如果宽度小于等于 0，说明没有重叠区域，返回 0

• 计算重叠区域的宽度：
  • 重叠区域的右边界是三个矩形右边界的最小值。
  • 重叠区域的左边界是三个矩形左边界的最大值。
  • 如果宽度小于等于 0，说明没有重叠区域，直接返回 0。

let height =
  Math.min(y1, y2, y3) - // 三个矩形上边界的最小值
  Math.max(y1 - h1, y2 - h2, y3 - h3); // 三个矩形下边界的最大值
if (height <= 0) return 0; // 如果高度小于等于 0，说明没有重叠区域，返回 0

• 计算重叠区域的高度：
  • 重叠区域的上边界是三个矩形上边界的最小值。
  • 重叠区域的下边界是三个矩形下边界的最大值。
  • 如果高度小于等于 0，说明没有重叠区域，直接返回 0。

return width * height;

• 返回重叠区域的面积：
  • 重叠区域的面积 = 宽度 × 高度。

代码运行示例

示例 1：

输入：

1 2 3 4
2 3 3 4
3 4 3 4

执行过程：

1. 输入三个矩形的数据：
   • 矩形 1：(x1=1, y1=2, w1=3, h1=4)
   • 矩形 2：(x2=2, y2=3, w2=3, h2=4)
   • 矩形 3：(x3=3, y3=4, w3=3, h3=4)
2. 计算重叠区域的宽度：
   • 右边界最小值：min(1+3, 2+3, 3+3) = min(4, 5, 6) = 4
   • 左边界最大值：max(1, 2, 3) = 3
   • 宽度：4 - 3 = 1
3. 计算重叠区域的高度：
   • 上边界最小值：min(2, 3, 4) = 2
   • 下边界最大值：max(2-4, 3-4, 4-4) = max(-2, -1, 0) = 0
   • 高度：2 - 0 = 2
4. 重叠区域面积：1 * 2 = 2

输出：

2

示例 2：

输入：

0 0 2 2
1 1 2 2
2 2 2 2

执行过程：

1. 输入三个矩形的数据：
   • 矩形 1：(x1=0, y1=0, w1=2, h1=2)
   • 矩形 2：(x2=1, y2=1, w2=2, h2=2)
   • 矩形 3：(x3=2, y3=2, w3=2, h3=2)
2. 计算重叠区域的宽度：
   • 右边界最小值：min(0+2, 1+2, 2+2) = min(2, 3, 4) = 2
   • 左边界最大值：max(0, 1, 2) = 2
   • 宽度：2 - 2 = 0
3. 由于宽度为 0，直接返回 0。

输出：

0

总结

1. 功能：

   • 计算三个矩形的重叠面积。

2. 优点：

   • 代码逻辑清晰，易于理解。
   • 使用解构赋值和数学方法简化了计算过程。

3. 适用场景：

   • 适用于需要计算多个矩形重叠面积的场景。

如果您有其他问题，欢迎随时提问！

三、Java算法源码

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    // 创建一个Scanner对象，用于从标准输入读取数据
    Scanner sc = new Scanner(System.in);

    // 读取第一个矩形的坐标和尺寸
    int x1 = sc.nextInt(); // 第一个矩形的左下角x坐标
    int y1 = sc.nextInt(); // 第一个矩形的左下角y坐标
    int w1 = sc.nextInt(); // 第一个矩形的宽度
    int h1 = sc.nextInt(); // 第一个矩形的高度

    // 读取第二个矩形的坐标和尺寸
    int x2 = sc.nextInt(); // 第二个矩形的左下角x坐标
    int y2 = sc.nextInt(); // 第二个矩形的左下角y坐标
    int w2 = sc.nextInt(); // 第二个矩形的宽度
    int h2 = sc.nextInt(); // 第二个矩形的高度

    // 读取第三个矩形的坐标和尺寸
    int x3 = sc.nextInt(); // 第三个矩形的左下角x坐标
    int y3 = sc.nextInt(); // 第三个矩形的左下角y坐标
    int w3 = sc.nextInt(); // 第三个矩形的宽度
    int h3 = sc.nextInt(); // 第三个矩形的高度

    // 计算三个矩形的重叠区域的宽度
    // getMin(x1 + w1, x2 + w2, x3 + w3) 获取三个矩形右边界的最小值
    // getMax(x1, x2, x3) 获取三个矩形左边界的最小值
    // wid = 右边界的最小值 - 左边界的最大值
    int wid = getMin(x1 + w1, x2 + w2, x3 + w3) - getMax(x1, x2, x3);
    if (wid <= 0) {
      // 如果宽度小于等于0，说明没有重叠区域，输出0并结束程序
      System.out.println(0);
      return;
    }

    // 计算三个矩形的重叠区域的高度
    // getMin(y1, y2, y3) 获取三个矩形上边界的最小值
    // getMax(y1 - h1, y2 - h2, y3 - h3) 获取三个矩形下边界的最大值
    // hei = 上边界的最小值 - 下边界的最大值
    int hei = getMin(y1, y2, y3) - getMax(y1 - h1, y2 - h2, y3 - h3);
    if (hei <= 0) {
      // 如果高度小于等于0，说明没有重叠区域，输出0并结束程序
      System.out.println(0);
      return;
    }

    // 计算并输出重叠区域的面积
    System.out.println(wid * hei);
  }

  // 获取三个数中的最大值
  public static int getMax(int n1, int n2, int n3) {
    int max = Math.max(n1, n2); // 先比较n1和n2，取最大值
    max = Math.max(max, n3); // 再将最大值与n3比较，取最大值
    return max;
  }

  // 获取三个数中的最小值
  public static int getMin(int n1, int n2, int n3) {
    int min = Math.min(n1, n2); // 先比较n1和n2，取最小值
    min = Math.min(min, n3); // 再将最小值与n3比较，取最小值
    return min;
  }
}

代码功能讲解：

1. 输入部分：

   • 代码首先通过Scanner对象从标准输入读取三个矩形的坐标和尺寸。每个矩形由左下角的坐标(x, y)、宽度w和高度h定义。

2. 重叠区域的计算：

   • 宽度计算：

     • 通过getMin(x1 + w1, x2 + w2, x3 + w3)获取三个矩形右边界的最小值。
     • 通过getMax(x1, x2, x3)获取三个矩形左边界的最大值。
     • 重叠区域的宽度wid为右边界的最小值减去左边界的最大值。
     • 如果wid <= 0，说明三个矩形在水平方向上没有重叠，直接输出0并结束程序。

   • 高度计算：

     • 通过getMin(y1, y2, y3)获取三个矩形上边界的最小值。
     • 通过getMax(y1 - h1, y2 - h2, y3 - h3)获取三个矩形下边界的最大值。
     • 重叠区域的高度hei为上边界的最小值减去下边界的最大值。
     • 如果hei <= 0，说明三个矩形在垂直方向上没有重叠，直接输出0并结束程序。

3. 输出结果：

   • 如果重叠区域的宽度和高度都大于0，则计算并输出重叠区域的面积wid * hei。

4. 辅助方法：

   • getMax(int n1, int n2, int n3)：返回三个数中的最大值。
   • getMin(int n1, int n2, int n3)：返回三个数中的最小值。

总结：

该代码的主要功能是计算三个矩形在二维平面上的重叠区域的面积。通过计算三个矩形在水平和垂直方向上的重叠部分，最终得到重叠区域的面积。如果没有重叠区域，则输出0。

四、Python算法源码

以下是这段 Python 代码的详细中文注释与讲解。此代码的功能是计算三个矩形的重叠面积。

代码结构

这段代码分为两个主要部分：

1. 输入获取：

   • 从控制台读取三个矩形的坐标和尺寸信息。

2. 核心算法 (getResult)：

   • 计算三个矩形的重叠面积。

代码：

# 输入获取：从控制台读取三个矩形的坐标和尺寸信息
x1, y1, w1, h1 = map(int, input().split())  # 矩形1的左上角坐标 (x1, y1)，宽度 w1，高度 h1
x2, y2, w2, h2 = map(int, input().split())  # 矩形2的左上角坐标 (x2, y2)，宽度 w2，高度 h2
x3, y3, w3, h3 = map(int, input().split())  # 矩形3的左上角坐标 (x3, y3)，宽度 w3，高度 h3

# 算法入口：计算三个矩形的重叠面积
def getResult():
    # 计算重叠区域的宽度
    wid = min(x1 + w1, x2 + w2, x3 + w3) - max(x1, x2, x3)
    if wid <= 0:  # 如果宽度小于等于 0，说明没有重叠区域
        return 0

    # 计算重叠区域的高度
    hei = min(y1, y2, y3) - max(y1 - h1, y2 - h2, y3 - h3)
    if hei <= 0:  # 如果高度小于等于 0，说明没有重叠区域
        return 0

    # 返回重叠区域的面积
    return wid * hei

# 调用算法，并输出结果
print(getResult())

详细讲解：

1. 输入获取

x1, y1, w1, h1 = map(int, input().split())
x2, y2, w2, h2 = map(int, input().split())
x3, y3, w3, h3 = map(int, input().split())

• input().split()：

  • 从控制台读取一行输入，并按空格分割成字符串列表。
  • 例如，输入 1 2 3 4 会被分割为 ["1", "2", "3", "4"]。

• map(int, ...)：

  • 将字符串列表中的每个元素转换为整数。
  • 例如，["1", "2", "3", "4"] 会被转换为 [1, 2, 3, 4]。

• 解构赋值：

  • 将转换后的整数列表赋值给变量 x1, y1, w1, h1 等。
  • 每个变量分别表示矩形的左上角坐标 (x, y)、宽度 w 和高度 h。

2. 核心算法 (getResult)

def getResult():

• 函数定义：
  • 定义一个函数 getResult，用于计算三个矩形的重叠面积。

wid = min(x1 + w1, x2 + w2, x3 + w3) - max(x1, x2, x3)
if wid <= 0:
    return 0

• 计算重叠区域的宽度：
  • 重叠区域的右边界是三个矩形右边界的最小值：

    min(x1 + w1, x2 + w2, x3 + w3)
    

  • 重叠区域的左边界是三个矩形左边界的最大值：

    max(x1, x2, x3)
    

  • 重叠区域的宽度 = 右边界最小值 - 左边界最大值。
  • 如果宽度小于等于 0，说明没有重叠区域，直接返回 0。

hei = min(y1, y2, y3) - max(y1 - h1, y2 - h2, y3 - h3)
if hei <= 0:
    return 0

• 计算重叠区域的高度：
  • 重叠区域的上边界是三个矩形上边界的最小值：

    min(y1, y2, y3)
    

  • 重叠区域的下边界是三个矩形下边界的最大值：

    max(y1 - h1, y2 - h2, y3 - h3)
    

  • 重叠区域的高度 = 上边界最小值 - 下边界最大值。
  • 如果高度小于等于 0，说明没有重叠区域，直接返回 0。

return wid * hei

• 返回重叠区域的面积：
  • 重叠区域的面积 = 宽度 × 高度。

3. 调用算法并输出结果

print(getResult())

• 调用 getResult 函数，计算重叠面积，并输出结果。

代码运行示例

示例 1：

输入：

1 2 3 4
2 3 3 4
3 4 3 4

执行过程：

1. 输入三个矩形的数据：
   • 矩形 1：(x1=1, y1=2, w1=3, h1=4)
   • 矩形 2：(x2=2, y2=3, w2=3, h2=4)
   • 矩形 3：(x3=3, y3=4, w3=3, h3=4)
2. 计算重叠区域的宽度：
   • 右边界最小值：min(1+3, 2+3, 3+3) = min(4, 5, 6) = 4
   • 左边界最大值：max(1, 2, 3) = 3
   • 宽度：4 - 3 = 1
3. 计算重叠区域的高度：
   • 上边界最小值：min(2, 3, 4) = 2
   • 下边界最大值：max(2-4, 3-4, 4-4) = max(-2, -1, 0) = 0
   • 高度：2 - 0 = 2
4. 重叠区域面积：1 * 2 = 2

输出：

2

示例 2：

输入：

0 0 2 2
1 1 2 2
2 2 2 2

执行过程：

1. 输入三个矩形的数据：
   • 矩形 1：(x1=0, y1=0, w1=2, h1=2)
   • 矩形 2：(x2=1, y2=1, w2=2, h2=2)
   • 矩形 3：(x3=2, y3=2, w3=2, h3=2)
2. 计算重叠区域的宽度：
   • 右边界最小值：min(0+2, 1+2, 2+2) = min(2, 3, 4) = 2
   • 左边界最大值：max(0, 1, 2) = 2
   • 宽度：2 - 2 = 0
3. 由于宽度为 0，直接返回 0。

输出：

0

总结

1. 功能：

   • 计算三个矩形的重叠面积。

2. 优点：

   • 代码逻辑清晰，易于理解。
   • 使用数学方法简化了计算过程。

3. 适用场景：

   • 适用于需要计算多个矩形重叠面积的场景。

如果您有其他问题，欢迎随时提问！

五、C/C++算法源码：

以下是这段代码的 C 语言版本 和 C++ 版本，并附上详细的中文注释与讲解。代码的功能是计算三个矩形的重叠面积。

C 语言版本

代码：

#include <stdio.h>

// 宏定义：计算三个数中的最大值
#define MAX(a, b, c) ((a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)))

// 宏定义：计算三个数中的最小值
#define MIN(a, b, c) ((a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)))

int main() {
    // 输入矩形1的左上角坐标 (x1, y1)、宽度 w1、高度 h1
    int x1, y1, w1, h1;
    scanf("%d %d %d %d", &x1, &y1, &w1, &h1);

    // 输入矩形2的左上角坐标 (x2, y2)、宽度 w2、高度 h2
    int x2, y2, w2, h2;
    scanf("%d %d %d %d", &x2, &y2, &w2, &h2);

    // 输入矩形3的左上角坐标 (x3, y3)、宽度 w3、高度 h3
    int x3, y3, w3, h3;
    scanf("%d %d %d %d", &x3, &y3, &w3, &h3);

    // 计算重叠区域的宽度
    int wid = MIN(x1 + w1, x2 + w2, x3 + w3) - MAX(x1, x2, x3);

    // 计算重叠区域的高度
    int hei = MIN(y1, y2, y3) - MAX(y1 - h1, y2 - h2, y3 - h3);

    // 判断是否有重叠区域
    if (wid <= 0 || hei <= 0) {
        puts("0"); // 没有重叠区域，输出 0
    } else {
        printf("%d\n", wid * hei); // 输出重叠区域的面积
    }

    return 0;
}

详细讲解：

1. 宏定义：

   • MAX(a, b, c)：计算三个数中的最大值。
   • MIN(a, b, c)：计算三个数中的最小值。

2. 输入部分：

   • 使用 scanf 从控制台读取三个矩形的左上角坐标 (x, y)、宽度 w 和高度 h。

3. 计算重叠区域的宽度：

   • 重叠区域的右边界是三个矩形右边界的最小值：

     MIN(x1 + w1, x2 + w2, x3 + w3)
     

   • 重叠区域的左边界是三个矩形左边界的最大值：

     MAX(x1, x2, x3)
     

   • 重叠区域的宽度 = 右边界最小值 - 左边界最大值。

4. 计算重叠区域的高度：

   • 重叠区域的上边界是三个矩形上边界的最小值：

     MIN(y1, y2, y3)
     

   • 重叠区域的下边界是三个矩形下边界的最大值：

     MAX(y1 - h1, y2 - h2, y3 - h3)
     

   • 重叠区域的高度 = 上边界最小值 - 下边界最大值。

5. 判断是否有重叠区域：

   • 如果宽度或高度小于等于 0，说明没有重叠区域，输出 0。
   • 否则，输出重叠区域的面积。

C++ 版本

代码：

#include <iostream>
#include <algorithm> // 包含 std::max 和 std::min 函数

using namespace std;

int main() {
    // 输入矩形1的左上角坐标 (x1, y1)、宽度 w1、高度 h1
    int x1, y1, w1, h1;
    cin >> x1 >> y1 >> w1 >> h1;

    // 输入矩形2的左上角坐标 (x2, y2)、宽度 w2、高度 h2
    int x2, y2, w2, h2;
    cin >> x2 >> y2 >> w2 >> h2;

    // 输入矩形3的左上角坐标 (x3, y3)、宽度 w3、高度 h3
    int x3, y3, w3, h3;
    cin >> x3 >> y3 >> w3 >> h3;

    // 计算重叠区域的宽度
    int wid = min({x1 + w1, x2 + w2, x3 + w3}) - max({x1, x2, x3});

    // 计算重叠区域的高度
    int hei = min({y1, y2, y3}) - max({y1 - h1, y2 - h2, y3 - h3});

    // 判断是否有重叠区域
    if (wid <= 0 || hei <= 0) {
        cout << "0" << endl; // 没有重叠区域，输出 0
    } else {
        cout << wid * hei << endl; // 输出重叠区域的面积
    }

    return 0;
}

详细讲解：

1. 输入部分：

   • 使用 cin 从控制台读取三个矩形的左上角坐标 (x, y)、宽度 w 和高度 h。

2. 计算重叠区域的宽度：

   • 使用 std::min 计算三个矩形右边界的最小值：

     min({x1 + w1, x2 + w2, x3 + w3})
     

   • 使用 std::max 计算三个矩形左边界的最大值：

     max({x1, x2, x3})
     

   • 重叠区域的宽度 = 右边界最小值 - 左边界最大值。

3. 计算重叠区域的高度：

   • 使用 std::min 计算三个矩形上边界的最小值：

     min({y1, y2, y3})
     

   • 使用 std::max 计算三个矩形下边界的最大值：

     max({y1 - h1, y2 - h2, y3 - h3})
     

   • 重叠区域的高度 = 上边界最小值 - 下边界最大值。

4. 判断是否有重叠区域：

   • 如果宽度或高度小于等于 0，说明没有重叠区域，输出 0。
   • 否则，输出重叠区域的面积。

总结

1. 功能：

   • 计算三个矩形的重叠面积。

2. C 语言与 C++ 的区别：

   • C 语言使用宏定义实现最大值和最小值的计算。
   • C++ 使用 std::min 和 std::max 函数，代码更简洁。

3. 优点：

   • 代码逻辑清晰，易于理解。
   • 使用数学方法简化了计算过程。

4. 适用场景：

   • 适用于需要计算多个矩形重叠面积的场景。

如果您有其他问题，欢迎随时提问！

六、尾言

什么是华为OD？

华为OD（Outsourcing Developer，外包开发工程师）是华为针对软件开发工程师岗位的一种招聘形式，主要包括笔试、技术面试以及综合面试等环节。尤其在笔试部分，算法题的机试至关重要。

为什么刷题很重要？

1. 机试是进入技术面的第一关：
   华为OD机试（常被称为机考）主要考察算法和编程能力。只有通过机试，才能进入后续的技术面试环节。

2. 技术面试需要手撕代码：
   技术一面和二面通常会涉及现场编写代码或算法题。面试官会注重考察候选人的思路清晰度、代码规范性以及解决问题的能力。因此提前刷题、多练习是通过面试的重要保障。

3. 入职后的可信考试：
   入职华为后，还需要通过“可信考试”。可信考试分为三个等级：

   • 入门级：主要考察基础算法与编程能力。
   • 工作级：更贴近实际业务需求，可能涉及复杂的算法或与工作内容相关的场景题目。
   • 专业级：最高等级，考察深层次的算法以及优化能力，与薪资直接挂钩。

刷题策略与说明：

2024年8月14日之后，华为OD机试的题库转为 E卷，由往年题库（D卷、A卷、B卷、C卷）和全新题目组成。刷题时可以参考以下策略：

1. 关注历年真题：

   • 题库中的旧题占比较大，建议优先刷历年的A卷、B卷、C卷、D卷题目。
   • 对于每道题目，建议深度理解其解题思路、代码实现，以及相关算法的适用场景。

2. 适应新题目：

   • E卷中包含全新题目，需要掌握全面的算法知识和一定的灵活应对能力。
   • 建议关注新的刷题平台或交流群，获取最新题目的解析和动态。

3. 掌握常见算法：
   华为OD考试通常涉及以下算法和数据结构：

   • 排序算法（快速排序、归并排序等）
   • 动态规划（背包问题、最长公共子序列等）
   • 贪心算法
   • 栈、队列、链表的操作
   • 图论（最短路径、最小生成树等）
   • 滑动窗口、双指针算法

4. 保持编程规范：

   • 注重代码的可读性和注释的清晰度。
   • 熟练使用常见编程语言，如C++、Java、Python等。

如何获取资源？

1. 官方参考：

   • 华为招聘官网或相关的招聘平台会有一些参考信息。
   • 华为OD的相关公众号可能也会发布相关的刷题资料或学习资源。

2. 加入刷题社区：

   • 找到可信的刷题交流群，与其他备考的小伙伴交流经验。
   • 关注知名的刷题网站，如LeetCode、牛客网等，这些平台上有许多华为OD的历年真题和解析。

3. 寻找系统性的教程：

   • 学习一本经典的算法书籍，例如《算法导论》《剑指Offer》《编程之美》等。
   • 完成系统的学习课程，例如数据结构与算法的在线课程。

积极心态与持续努力：

刷题的过程可能会比较枯燥，但它能够显著提升编程能力和算法思维。无论是为了通过华为OD的招聘考试，还是为了未来的职业发展，这些积累都会成为重要的财富。

考试注意细节

1. 本地编写代码

   • 在本地 IDE（如 VS Code、PyCharm 等）上编写、保存和调试代码，确保逻辑正确后再复制粘贴到考试页面。这样可以减少语法错误，提高代码准确性。

2. 调整心态，保持冷静

   • 遇到提示不足或实现不确定的问题时，不必慌张，可以采用更简单或更有把握的方法替代，确保思路清晰。

3. 输入输出完整性

   • 注意训练和考试时都需要编写完整的输入输出代码，尤其是和题目示例保持一致。完成代码后务必及时调试，确保功能符合要求。

4. 快捷键使用

   • 删除行可用 Ctrl+D，复制、粘贴和撤销分别为 Ctrl+C，Ctrl+V，Ctrl+Z，这些可以正常使用。
   • 避免使用 Ctrl+S，以免触发浏览器的保存功能。

5. 浏览器要求

   • 使用最新版的 Google Chrome 浏览器完成考试，确保摄像头开启并正常工作。考试期间不要切换到其他网站，以免影响考试成绩。

6. 交卷相关

   • 答题前，务必仔细查看题目示例，避免遗漏要求。
   • 每完成一道题后，点击【保存并调试】按钮，多次保存和调试是允许的，系统会记录得分最高的一次结果。完成所有题目后，点击【提交本题型】按钮。
   • 确保在考试结束前提交试卷，避免因未保存或调试失误而丢分。

7. 时间和分数安排

   • 总时间：150 分钟；总分：400 分。
   • 试卷结构：2 道一星难度题（每题 100 分），1 道二星难度题（200 分）。及格分为 150 分。合理分配时间，优先完成自己擅长的题目。

8. 考试环境准备

   • 考试前请备好草稿纸和笔。考试中尽量避免离开座位，确保监控画面正常。
   • 如需上厕所，请提前规划好时间以减少中途离开监控的可能性。

9. 技术问题处理

   • 如果考试中遇到断电、断网、死机等技术问题，可以关闭浏览器并重新打开试卷链接继续作答。
   • 出现其他问题，请第一时间联系 HR 或监考人员进行反馈。

祝你考试顺利，取得理想成绩！