三色球 RGB

来自某软19年复试—机试题。

原题：
给一个字符串 由RGB（红绿蓝）3种字母组成
找出串中最长的相同子串，输出****字母以及所在位置，然后剔除（如有多个相同拿最左的子串）
将剩余部分按序连接，如果只有一个字母则结束游戏，否则返回第一步
注意每次输出的位置为原始串中的位置
例：RBBGGR
B 2 3
G 4 5
R 1 6

---

本人采用的是纯HashMap的方式来进行编写的。
整个代码流程分为两步：

1. 找到最长的子串，并记录其起始位置和最大长度
2. 剔除该连续子串（采用标记的方法，并不真正删除，目的是保存其位置信息）
   其中步骤一 又分为四步：
   1. 使用map记录找连续子串**（key:begin, value:end）**
   2. 对end相同的map进行处理，只保留最长的，由于begin是按照顺序的，所以这里使用map逆转的方式对map进行逆转，这样就能保证相同end的map在逆转后只有最长的连续子串了。
      map（key:begin, value:end） -----> reverse(key:end , value:begin)
   3. 根据reverse得到lenMap，此时
      lenMap (key:begin,value:length)
   4. 根据length找到最长子串，并记录下他的begin
      步骤二：
      从begin到end，输出flag值不为0的。之后再把这次输出过的值的flag改为0，标记为已输出。

---

package ican;


/*
    原题：
    给一个字符串 由RGB（红绿蓝）3种字母组成
    找出串中最长的相同子串，输出字母以及所在位置，然后剔除（如有多个相同拿最左的子串）
    将剩余部分按序连接，如果只有一个字母则结束游戏，否则返回第一步
    注意每次输出的位置为原始串中的位置
    例：RBBGGR
        B 2 3
        G 4 5
        R 1 6
*/

import java.util.*;

public class RGB {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String rgb = sc.next();
        location(rgb);
    }
    public static void location(String rgb){
        char[] chars = rgb.toCharArray();
        ArrayList<Integer> flag = new ArrayList<>();     //标记每个字符
        for (char c : chars){
            flag.add(1);
        }
        while (flag.contains(1)){
            int num = 0;
            for (int i : flag){
                if (i == 1) num++;
            }
            if (num == 0 || num == 1) break;
            else {
                printRGB(flag, chars);
            }
        }
    }

    public static void printRGB(ArrayList<Integer> flag, char[] chars){
        HashMap<Integer,Integer> map = new HashMap<>();

        //RBBGGR

        //找出串中最长的相同子串，输出字母以及所在位置，然后剔除（如有多个相同拿最左的子串）
        //1，找出串中最长的相同子串
        for( int i=0,j=1; j< chars.length; i++,j++){
            int index = j;
            if (flag.get(i) == 0 )
                continue;
            while (chars[i] == chars[index] || flag.get(index) == 0){
                map.put(i, index);
                index++;
                if (index >= chars.length) break;
            }
            if (!map.isEmpty() && flag.get(--index) == 0)
                if (flag.get(i+1) == 0 ){
                    map.remove(i);
                }

        }
        //若有多个键值对的end相同，则表明他们是同一子串，只保留最长的（最先put的）
        //由于map是从大到小排，那么我们直接替换key-value就可以保证 只有一个key
        HashMap<Integer,Integer> reverse = new HashMap<>();
        for (Integer i : map.keySet()){
            Integer value = map.get(i);
            if(!reverse.containsKey(value))
                reverse.put(value, i);
        }

        HashMap<Integer, Integer> lenMap = new HashMap<>();
        for (Integer i : reverse.keySet()){
            //key-begin,value-length
            lenMap.put(reverse.get(i), i - reverse.get(i) + 1);
        }

        //只需要单独的对那些末尾flag为0的进行处理


        //记录哪个key对应的value最大
        int begin = 0;
        int max_Len = 1;
        for (Integer i : lenMap.keySet()){
            if (lenMap.get(i) > max_Len){
                max_Len = lenMap.get(i);
                begin = i;
            }
        }
        //通过一系列的操作，找到了begin和max_Len，可以进行输出了。

        System.out.print(chars[begin]);

        //2.然后剔除,将剩余部分再按序输出
        //剔除时，将不要的部分flag标记为0
        for (int i = begin; i<begin+max_Len; i++){
            if (flag.get(i) != 0)
                System.out.print(" " + (i+1));
            flag.set(i,0);
        }
        System.out.println();
    }

}