1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
๋ถ๋ถ ๋ฌธ์์ด์ ํฌ๊ธฐ 1๋ถํฐ N/2๊น์ง๋ง ์๊ฐํ๋ฉด ๋๋ค. (N = ๋ฌธ์์ด์ ๊ธธ์ด)
์๋ํ๋ฉด, ๋ถ๋ถ ๋ฌธ์์ด์ ํฌ๊ธฐ๊ฐ ์ ๋ฐ ์ด์์ด๋ฉด ๋ฐ๋ณต์ด ๋ถ๊ฐํ๋ฏ๋ก, ์ธ๋ ์๋ฏธ๊ฐ ์๋ค.1๋ฒ์์ ์ ํ ๋ฌธ์์ด ํฌ๊ธฐ๋งํผ ์ฒ์๋ถํฐ ์๋ฅธ๋ค.
์ด ํ์๋ 0 ~ N - i ๊น์ง๋ง ๋ฐ๋ณตํ๋ค. ๋ถ๋ถ๋ฌธ์์ด์ ๊ตฌํ๋ substring(startIndex, endIndex)์์ endIndex๊ฐ ๋ฐฐ์ด์ ๋ฒ์๋ฅผ ๋์ด๊ฐ๋ฉด ์์ธ๊ฐ ๋ฐ์ํ๋ค. ์ฐ๋ฆฌ๋ substring(startIndex, startIndex+i)๋งํผ ํญ์ ํ ๊ฒ์ด๋ฏ๋ก, endIndex๊ฐ ๋ฐฐ์ด์ ๋ฒ์๋ฅผ ๋์ด์์ง ์๋๋ก ๋ฐ๋ณต์ ๋ฒ์๋ฅผ ์์ ๊ฐ์ด ์ ํ๋ค.
์ต์ด ์๋ฅธ ๋ถ๋ถ ๋ฌธ์์ด์ ์ค๋ณต ์ฒดํฌ๊ฐ ๋ถ๊ฐํ๋ฏ๋ก ์ด์ ๋ฌธ์์ด(์ดํ prev)์ ์ ์ฅํ๋ค.์ด์ ๋ฌธ์์ด๊ณผ ํ ๋ฌธ์์ด์ ๋น๊ตํ์ฌ ๋์ผํ๋ฉด ๋ฐ๋ณตํ์(์ดํ count)๋ฅผ 1 ๋๋ฆฐ๋ค.
๋์ผํ์ง ์์ผ๋ฉด prev๊ณผ count๋ฅผ ๋ต๋ณ StringBuilder(์ดํ ans)์ ์ฝ์ ํ๊ณ , count๋ฅผ ์ด๊ธฐํ ํ๋ค.
ํ์ฌ ๋ฌธ์์ด์ prev์ ๋์ ํ๋ค. (์ด์ ์ด์ ๋ฌธ์์ด ์ด๋ฏ๋ก)
2๋ฒ์ ๋ฐ๋ณต๋ฌธ ์ด ๋๋๋ฉด, prev์๋ ํญ์ ๋งจ ๋ง์ง๋ง ๋ถ๋ถ ๋ฌธ์์ด์ด ์ ์ฅ๋์ด์๋ค. ํด๋น ๋ถ๋ถ ๋ฌธ์์ด์ ans์ ์ ์ฅํ๋ค.
๋ง์ฝ N%i != 0์ด๋ฉด, ๋ฐ๋ณต๋ฌธ์ ๋๋๊ณ ๋ ํ์ธํ์ง ์์ ๋๋จธ์ง ๊ฐ๋ค์ด ์กด์ฌํ๋ค๋ ๊ฒ์ด๋ค. ํด๋น ๊ฐ๋ค์ ๋ฐ๋ณต๋ฌธ์ ๊ธธ์ด๋ณด๋ค ์์ ๋ฐ๋ณต์ ํ์ธํ ํ์๊ฐ ์์ผ๋ฏ๋ก, ๊ทธ๋ฅ ans์ ์ ์ฅํ๋ค.
1~7 ์ดํ์ ๋์จ ans์ ๊ธธ์ด๋ฅผ ์ด์ ans์ ๊ธธ์ด์ ๋น๊ตํ์ฌ minimum์ด๋ฉด ๊ฐฑ์ ํ๋ค.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
class Solution {
public int solution(String s) {
int ans = Integer.MAX_VALUE;
if(s.length() == 1) return 1; // ์์ธ์ฒ๋ฆฌ: ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ 1์ด๋ฉด ๋ฐ์ ๋ชจ๋ ํต๊ณผํ๊ธฐ ๋๋ฌธ
for(int i = 1; i <= s.length()/2; i++){
StringBuilder sb = new StringBuilder(); // ๋ต๋ณ ์ ์ฅ์ฉ StringBuilder
String prev = ""; // ์ด์ ๋ฌธ์์ด
int count = 1; // ๋ฐ๋ณต ํ์
for(int j = 0; j <= s.length() - i; j += i){
String cur = s.substring(j, j+i); // ๋ถ๋ถ๋ฌธ์์ด์ ์๋ฅธ๋ค.
if(cur.equals(prev)){ // ํ์ฌ ์๋ฅธ ๋ฌธ์์ด์ด ์ด์ ๊ณผ ๊ฐ์ผ๋ฉด count ++;
count++;
}else {// ์๋๋ฉด, ์ด์ ๋ฌธ์์ด์ ์ง๊ธ๊น์ง ๋ฐ๋ณตํ์์ ํจ๊ป sb์ ์ ์ฅ
sb.append(count>1 ? count : "").append(prev);
count = 1;
}
prev = cur; // ์ด์ ๋ฌธ์์ด์ ๊ฐฑ์
}
sb.append(count>1? count : "").append(prev); // ๋งจ ๋ง์ง๋ง์ ๋จ์ ๋ถ๋ถ ๋ฌธ์์ด ์ ์ฅ
if(s.length()%i !=0){ // ๋๋จธ์ง ๊ฐ๋ค ๋ชจ์กฐ๋ฆฌ sb์ ์ ์ฅ
String last = s.substring(s.length() - s.length()%i, s.length());
sb.append(last);
}
ans = Math.min(ans, sb.toString().length()); // minimum ๋ฌธ์์ด ๊ธธ์ด ๊ฐฑ์
}
return ans;
}
}
4. ์ฑ์ฅ ํ๊ธฐ
- ๋ฌธ์์ด ์๋ฅด๋ ๊ฑฐ๋ฅผ ํญ์ ๋งจ ์ฒ์ ๊ฐ์ ์์์ ์ผ๋ก ์์ ํ๋ค๋ ๊ฒ์ ๋ฌธ์ ๋ฅผ ๋๊น์ง ์ฝ์ง ์์ ํ์
ํ์ง ๋ชปํ๋ค.
(์๋ฅผ ๋ค์ด xabcabc๋ฅผ 3์ฉ ์๋ฅธ๋ค๊ณ ์น๋ฉด, x / abc / abc ์ด๋ ๊ฒ ๋ชป ์๋ฅด๊ณ ํญ์ xab / bca / bc ์ด๋ ๊ฒ ์๋ผ์ผ ํจ)
๋ฌธ์ ๋ฅผ ๋๊น์ง ์ฝ์!!! - substring์ ์ ์ฌ์ฉํ์ง ์์์, ์ ๋ชฐ๋๋ค. ๊ทธ ๋๋ฌธ์, StringBuilder๋ก๋ง ์ผ์ ์ฒ๋ฆฌํ๋ ค๋ค ๋ณด๋, ๋ฌธ์ ๋ฅผ ๋ ๋ณต์กํ๊ฒ ํผ ๊ฒ ๊ฐ๋ค. ๊ทธ ๋๋ฌธ์ ํฐ ํ๋ฆ์ ๋ง์์ผ๋ ๋๋๋ด ๋ชป ํ์๋ค.
String.substring(int endIndex); // ์ฒ์๋ถํฐ endIndex ์ง์ ๊น์ง์ ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐํ
String.substring(int startIndex, int endIndex); // ์์์ ๋ถํฐ endIndex ์ง์ ๊น์ง ๋ฌธ์์ด์ ๋ฐํ
๋ชจ๋ ์๋ฌธ์๋ก, substring์ด๋ ๊ฒ์ ์ ์ํ์... ๋ ๊ณ์ subString์ด๋ผ ์ ์ด์ ํ๋ ธ๋ค.