(C卷,100分)- 绘图机器（Java & JS & Python & C）

题目描述

绘图机器的绘图笔初始位置在原点(0,0)机器启动后按照以下规则来进行绘制直线。

1. 尝试沿着横线坐标正向绘制直线直到给定的终点E

2. 期间可以通过指令在纵坐标轴方向进行偏移，offsetY为正数表示正向偏移,为负数表示负向偏移

给定的横坐标终点值E 以及若干条绘制指令，

请计算绘制的直线和横坐标轴以及x=E的直线组成的图形面积。

输入描述

• 首行为两个整数 N 和 E
• 表示有N条指令,机器运行的横坐标终点值E
• 接下来N行 每行两个整数表示一条绘制指令x offsetY
• 用例保证横坐标x以递增排序的方式出现
• 且不会出现相同横坐标x

取值范围

• 0<N<=10000
• 0<=x<=E<=20000
• -10000<=offsetY<=10000

输出描述

• 一个整数表示计算得到的面积 用例保证结果范围在0到4294967295之内。

用例

题目解析

注意下面每个拐点上标记不是坐标信息，而是 (x,offsetY)，其中offsetY是偏移

示例1图示

示例2图示 

这题将图画出来后，可能大家的思路就打开了。

我的解题思路是这样的，将上面红色线框对应的复杂图形的面积求解，切割为横轴上每个单位长度的矩形面积求解，而每单位长度的矩形面积就等于对应的高度，即纵轴坐标的绝对值，因此我们只需要将offsetY偏移转为纵坐标的即可。

而题目描述中：用例保证横坐标x以递增排序的方式出现。

这里只强调递增没有强调连续，因此我们需要考虑不连续的offsetY转纵坐标的场景，其实也很简单，断档的offsetY其实默认为0。

Java算法源码

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    int end_x = sc.nextInt();

    // 记录题解
    long ans = 0;

    long last_x = 0; // 上一个点的横坐标
    long last_y = 0; // 上一个点的纵坐标

    // 获取n行输入
    for (int i = 0; i < n; i++) {
      int cur_x = sc.nextInt(); // 当前点的横坐标
      int offset_y = sc.nextInt(); // 当前点纵坐标相较于上一个点纵坐标的偏移量

      // cur_x - last_x 结果是上一个点到当前点的横向距离, 这个距离过程中，高度保持为abs(last_y)
      ans += (cur_x - last_x) * Math.abs(last_y);

      // 更新last_x, last_y
      last_x = cur_x;
      last_y += offset_y;
    }

    // 注意结束位置的处理
    if (end_x > last_x) {
      ans += (end_x - last_x) * Math.abs(last_y);
    }

    System.out.println(ans);
  }
}

JS算法源码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

// 串行异步获取
void (async function () {
  // 第一行输入解析
  const [n, end_x] = (await readline()).split(" ").map(Number);

  // 记录题解
  let ans = 0;

  let last_x = 0; // 上一个点的横坐标
  let last_y = 0; // 上一个点的纵坐标

  // 获取n行输入
  for (let i = 0; i < n; i++) {
    // [当前点的横坐标,当前点纵坐标相较于上一个点纵坐标的偏移量]
    const [cur_x, offset_y] = (await readline()).split(" ").map(Number);

    // cur_x - last_x 结果是上一个点到当前点的横向距离, 这个距离过程中，高度保持为abs(last_y)
    ans += (cur_x - last_x) * Math.abs(last_y);

    // 更新last_x, last_y
    last_x = cur_x;
    last_y += offset_y;
  }

  // 注意结束位置的处理
  if (end_x > last_x) {
    ans += (end_x - last_x) * Math.abs(last_y);
  }

  console.log(ans);
})();

Python算法源码

# 第一行输入解析
n, end_x = map(int, input().split())

# 记录题解
ans = 0

last_x = 0  # 上一个点的横坐标
last_y = 0  # 上一个点的纵坐标

# 获取n行输入
for _ in range(n):
    # 当前点的横坐标, 当前点纵坐标相较于上一个点纵坐标的偏移量
    cur_x, offset_y = map(int, input().split())

    # cur_x - last_x 结果是上一个点到当前点的横向距离, 这个距离过程中，高度保持为abs(last_y)
    ans += (cur_x - last_x) * abs(last_y)

    # 更新last_x, last_y
    last_x = cur_x
    last_y += offset_y

# 注意结束位置的处理
if end_x > last_x:
    ans += (end_x - last_x) * abs(last_y)

print(ans)

C算法源码

#include <stdio.h>
#include <math.h>

int main() {
    int n, end_x;
    scanf("%d %d", &n, &end_x);

    long ans = 0;

    long last_x = 0;
    long last_y = 0;

    for(int i=0; i<n; i++) {
        int cur_x, offset_y;
        scanf("%d %d", &cur_x, &offset_y);

        ans += (cur_x - last_x) * abs(last_y);

        last_x = cur_x;
        last_y += offset_y;
    }

    if(end_x > last_x) {
        ans += (end_x - last_x) * abs(last_y);
    }

    printf("%ldn", ans);

    return 0;
}