๋ฌธ์ ํ์
๋ฌธ์์ด s
๊ฐ ์ฃผ์ด์ง๋ค.
๋ฌธ์๊ฐ ๋ฐ๋ณต๋์ง ์๋ ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐํํด์ผํ๋ค.
ํ์ด
1๏ธโฃ Queue ๋ฅผ ์ด์ฉํ ํ์ด
๐ก ๋ ์ค๋ฅธ Idea
๋ฌธ์์ด์ ์ํํ๋ฉด์,Queue
์ ๋ฌธ์๋ฅผ ์ ๋ ฅํ๋ค.
๋จ, ์ ๋ ฅํ๊ธฐ ์ , ์ ๋ ฅํ๋ ค๋ ๋ฌธ์๊ฐQueue
์ ์ด๋ฏธ ์กด์ฌํ๋ค๋ฉด ๊ทธ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๋ ฅํ๋ค.
๋ง์ฝ pwwkew
๋ฌธ์์ด์ธ ๊ฒฝ์ฐ
์ฒซ p
๋ ํ์ ์์ผ๋ฏ๋ก ํ์ ์
๋ ฅํ๋ค.
Queue = [ p ]
๋๋ฒ์งธ w
๋ก ์์ง ํ์ ์์ผ๋ฏ๋ก ํ์ ์
๋ ฅํ๋ค.
Queue = [ p, w ]
์ธ๋ฒ์งธ w
๋ ์ด๋ฏธ ํ์ ์กด์ฌํ๋ ๋ฌธ์์ด๋ฏ๋ก ํ์ ๋ฌธ์ w
๊ฐ ์์ด์ง๋๊น์ง pop
ํ๋ค. ๊ทธ๋ฆฌ๊ณ ์
๋ ฅํ๋ค.
Queue = [ w ]
...
์ด๋ฐ์์ผ๋ก ์งํ๋๋ฉด์ ์ค๋ณต๋๋ ๋ฌธ์๊ฐ ์๋ ๋ถ๋ถ ๋ฌธ์์ด์ด ํ์ ๊ฐฑ์ ๋๋ค.
class Solution {
public int lengthOfLongestSubstring(String s) {
int ans = 0;
Queue<Character> q = new LinkedList<>();
char[] split = s.toCharArray();
int N = split.length;
for (int i = 0; i < N; i++) {
if (q.contains(split[i])) {
while (!q.isEmpty() && q.peek() != split[i]) {
q.poll();
}
q.poll();
q.offer(split[i]);
} else {
q.offer(split[i]);
}
ans = Math.max(ans, q.size());
}
return ans;
}
}
๊ฒฐ๊ณผ
๊ฒฐ๊ณผ๋ ํต๊ณผํ์ง๋ง, ํ์ contains()
๋ฉ์๋์ ๊ฒฝ์ฐ ํ๋ LinkedList
์ด๊ธฐ ๋๋ฌธ์
ํน์ ์์๋ฅผ ์ฐพ์๋ ์์๋ค์ ์ํํด์ ์ฐพ์์ผ ํ๋ฏ๋ก, ์ ์ฝ๋๋ ์๊ฐ๋ณต์ก๋๊ฐ ์ต๋ O(N^2) ์ด๋ค.
๋ฐ๋ผ์, ๋ ๋น ๋ฅธ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๊ณ ๋ฏผํด๋ณด์๋ค.
2๏ธโฃ set์ ์ด์ฉํ ํ์ด
ํด๊ฒฐ ๋ฐฉ๋ฒ์ ๋ฐฉ๋ฒ 1๊ณผ ์ ์ฌํ๋ค. ๋จ, set
์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์ contains
์๊ฐ ๋ณต์ก๋๋ฅผ O(1) ๋ก ์ฌ์ฉํ ์ ์๋ค.
ํฌ์ธํฐ๋ฅผ ํตํด์, ์ ๊ฑฐํด์ผํ ์์๋ฅผ ์ฒดํฌํ ์ ์๋๋ก ๊ตฌํํ์๋ค.
import java.util.*;
class Solution {
public int lengthOfLongestSubstring(String s) {
int ans = 0;
char[] split = s.toCharArray();
int N = split.length;
int pointer = 0;
HashSet<Character> set = new HashSet<>();
for (int i = 0; i < N; i++) {
char target = split[i];
if (set.contains(target)) {
while (split[pointer] != target) {
set.remove(split[pointer++]);
}
set.remove(split[pointer++]);
set.add(target);
} else {
set.add(target);
}
ans = Math.max(ans, set.size());
}
return ans;
}
}
๊ฒฐ๊ณผ
์ด์ ๋ฐฉ๋ฒ๋ณด๋ค๋ ์ฝ๊ฐ ์๊ฐ์ ๋จ์ถํ ์ ์์๋ค.
๐ ํ๊ณ
์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ ๋, ๋ ๋ฎ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ๋ก ํด๊ฒฐํ ์ ์๋์ง ํ์ธํด๋ณด๊ณ ํ์ฉํ์ฌ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์งค ์ ์๋๋ก ํด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค.