【华为OD机试真题 JAVA】路灯照明问题 【2022 Q4 | 100分】 贪心算法 区间覆盖问题

【华为OD机试真题 JAVA】路灯照明问题 【2022 Q4 | 100分】

消失de岁月

于 2022-11-22 21:32:07 发布

254

收藏 1

分类专栏： 华为OD机试真题JAVA 文章标签： java 算法 华为

版权

华为OD机试真题JAVA

专栏收录该内容

38 篇文章16 订阅

订阅专栏

前言

《华为OD笔试真题 JAVA》 专栏含华为OD机试真题JAVA实现、华为面试题、牛客网华为专栏真题。

如果您正在准备华为的面试，或者华为od的机会，希望可以帮到您！ PS：文中答案仅供参考，不可照抄

■ 题目描述

【路灯照明问题】

在一条笔直的公路上安装了N个路灯，从位置0开始安装，路灯之间间距固定为100米。

每个路灯都有自己的照明半径，请计算第一个路灯和最后一个路灯之间，无法照明的区间的长度和。

输入描述

第一行为一个数N，表示路灯个数，1<=N<=100000

第二行为N个空格分隔的数，表示路径的照明半径，1<=照明半径<=100000*100

输出描述

第一个路灯和最后一个路灯之间，无法照明的区间的长度和

示例1 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

2

50 50

输出

0

说明

路灯1覆盖0-50，路灯2覆盖50-100，路灯1和路灯2之间(0米-100米)无未覆盖的区间。

示例2 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

4

50 70 20 70

解释：

路灯1 覆盖0-50

路灯2 覆盖30-170

路灯3 覆盖180-220

路灯4 覆盖230-370

输出

20

说明

[170,180],[220,230]，两个未覆盖的区间，总里程为20

package huaweiod;

import java.util.*;

class MyObj implements Comparable<MyObj> {

    int left;
    int right;
    int posIndex;


    @Override
    public int compareTo(MyObj m) {
        return this.left - m.left;
    }
}

public class Main路灯照明问题优化 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        MyObj[] arr = new MyObj[n];
        ArrayList<MyObj> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int pos = i * 100;
            int r = scanner.nextInt();
            MyObj myObj = new MyObj();
            myObj.left = pos - r;
            if (myObj.left <= 0) {
                myObj.left = 0;
            }
            myObj.right = pos + r;
            myObj.posIndex = i;
            arr[i] = myObj;

        }
        //左端点进行排序
        Arrays.sort(arr);
        for (int i = 0; i < n; i++) {
            System.out.println(arr[i].left + "-" + arr[i].right);
            list.add(arr[i]);
        }
        Collections.sort(list);
        //删除被包含的
        List<MyObj> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); ) {
            if (i + 1 >= list.size()) {
                break;
            }
            //删除被被包含的
            if (list.get(i).left <= list.get(i + 1).left && list.get(i).right >= list.get(i + 1).right) {
                list.remove(i + 1);
            } else {
                i++;
            }
        }

        System.out.println("移除之后");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).left + "-" + list.get(i).right);
//            8 10 10 10 250 10 10 10 10

        }
        int sum = 0;
        for (int i = 0; i < list.size(); ) {

            int who = -1;
            int maxR_end = -1;

            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(j).left <= list.get(i).right) {
                    if (maxR_end < list.get(j).right) {
                        who = j;
                        maxR_end = list.get(j).right;
                    }

                }
            }


            if (who == -1) {
                if (i + 1 < list.size()) {
                    sum += (list.get(i + 1).left - list.get(i).right);
                    i++;
                } else {
                    //
                    break;
                }

            } else {
                //                找到了
                i = who;
                //                可能是包含的
//                    if (arr[who].right < arr[i].right) {
//                        //包含关系 相当于没有找到
//                        if (who + 1 > arr.length) {
//                            break;
//                        }
//                        sum += (arr[who + 1].left - arr[i].right);
//                        i = who + 1;
//
//                    } else {
//                        i = who;
//                    }
            }

        }
        System.out.println(sum);
        //        System.out.println(arr);
        //        4
        //        50 70 220 70


    }
    //    Scanner scanner = new Scanner(System.in);
    //    String line = scanner.nextLine();
    //    Pattern pattern = Pattern.compile("(\\w+)$");
    //    Matcher matcher = pattern.matcher(line);
    //        if (matcher.find()){
    //        String s = matcher.group(0);
    //        System.out.println(s.length());
    //
    //    }

}