【2023华为ODB卷-AI面板识别】100%通过率（Java&Python&C++&Go）

题目内容

AI识别到面板上有$N$ ($1\le N\le 100$) 个指示灯，灯大小一样，任意两个之间无重叠。

由于AI识别误差，每次识别到的指示灯位置可能有差异，以4个坐标值描述AI识别的指示灯的大小和位置(左上角$x1$,$y1$，右下角$x2,y2$)

请输出先行后列排序的指示灯的编号，排序规则:

​ 1.每次在尚未排序的灯中挑选最高的灯作为的基准灯，

​ 2.找出和基准灯属于同一行所有的灯进行排序。两人灯高低偏差不超过灯半径算同一行(即两个灯坐标的差$\le$灯高度的一半)。

输入描述

第一行为$N$，表示灯的个数
接下来$N$行，每行为$1$个灯的坐标信息，格式为:

编号x_1 y_1 x_2 y_2

• 编号全局唯一
• $1\le 编号\le 100$
• $0\le x_1<x_2\le 1000$
• $0\le y_1\le y_2\le 1000$

输出描述

排序后的编号列表，编号之间以空格分隔

用例

输入

5
1 0 0 2 2
2 6 1 8 3
3 3 2 5 4
5 5 4 7 6
4 0 4 2 6

输出

1 2 3 4 5

样例说明

思路：模拟+排序

给定一组指示灯，每个指示灯给出其坐标信息，要求按以下规则对灯进行排序输出：

1.每次在尚未排序的灯中挑选最高的灯(�1y1最小)作为的基准灯，

2.找出和基准灯属于同一行所有的灯进行排序(按�1x1升序排)并输出。

也就是说我们每次找到基准灯后，根据规则判断其它灯是否与基准灯同行，将所有同行的灯排序后，再进行下一次迭代即可。

几乎所有语言中都已经封装好了排序的函数，比如在C++中，我们可以直接调用Algorithm库中的sort函数来直接完成排序功能，只需要重写排序规则即可。

想练手的同学也可以自行尝试编写排序的代码。

代码

C++

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

int n;

// 存储灯的范围 
struct node{
	int id;
	int x1,y1,x2,y2;
} a[105];

// 重写sort的排序规则 
bool cmp(node a,node b){
	return a.y1<b.y1;
}

bool cmp2(node a,node b){
	return a.x1<b.x1;
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i){
		scanf("%d %d %d %d %d",&a[i].id,&a[i].x1,&a[i].y1,&a[i].x2,&a[i].y2);
	}
	// 第一次排序，按照高度从高往低排 
	sort(a+1,a+n+1,cmp);
	int l=1;
	for(int i=2;i<=n;++i){
		// 找到与基准灯在同一行的所有灯 
		if(a[i].y1-a[l].y1<=(a[l].y2-a[l].y1)/2) continue;
		// 对这些灯进行排序 
		sort(a+l,a+i,cmp2);
		// 更新基准灯 
		l=i;
	}
	// 最后一个基准灯及其同行灯进行排序 
	sort(a+l,a+n+1,cmp2);
	for(int i=1;i<=n;++i) printf("%d ",a[i].id);
	
	return 0;
}

Python

# 存储灯的范围
class Node:
    def __init__(self, id, x1, y1, x2, y2):
        self.id = id
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

n = int(input())

a = []
for i in range(n):
    id, x1, y1, x2, y2 = map(int, input().split())
    a.append(Node(id, x1, y1, x2, y2))

# 第一次排序，按照高度从高往低排
a.sort(key=lambda x: x.y1)

l = 0
for i in range(1, n):
    # 找到与基准灯在同一行的所有灯
    if a[i].y1 - a[l].y1 <= (a[l].y2 - a[l].y1) / 2:
        continue
    # 对这些灯进行排序
    a[l:i] = sorted(a[l:i], key=lambda x: x.x1)
    # 更新基准灯
    l = i

# 最后一个基准灯及其同行灯进行排序
a[l:] = sorted(a[l:], key=lambda x: x.x1)

for i in range(n):
    print(a[i].id, end=' ')

Java

import java.util.*;

class Main {
    static class Node {
        int id;
        int x1, y1, x2, y2;
        
        Node(int id, int x1, int y1, int x2, int y2) {
            this.id = id;
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }
    }
    
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();

        Node[] a = new Node[n];
        for (int i = 0; i < n; i++) {
            int id = input.nextInt();
            int x1 = input.nextInt();
            int y1 = input.nextInt();
            int x2 = input.nextInt();
            int y2 = input.nextInt();
            a[i] = new Node(id, x1, y1, x2, y2);
        }

        Arrays.sort(a, new Comparator<Node>() {
            @Override
            public int compare(Node a, Node b) {
                return a.y1 - b.y1;
            }
        });

        int l = 0;
        for (int i = 1; i < n; i++) {
            // 找到与基准灯在同一行的所有灯
            if (a[i].y1 - a[l].y1 <= (a[l].y2 - a[l].y1) / 2)
                continue;
            // 对这些灯进行排序
            Arrays.sort(a, l, i, new Comparator<Node>() {
                @Override
                public int compare(Node a, Node b) {
                    return a.x1 - b.x1;
                }
            });
            // 更新基准灯
            l = i;
        }

        // 最后一个基准灯及其同行灯进行排序
        Arrays.sort(a, l, n, new Comparator<Node>() {
            @Override
            public int compare(Node a, Node b) {
                return a.x1 - b.x1;
            }
        });

        for (int i = 0; i < n; i++) {
            System.out.print(a[i].id + " ");
        }
    }
}

Go

package main

import (
	"fmt"
	"sort"
)

type node struct {
	id, x1, y1, x2, y2 int
}

func main() {
	var n int
	fmt.Scan(&n)

	a := make([]node, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i].id, &a[i].x1, &a[i].y1, &a[i].x2, &a[i].y2)
	}

	sort.Slice(a, func(i, j int) bool {
		return a[i].y1 < a[j].y1
	})

	l := 0
	for i := 1; i < n; i++ {
		// 找到与基准灯在同一行的所有灯
		if a[i].y1-a[l].y1 <= (a[l].y2-a[l].y1)/2 {
			continue
		}
		// 对这些灯进行排序
		sort.Slice(a[l:i], func(x, y int) bool {
			return a[x+l].x1 < a[y+l].x1
		})
		// 更新基准灯
		l = i
	}

	// 最后一个基准灯及其同行灯进行排序
	sort.Slice(a[l:], func(x, y int) bool {
		return a[x+l].x1 < a[y+l].x1
	})

	for i := 0; i < n; i++ {
		fmt.Printf("%d ", a[i].id)
	}
}