字符串化繁为简_200分_B卷_逻辑分析模拟/字符串/数据结构

字符串化繁为简

题目描述：

  给定一个输入字符串，字符串只可能由英文字母 (a ~ z、A ~ Z ) 和左右小括号 (、) 组成
  当字符里存在小括号时，小括号是成对的，可以有一个或多个小括号对，小括号对不会嵌套，小括号对内可以包含1个或多个英文字母也可以不包含英文字母。
  当小括号对内包含多个英文字母时，这些字母之间是相互等效的关系，而且等效关系可以在不同的小括号对之间传递，即当存在a和b等效和存在b和c等效时， a和c 也等效，
  另外，同一个英文字母的大写字和小写字母也相互等效(即使它们分布在不同的括号对里)
  要对这个输入字符串做简化，输出一个新的字符串，输出字符串里只需保留输入字符串里的没有被小括号对包含的字符(按照输入字符串里的字符顺序)，并将每个字符替换为在小括号对里包含的目字典序最小的等效字符。如果简化后的字符串为空，请输出为”0”
  示例:输入字符串为"never(dont)live(run)up(f)()"，初始等效字符集合为(d,o,n,t)、(r,u,n)，由于等效关系可以传递，因此最终等效字符集合为(d,o,n,t,r,u)，将输入字符串里的剩余部分按字典序最小的等效字符替换后得到"devedgivedp

输入输出描述：

输入描述：

  input string
  输入为1行，代表输入字符串

输出描述：

  output string
  输出为1行，代表输出字符串
  备注:
    输入字符串的长度在1~100000之间

示例1：

输入：
	()abd
输出：
	abd
说明：输入字符串里没有被小括号包含的了字符串为"abd"，其中每个字符没有等效字符，输出为"abd"

示例2：

输入：
	(abd)demand(fb)()for
输出：
	aemanaaor
说明: 等效字符集为(a，b，d，f)，输入字符串里没有被小括号包含的了字符串集合为'demandfor”，将其中字符替换为字典序最小的等效字符后输出为:"aemanaaor

示例3：

输入：
	happy(xyz)new(wxy)year(t)
输出：
	happwnewwear

说明：等效字符集为(x，y, z，w)，输入字符串里没有被小括号包含的了字符串集合为"happynewyear”，将其中字符替换为字典序最小的等效字等后输出为:"happwnewwear

解题思路：

理解题意，题目意思还比较清洗，没有歧义，故可以直接按照题目的意思进行模拟即可，主要解题步骤如下：
  1、遍历原字符串，找出表示等效字母的括号。当遇见有字母的括号时，要判断当前括号内的字母是否在已经遍历过的括号中是否出现过，如果出现过的话，那么代表出现等效传递——这个括号的内容需要和与之有交集的括号内的字母进行合并
  2、得到等效字母的替换集合后，再次遍历原来的字符串进行等效替换即可。

代码：

public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	String line = scanner.nextLine();
	char[] original = line.toCharArray();
	char[] chars = line.toLowerCase().toCharArray();
	StringBuilder sb = new StringBuilder();
	// 标记所有不存在交集的、独立的等效括号的字符集合
	List<Set<Character>> equivalent = new ArrayList<>();
	// 标记字母是否在某个等效字母括号内出现过
	int[] count = new int[26];

	for (int i = 0; i < chars.length; i++) {
		char c = chars[i];
		
		// 扫描到了小括号，代表，括号内可能有字母，即等效字母出现
		if (c == '(') {
			int j = i + 1;
			// 找到右括号
			while (j < chars.length && chars[j] != ')') {
				j++;
			}
			// 括号内字母有多个，则遍历
			if (j - i >= 3) {
				// 截取出括号内的字母内容
				char[] bracket = line.toLowerCase().substring(i + 1, j).toCharArray();
				// 和之前的其它括号内的等效字母合
				Set<Character> union = new TreeSet<>();
				// 标记处与其它括号内的等效字母合是否存在相同字母——等效传递
				List<Character> isSame = new ArrayList<>();
				for (char c1 : bracket) {
					// 如果字母在之前的括号内出现过，则说明出现了等效传递，需要进行合并
					if (!union.contains(c1) && count[c1 - 'a'] == 1) {
						isSame.add(c1);
					} else {
						union.add(c1);
						count[c1 - 'a'] = 1;
					}
				}

				// 存在等效传递——需要合并
				if (!isSame.isEmpty())  {
					Set<Integer> mergeIndex = new TreeSet<>();
					for (Character same : isSame) {
						for (int k = 0; k < equivalent.size(); k++) {
							if (equivalent.get(k).contains(same)) {
								// 合并
								union.addAll(equivalent.get(k));
								mergeIndex.add(k);
							}
						}
					}
					
					// 更新所有不存在交集的、独立的等效括号的字符集合
					List<Set<Character>> tmp = new ArrayList<>();
					for (int k = 0; k < equivalent.size(); k++) {
						if (!mergeIndex.contains(k)) {
							tmp.add(equivalent.get(k));
						}
					}
					equivalent = tmp;
				}
				equivalent.add(union);
			}
			i = j;
		} else {
			// 括号外的字母
			sb.append(original[i]);
		}
	}

	// 替换——替换掉等效字母
	char[] onBraket = sb.toString().toCharArray();
	sb = new StringBuilder();
	for (int i = 0; i < onBraket.length; i++) {
		char c = onBraket[i];
		boolean flag = true;

		for (int j = 0; j < equivalent.size(); j++) {
			Set<Character> set = equivalent.get(j);
			if (set.contains(c) || set.contains((char) (c + 32))) {
				flag = false;
				sb.append(set.iterator().next());
				break;
			}
		}

		if (flag) {
			sb.append(c);
		}
	}

	System.out.println(sb.toString());
}