合并区间问题

问题描述

为了提高文章质量，每一篇文章（假设全部都是英文）都会有m民编辑进行审核，每个编辑独立工作，会把觉得有问题的句子通过下表记录下来，比如[1,10]，1表示病句的第一个字符，10表示病句的最后一个字符。也就是从1到10着10个字符组成的句子，是有问题的。

现在需要把多名编辑有问题的句子合并起来，送个总编辑进行最终的审核。比如编辑A指出的病句是[1,10]，[32,45];编辑B指出的病句是[5,16]，[78,94]那么[1,10]和[5,16]是有交叉的，可以合并成[1,16][32,45][78,94]

输入描述：

编辑数量m，之后每行是每个编辑的标记的下表组合，第一个和最后一个下标用英文逗号分隔，每组下标之间用分号分隔

输出描述：

合并后的下标集合，第一个和最后一个下标用英文逗号分隔，每组下标之间用分号分隔。返回结果是从小到大递增排列

例：输入

3

1,10;32,45

78,94;5,16

80,100;200,220;16,32

输出： 1,45;78,100;200,220

方式一:

　　暴力解法，用了三层嵌套的循环。

　　第一层循环三行数据，

　　第二层循环每行数据的每个begin和end；（前两步可以先把二维的数据改成一个list或者map，就可以减少一层循环），

　　第三层循环已经排好顺序的结果集。把每个新的begin和end与结果集对比，合并到合适的位置。

缺点：判断条件很多，很多边界可能会考虑不周全。

第71行的判断条件内，会把begin 大于 结果集当前遍历的begin 的新区间向前合并，然后放到下次循环继续判断是否会向后合并。然后下次循环向keys链表中插入数据时，需要判断key是否已经存在。

package test;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;

public class TestFind {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = Integer.parseInt(sc.nextLine());
        System.out.println(num);
        String[] lines = new String[num];
        for (int i = 0; i < num; i++) {
            lines[i] = sc.nextLine();
        }
        
        LinkedList<Integer> keys = new LinkedList<>();
        LinkedList<Integer> keys2 = new LinkedList<>();
        Map<Integer, Integer> m = new HashMap<>();
        //遍历人数
        for (int i = 0; i < num; i++) {
            //遍历每个人的数据
            boolean isInsert = false;
            for (String it : lines[i].split(";")) {
                int begin = Integer.parseInt(it.split(",")[0]);
                int end = Integer.parseInt(it.split(",")[1]);
                //比较key值,然后确定value
                for (int j = 0; j < keys.size(); j++) {
                    Integer key = keys.get(j);
                    Integer value = m.get(key);
                    if (begin < key) {
                        if (end < key) {
                            m.put(begin, end);
                            if (keys.contains(begin)){
                                keys2.set(j-1,begin);
                            }else{
                                keys2.add(j, begin);
                            }
                            isInsert = true;
                        } else if (end >= key && end <= value) {
                            m.remove(key);
                            m.put(begin, value);
                            keys2.remove(j);
                            //2 10 17
                            if (keys.contains(begin)){
                                keys2.set(j-1,begin);
                            }else{
                                keys2.add(j, begin);
                            }
                            isInsert = true;
                        } else {
                            m.remove(key);
                            m.put(begin, end);
                            keys2.remove(j);
                            if (keys.contains(begin)){
                                keys2.set(j-1,begin);
                            }else{
                                keys2.add(j, begin);
                            }
                            isInsert = true;
                        }
                    } else if (begin == key) {
                        int max = Math.max(end, value);
                        m.put(begin, max);
                        isInsert = true;
                    } else {
                        if (begin <= value+1) {
                            if (end <= value) {
                                continue;
                            } else if (end > value) {
                                //把key作为begin,查看下次循环是否被合并,若是最后一个,不影响
                                m.put(key, end);
                                begin = key;
                                continue;
                            }
                        } else {
                            continue;
                        }
                    }
                        break;
                }
                if (!isInsert) {
                    m.put(begin, end);
                    if (!keys.contains(begin)){
                        keys2.add(begin);
                    }
                }
                isInsert =false;
                keys = (LinkedList<Integer>) keys2.clone();
                System.out.println(keys);
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < keys.size(); i++) {
            int key = keys.get(i);
            int value = m.get(key);
            sb.append(key+","+value+";");
        }
        sb.delete(sb.length()-1,sb.length()-1);
        System.out.println(keys);
        System.out.println(sb);
    }
    
}

方式二

待补全