笔试时间：2023年4月18日 春招

第一题

题目：菱形个数

给定正整数X、Y，算出同时满足下列3个条件的所有菱形个数：

1、菱形存在正面积。

2、菱形每个顶点的横坐标xi为0≤xi≤X的整数，纵坐标yi为0≤yi≤Y的整数。

3、菱形的对角线平行于坐标轴。

输入描述

输入为一行，包含两个整数x和v，满足(1≤x, Y≤300)

输出描述

输出一个数,表示满足条件的所有菱形个数

示例输入

2 2

示例输出

1

参考题解

C++：[此代码未进行大量数据的测试，仅供参考]

#include <iostream>
using namespace std;

int main() {
    int X, Y;
    cin >> X >> Y;
    int ans = 0;
    for (int x1 = 0; x1 <= X; x1++) {
        for (int y1 = 1; y1 <= Y; y1++) {
            for (int x2 = x1 + 2; x2 <= X; x2++) {
                ans += min(Y, 2 * y1) - max(2 * y1 - Y, y1);
            }
        }
    }
    cout << ans << endl;
    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int X = scanner.nextInt();
        int Y = scanner.nextInt();
        int ans = 0;

        for (int x1 = 0; x1 <= X; x1++) {
            for (int y1 = 1; y1 <= Y; y1++) {
                for (int x2 = x1 + 2; x2 <= X; x2++) {
                    ans += Math.min(Y, 2 * y1) - Math.max(2 * y1 - Y, y1);
                }
            }
        }

        System.out.println(ans);
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

X, Y = map(int, input().split())
ans = 0
for x1 in range(X + 1):
    for y1 in range(1, Y + 1):
        for x2 in range(x1 + 2, X + 1):
            ans += min(Y, 2 * y1) - max(2 * y1 - Y, y1)
print(ans)

第二题

题目：最大投影面积

二维平面上有n个点，它们的横纵坐标均为正整数，且没有两个点有相同的横坐标，把所有点从左到右依次通过直线连接，形成的折线与横坐标可形成一片投影区间。若最多只能交换其中两点的纵坐标值，问如何交换可得到最大的投影面积。

范围: n (2<= n <= 1000)；横纵坐标x y范围(1<= x, y <= 10^5)

输入描述

第一行为坐标上点的个数n。

接下来n行输入每个点的横纵坐标值。

输出描述

需要交换两点的横坐标值，按增序排列，若无需交换则输出-1

示例输入

示例输入一：

3

1 2

4 1

2 5

示例输入二：

2

1 2

3 2

示例输出

示例输出一：

1 4

示例输出二：

-1

参考题解

可以列举出所有可能的交换点，然后计算。

C++：[此代码未进行大量数据的测试，仅供参考]

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int numPoints;
    cin >> numPoints;
    
    vector<pair<int, int>> points;

    // 输入坐标点
    for (int i = 0; i < numPoints; i++) {
        int x, y;
        cin >> x >> y;
        points.push_back({x, y});
    }
    
    // 根据 x 坐标排序
    sort(points.begin(), points.end());

    int maxChange = 0;
    int bestPoint1 = -1, bestPoint2 = -1;
    
    // 遍历所有可能的点对
    for (int i = 0; i < numPoints; i++) {
        for (int j = i + 1; j < numPoints; j++) {
            int deltaX1 = points[min(numPoints - 1, i + 1)].first - points[max(0, i - 1)].first;
            int deltaX2 = points[min(numPoints - 1, j + 1)].first - points[max(0, j - 1)].first;
            
            // 计算当前点对的改变量
            int currentChange = (points[j].second - points[i].second) * (deltaX1 - deltaX2);
            
            // 更新最大改变量和最佳点对
            if (currentChange > maxChange) {
                maxChange = currentChange;
                bestPoint1 = i;
                bestPoint2 = j;
            }
        }
    }
    
    // 输出结果
    if (maxChange == 0) {
        cout << -1 << endl;
    } else {
        cout << points[bestPoint1].first << " " << points[bestPoint2].first << endl;
    }
    
    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numPoints = scanner.nextInt();
        List<Point> points = new ArrayList<>();

        // 输入坐标点
        for (int i = 0; i < numPoints; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            points.add(new Point(x, y));
        }

        // 根据 x 坐标排序
        Collections.sort(points);

        int maxChange = 0;
        int bestPoint1 = -1, bestPoint2 = -1;

        // 遍历所有可能的点对
        for (int i = 0; i < numPoints; i++) {
            for (int j = i + 1; j < numPoints; j++) {
                int deltaX1 = getDeltaX(points, i);
                int deltaX2 = getDeltaX(points, j);
                int currentChange = (points.get(j).y - points.get(i).y) * (deltaX1 - deltaX2);

                // 更新最大改变量和最佳点对
                if (currentChange > maxChange) {
                    max