2023. 10. 24. 13:31ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1229
-> ์ด์ ๋ฌธ์ ํ์ด
4. ๋ชจ๋ ์๋๊ทธ๋จ ์ฐพ๊ธฐ
์ค๋ช
S๋ฌธ์์ด์์ T๋ฌธ์์ด๊ณผ ์๋๊ทธ๋จ์ด ๋๋ S์ ๋ถ๋ถ๋ฌธ์์ด์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์๋๊ทธ๋จ ํ๋ณ์ ๋์๋ฌธ์๊ฐ ๊ตฌ๋ถ๋ฉ๋๋ค. ๋ถ๋ถ๋ฌธ์์ด์ ์ฐ์๋ ๋ฌธ์์ด์ด์ด์ผ ํฉ๋๋ค.
์ ๋ ฅ
์ฒซ ์ค์ ์ฒซ ๋ฒ์งธ S๋ฌธ์์ด์ด ์ ๋ ฅ๋๊ณ , ๋ ๋ฒ์งธ ์ค์ T๋ฌธ์์ด์ด ์ ๋ ฅ๋ฉ๋๋ค.
S๋ฌธ์์ด์ ๊ธธ์ด๋ 10,000์ ๋์ง ์์ผ๋ฉฐ, T๋ฌธ์์ด์ S๋ฌธ์์ด๋ณด๋ค ๊ธธ์ด๊ฐ ์๊ฑฐ๋ ๊ฐ์ต๋๋ค.
์ถ๋ ฅ
S๋จ์ด์ T๋ฌธ์์ด๊ณผ ์๋๊ทธ๋จ์ด ๋๋ ๋ถ๋ถ๋ฌธ์์ด์ ๊ฐ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
์์ ์ ๋ ฅ 1
bacaAacba
abc
์์ ์ถ๋ ฅ 1
3
ํํธ
์ถ๋ ฅ์ค๋ช : {bac}, {acb}, {cba} 3๊ฐ์ ๋ถ๋ถ๋ฌธ์์ด์ด "abc"๋ฌธ์์ด๊ณผ ์๋๊ทธ๋จ์ ๋๋ค.
๋ฌธ์ ํ์ด 1
public int solution(String s, String t)
{
int answer = 0;
HashMap<Character, Integer> map = new HashMap<>();
HashMap<Character, Integer> map2 = new HashMap<>();
char[] chars = s.toCharArray();
for (int i = 0; i< t.length() - 1 ; i++)
{
map.put(chars[i], map.getOrDefault(chars[i], 0) + 1);
}
for (char c : t.toCharArray())
{
map2.put(c, map2.getOrDefault(c, 0) + 1);
}
int lt = 0;
for (int i = t.length() -1; i< chars.length; i++)
{
int cnt = 0;
map.put(chars[i], map.getOrDefault(chars[i], 0) + 1);
for (char c : t.toCharArray())
{
if (map.containsKey(c)) {
if (map.get(c) == map2.get(c)) {
cnt++;
} else {
break;
}
} else
{
break;
}
}
if (cnt == t.length())
{
answer++;
}
map.put(chars[lt], map.get(chars[lt]) - 1);
if (map.get(chars[lt]) == 0) {
map.remove(chars[lt]);
}
lt++;
}
return answer;
}
๐ฉ๐ป : ์ด ๋ฌธ์ ๋ ์ ๋ฒ ๋ฌธ์ ํ์ด๋ ๊ฑฐ์ ๋น์ทํ๊ฒ ํ๋ฉด ๋๋ค.
๋จผ์ String s์ ๋ฌธ์ ๋ฐฐ์ด์ ํตํด map์ ๋ฌธ์๋ฅผ key๋ก ๊ทธ๋ฆฌ๊ณ ๊ทธ ๊ฐ์๋ฅผ value๋ก ๋ด์์ค๋ค. (์ฒซ ์ธํ ์ ํ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ t ๋ฌธ์์ด ๊ธธ์ด -1 ๊น์ง๋ง map์ ์ฐ์ ๋ฃ์ด์ค๋ค. -> ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ Sliding Window ์๊ณ ๋ฆฌ์ฆ ์ ์ฉํ ๊ฒ์ด๊ธฐ ๋๋ฌธ)
๋ค์ map2 ์๋ String t ๋ฌธ์ ๋ฐฐ์ด์ ๋ด์์ค๋ค.
๋ค์ for๋ฌธ์ ํตํด t๋ฌธ์์ด ๊ธธ์ด - 1 ๋ถํฐ ์์ํด์ ์ฃผ์ด์ง ๋ฌธ์์ด S์ ๊ธธ์ด๊น์ง ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์
์ฐ์ map์ chars[i]์ ๊ฐ์ key ๊ฐ์ผ๋ก getOrDefault๋ฅผ ํตํด ๊ฐ์ด ์์ผ๋ฉด 0 + 1 ์๋๋ฉด value + 1 ํ๋๋ก ํด์ค๋ค.
๊ทธ๋ฌ๋ฉด ์ผ๋จ t ๋ฌธ์์ด ๊ธธ์ด๋งํผ map์ ๋ฃ์ด์คฌ๊ธฐ ๋๋ฌธ์ t ๋ฌธ์์ด๊ณผ ๋น๊ต๋ฅผ ํด์ ์๋๊ทธ๋จ์ธ์ง ๋จผ์ ๋น๊ตํด์ผ ํ๋ค.
๊ทธ๋ฌ๊ธฐ ์ํด์
for (char c : t.toCharArray())
{
if (map.containsKey(c)) {
if (map.get(c) == map2.get(c)) {
cnt++;
} else {
break;
}
} else
{
break;
}
}
๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ map์ c ๋ฌธ์๊ฐ key๋ก ์๋์ง ํ์ธํ๊ณ map.get(c)์ map2.get(c)๊ฐ ๊ฐ์ผ๋ฉด ์์์ ๋ณ์ cnt์ ๊ฐ์ +1 ์ ํด์ค๋ค. key ๊ฐ ์๋ค๋ ๋ง์ ์๋๊ทธ๋จ์ด ์๋๊ธฐ ๋๋ฌธ์ break๋ก ํด๋น ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ ๋์ค๊ณ , map.get(c) ์ map2.get(c)๊ฐ ๊ฐ์ง ์์ ๋๋ key์ ๊ฐ์๊ฐ ๋ค๋ฅด๋ค๋ ๊ฒ์ด๋ฏ๋ก ์๋๊ทธ๋จ์ด ์๋๋ค.
๋ฐ๋ณต๋ฌธ์ ๋ชจ๋ ๋ค ๋๊ณ cnt์ ๊ฐ์ด t๋ฌธ์์ด์ ๊ธธ์ด์ ๊ฐ์ผ๋ฉด answer์ +1 ์ ํด์ค๋ค. ( ์๋๊ทธ๋จ์ด๋ผ๋ ๋ป!)
(key๊ฐ map์ ๋ชจ๋ ํฌํจ๋์ด ์๊ณ , ๊ฐ์๋ ๊ฐ๋ค๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ ! )
์ด๋ ๊ฒ answer์ +1 ํด์ฃผ๊ณ ๋๋ฉด ์ด์ ๋ค์ ๋ฌธ์๋ก ๋์ด๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ ๊ทธ ์ ์ ๊ฐ (์ ์ผ ์ฒซ๋ฒ์งธ ๊ฐ)์ ์ ๊ฑฐํด์ค์ผ ํ๋ค.
map.put(chars[lt], map.get(chars[lt]) - 1);
if (map.get(chars[lt]) == 0) {
map.remove(chars[lt]);
}
lt++;
lt๋ฅผ ๊ธฐ์ค์ผ๋ก map์์ ๊ฐ์ ๊บผ๋ด -1 ํด์ฃผ๊ณ , ์ด ๊ฐ์ด ๋ง์ฝ 0 ์ด๋ฉด ์ด์ key ๊ฐ๋ remove ํด์ค๋ค.
๊ทธ ๋ค์ lt ๋ฅผ +1 ํด์ค๋ค. (๊ทธ๋์ผ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ก ์์ผ๋ก ๋์ด๊ฐ๋ฉด์ ์๋์ฐ๋ฅผ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ !!)
๋๋ equals๋ก HashMap์ ๋น๊ตํ ์๊ฐ์ ๋ชปํด์ ์ด๋ ๊ฒ ๋ฐ๋ณต๋ฌธ์ผ๋ก key๊ฐ ์๋์ง ํ์ธํ๊ณ get ํด์ value๊ฐ์ ๋น๊ตํด์ค ๊ฒ์ด๋ค.. equals ์ฌ์ฉํ๋ฉด
for (char c : t.toCharArray())
{
if (map.containsKey(c)) {
if (map.get(c) == map2.get(c)) {
cnt++;
} else {
break;
}
} else
{
break;
}
}
if (cnt == t.length())
{
answer++;
}
์ด ๋ถ๋ถ์ ์ ๊ฑฐํ ์ ์๋ค.... ใ
๋ฌธ์ ํ์ด 2
public int solution2(String a, String b)
{
int answer = 0;
HashMap<Character, Integer> am = new HashMap<>();
HashMap<Character, Integer> bm = new HashMap<>();
for (char c : b.toCharArray())
{
bm.put(c, bm.getOrDefault(c, 0) + 1);
}
int L = b.length() - 1;
for (int i = 0; i < L; i++)
{
am.put(a.charAt(i), am.getOrDefault(a.charAt(i), 0) + 1);
}
int lt = 0;
for (int rt = L; rt < a.length(); rt++)
{
am.put(a.charAt(rt), am.getOrDefault(a.charAt(rt), 0) + 1);
if (am.equals(bm))
{
answer++;
}
am.put(a.charAt(lt), am.get(a.charAt(lt)) - 1);
if (am.get(a.charAt(lt)) == 0) {
am.remove(a.charAt(lt));
}
lt++;
}
return answer;
}
๐พ : ๊ฐ์ฌ๋๋ ๋์ ํ์ด ๋ฐฉ์์ ๋์ผํ๋ฐ ์ฌ๊ธฐ์ ๊ฐ์ฌ๋์ HashMap์ equals๋ฅผ ์ฌ์ฉํด์ am๊ณผ bm์ ๋น๊ตํด์คฌ๋ค.
am์ ์ฃผ์ด์ง ๋ฌธ์์ด a์ ๋ํด ๋ฌธ์ ๋ฐฐ์ด๋ก ๋ง๋ค์ด์ b ๋ฌธ์์ด์ ๊ฐ์ -1 ์ ๊น์ง๋ง Map์ Key, ๊ทธ๋ฆฌ๊ณ value (key ์ ๊ฐ์)๋ฅผ ์ ์ฅํด์คฌ๋ค. (์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ก ์์ผ๋ก ์ ์ ์ถ๊ฐํ๋ฉด์ ๊ฐ ๊ฒ์ด๊ธฐ ๋๋ฌธ!)
bm์ ์ฃผ์ด์ง ๋ฌธ์์ด b์ ๋ฌธ์ ๋ฐฐ์ด์ ๋ํด์ Map์ Key, ๊ทธ๋ฆฌ๊ณ value (key ์ ๊ฐ์)๋ฅผ ์ ์ฅํด์คฌ๋ค.
HashMap<Character, Integer> am = new HashMap<>();
HashMap<Character, Integer> bm = new HashMap<>();
for (char c : b.toCharArray())
{
bm.put(c, bm.getOrDefault(c, 0) + 1);
}
int L = b.length() - 1;
for (int i = 0; i < L; i++)
{
am.put(a.charAt(i), am.getOrDefault(a.charAt(i), 0) + 1);
}
๊ทธ ๋ค์์๋ ์ด์ lt, rt ๋ฅผ ์ด์ฉํด์
๋จผ์ for๋ฌธ ๋ฐ๋ณต๋ฌธ์ผ๋ก rt๋ a ๋ฌธ์์ด ๊ธธ์ด๊น์ง ์ญ์ญ ์์ผ๋ก ํ์นธ์ฉ ๋์ด๊ฐ๋ค.
am์ put์ a.charAt(rt) ๋ฅผ key ๊ฐ์ผ๋ก ํ๋ value๊ฐ ์์ผ๋ฉด ๊ทธ value์ +1 ์๋๋ฉด 0 +1 ํด์ค๋ค.
๋ค์ am๊ณผ bm ์ eqauls๋ก ๋น๊ตํด์ ๋์ด ๊ฐ๋ค๋ฉด ์๋๊ทธ๋จ์ด๋ผ๋ ๋ป์ด๊ธฐ ๋๋ฌธ์ answer + 1 ํด์ค๋ค.
am.put(a.charAt(rt), am.getOrDefault(a.charAt(rt), 0) + 1);
if (am.equals(bm))
{
answer++;
}
๊ทธ ๋ค์ ์ด์ rt ๊ฐ ์์ผ๋ก ๊ฐ๊ธฐ์ ์ lt์ ๊ฐ์ ๋นผ์ค์ผ ํ๊ธฐ ๋๋ฌธ์ map.get(a.charAt(lt))์ value ๊ฐ์ ๊ตฌํด์ -1 ํด์ค๋ค.
๊ทธ ๋ค์ ์ด key ๊ฐ์ value๊ฐ 0 ์ด๋ฉด ํด๋น ๋ฌธ์๊ฐ ์๋์ฐ์์ ์๋ค๋ ๋ป์ด๊ธฐ ๋๋ฌธ์ am ์์ remove ํด์ค์ผ ํ๋ค.
๊ทธ ๋ค์ lt ๊ฐ์ +1 ์ฆ๊ฐ ์์ผ์ฃผ๋ฉด ๋๋ค.
๐ต ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ ์ฐจ๊ทผ ์ฐจ๊ทผ ์๊ฐํด๋ณด๋ฉด ๊ทธ๋ ๊ฒ ์์ฒญ ์ด๋ ค์ด ๋์ด๋์ ๋ฌธ์ ๋ ์๋ ๊ฒ ๊ฐ๋ค.
lt , rt ์ ํจ๊ป ํ๋์ฉ ์์ผ๋ก ๋ฐ๋ฉด์ ์ถ๊ฐํ๊ณ ๋น๊ตํ๊ณ ์ญ์ ํ๊ณ ์ด ๊ณผ์ ์ ์๊ฐํ๋ฉด ๋๋ค !