問題描述

為了提高文章質量，每一篇文章（假設全部都是英文）都會有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是否已經存在。

  1 package test;
  2 
  3 import java.util.HashMap;
  4 import java.util.LinkedList;
  5 import java.util.Map;
  6 import java.util.Scanner;
  7 
  8 public class TestFind {
  9     public
 
 static void main(String[] args) {
 10         Scanner sc = new Scanner(System.in);
 11         int num = Integer.parseInt(sc.nextLine());
 12         System.out.println(num);
 13         String[] lines = new String[num];
 14         for (int i = 0; i < num; i++) {
 15             lines[i] = sc.nextLine();
 16         }
 17         
 18         LinkedList<Integer> keys = new LinkedList<>();
 19         LinkedList<Integer> keys2 = new LinkedList<>();
 20         Map<Integer, Integer> m = new HashMap<>();
 21         //遍歷人數
 22         for (int i = 0; i < num; i++) {
 23             //遍歷每個人的數據
 24             boolean isInsert = false;
 25             for (String it : lines[i].split(";")) {
 26                 int begin = Integer.parseInt(it.split(",")[0]);
 27                 int end = Integer.parseInt(it.split(",")[1]);
 28                 //比較key值,然後確定value
 29                 for (int j = 0; j < keys.size(); j++) {
 30                     Integer key = keys.get(j);
 31                     Integer value = m.get(key);
 32                     if (begin < key) {
 33                         if (end < key) {
 34                             m.put(begin, end);
 35                             if (keys.contains(begin)){
 36                                 keys2.set(j-1,begin);
 37                             }else{
 38                                 keys2.add(j, begin);
 39                             }
 40                             isInsert = true;
 41                         } else if (end >= key && end <= value) {
 42                             m.remove(key);
 43                             m.put(begin, value);
 44                             keys2.remove(j);
 45                             //2 10 17
 46                             if (keys.contains(begin)){
 47                                 keys2.set(j-1,begin);
 48                             }else{
 49                                 keys2.add(j, begin);
 50                             }
 51                             isInsert = true;
 52                         } else {
 53                             m.remove(key);
 54                             m.put(begin, end);
 55                             keys2.remove(j);
 56                             if (keys.contains(begin)){
 57                                 keys2.set(j-1,begin);
 58                             }else{
 59                                 keys2.add(j, begin);
 60                             }
 61                             isInsert = true;
 62                         }
 63                     } else if (begin == key) {
 64                         int max = Math.max(end, value);
 65                         m.put(begin, max);
 66                         isInsert = true;
 67                     } else {
 68                         if (begin <= value+1) {
 69                             if (end <= value) {
 70                                 continue;
 71                             } else if (end > value) {
 72                                 //把key作為begin,查看下次循環是否被合並,若是最後一個,不影響
 73                                 m.put(key, end);
 74                                 begin = key;
 75                                 continue;
 76                             }
 77                         } else {
 78                             continue;
 79                         }
 80                     }
 81                         break;
 82                 }
 83                 if (!isInsert) {
 84                     m.put(begin, end);
 85                     if (!keys.contains(begin)){
 86                         keys2.add(begin);
 87                     }
 88                 }
 89                 isInsert =false;
 90                 keys = (LinkedList<Integer>) keys2.clone();
 91                 System.out.println(keys);
 92             }
 93         }
 94         StringBuilder sb = new StringBuilder();
 95         for (int i = 0; i < keys.size(); i++) {
 96             int key = keys.get(i);
 97             int value = m.get(key);
 98             sb.append(key+","+value+";");
 99         }
100         sb.delete(sb.length()-1,sb.length()-1);
101         System.out.println(keys);
102         System.out.println(sb);
103     }
104     
105 }

方式二

待補全

合並區間問題