- golang
- LCs
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- ์๊ณ ๋ฆฌ์ฆ
- DFS
- C++
- ํธ๋ฆฌ
- ์นด์นด์ค ์ฝํ
- DP
- ๋นํธ๋ง์คํน
- Python
- ์ด๋ถํ์
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- ์ฌ๊ท
- ์ํฐ๋
- go
- ํ๋ก๊ทธ๋๋จธ์ค
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- ์น๋ฆฐ์ด
- js
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ํ๋ฆฌ์จ๋ณด๋ฉ
- Union-Find
- BFS
- ๋ค์ต์คํธ๋ผ
- nestjs
- ๋ฐฑ์ค
- ์นด์นด์ค2021
- ์์ฝ๋
- ๋นํธ๋งต
- Today
- Total
Hello Ocean! ๐ผ
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋ณด์ ์ผํ (2020 ์นด์นด์ค ์ธํด์ญ) ๋ณธ๋ฌธ
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋ณด์ ์ผํ (2020 ์นด์นด์ค ์ธํด์ญ)
bba_dda 2021. 12. 30. 16:05๋ฌธ์
https://programmers.co.kr/learn/courses/30/lessons/67258
๋ฌธ์ ์์ฝ:
๋ณด์๋ค์ด ์ผ๋ ฌ๋ก ์ง์ด๋์ด ์์ ๋,
์ง์ด๋ ๋ชจ๋ ์ข ๋ฅ์ ๋ณด์์ ์ ์ด๋ 1๊ฐ ์ด์ ํฌํจํ๋ ๊ฐ์ฅ ์งง์ ๊ตฌ๊ฐ์ ์ฐพ์์,
๊ตฌ๊ฐ์ [์์ ์ง์ด๋ ๋ฒํธ, ๋ ์ง์ด๋ ๋ฒํธ]๋ฅผ returnํด๋ผ.
๊ฐ์ฅ ์งง์ ๊ตฌ๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด, ์์ ์ง์ด๋๋ฒํธ๊ฐ ๊ฐ์ฅ ์์ ๊ตฌ๊ฐ์ returnํด๋ผ.
์ง์ด๋๋ฅผ ๋ํ๋ด๋ gems ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ์ต๋ 100000์ด๋ค.
ํ์ด
[code๋ก ๋ง๋ค๊ธฐ, ๋ณด์ ์ข ๋ฅ ์ธ๊ธฐ]
๋ณด์์ ์ข ๋ฅ๊ฐ ๋ช ๊ฐ์ธ์ง input์์ ์๋ ค์ฃผ์ง ์๋๋ค. ๋ฐ๋ผ์ gems๋ฐฐ์ด์ ์ํํ๋ฉด์ ๋ณด์์ ์ข ๋ฅ๋ฅผ countํด์ผํ๋ค.
๋ํ, stringํํ๋ก ์ฐ์ฐํ๋ ๊ฒ์ด ๋ถํธํ ๊ฒ์ผ๋ก ์๊ฐ๋์ด string์ code๋ก ๋ฐ๊ฟ์ฃผ์๋ค.
[์ฌ๋ผ์ด๋ฉ ์๋์ฐ]
gems๋ฐฐ์ด์ ๊ธธ์ด๊ฐ N์ด๋ผ๊ณ ํ ๋,
๊ฐ๊ฐ์ ์์์์น(i)๋ง๋ค ๋ชจ๋ ์ข ๋ฅ์ ๋ณด์์ 1๊ฐ์ด์ ํฌํจํ๋ ๊ฐ์ฅ ์งง์ ๊ตฌ๊ฐ์ ์ฐพ๊ฒ๋๋ฉด, O(N^2)์ ๋ณต์ก๋๊ฐ ๋๋ค.
gems๋ฐฐ์ด์ ์ต๋ ํฌ๊ธฐ๊ฐ 10^5์ด๋ฏ๋ก, O(N^2)์ ๋ณต์ก๋์ผ ๋ ์ต๋ 10^10๋ฒ ๋๊ธฐ ๋๋ฌธ์ ํจ์จ์ฑ ํ ์คํธ๋ฅผ ํต๊ณผํ์ง ๋ชปํ ๊ฐ๋ฅ์ฑ์ด ํฌ๋ค.
๊ทธ๋์ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฐฉ์์ ์ฌ์ฉํ์๋ค.
์๋์ ์์์์, ๋ณด์์ ์ข ๋ฅ๋ 0,1,2์ ์ด ์ธ๊ฐ์ง ์ด๋ค.
0๋ฒ ์ง์ด์ฅ์์ ์์ํ๋ฉด, 2๋ฒ ์ง์ด์ฅ๊น์ง ๊ตฌ๋งคํ๋ฉด ๋ชจ๋ ์ข ๋ฅ์ ๋ณด์์ ํฌํจํ๋ค.
1๋ฒ ์ง์ด์ฅ์์ ์์ํ๋ ๊ตฌ๊ฐ์ ๊ตฌํ ๋, ์ฒ์๋ถํฐ ๋ค์ ์ธ๋ ๊ฒ์ด ์๋๋ผ ์ด์ ์ ์ธ์ด๋์ ๊ฒ์ ํ์ฉํ๋ ๊ฒ์ด๋ค.
0๋ฒ ์ง์ด์ฅ์ ๋ฒ๋ฆฌ๊ณ , ๋ท๋ถ๋ถ์ ์ง์ด์ฅ์ ๋ชจ๋ ์ข ๋ฅ์ ๋ณด์์ ํฌํจํ ๋ ๊น์ง ์ธ์ด๋๊ฐ๋ค.
๊ทธ๋ฆผ์ ๋ณด๋ ๊ฒ์ด ์ดํด๊ฐ ์ฌ์ธ ๊ฒ ๊ฐ๋ค!
์ฝ๋
#include <string>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
vector<int> solution(vector<string> gems) {
vector<int> answer = {1, (int)gems.size()};
vector<int> gem_codes; // intํํ์ gems ๋ฐฐ์ด
map<string, int> codes;
int code = 0;
for (string gem: gems) {
if (codes.count(gem))
gem_codes.push_back(codes[gem]);
else {
codes[gem] = code;
gem_codes.push_back(code++);
}
}
vector<int> have(code);
int end = 0;
for (int i=0;i<gem_codes.size();i++) {
bool flag = true;
while(find(have.begin(), have.end(), 0) != have.end()) {
// ๋ชจ๋ ์ข
๋ฅ์ ๋ณด์์ ํฌํจํ๊ธฐ์ ์, ์ง์ด์ฅ์ด ๋๋๋ฒ๋ฆฐ ๊ฒฝ์ฐ๋ฅผ ๊ตฌ๋ถํ๊ธฐ ์ํจ
if (end >= gem_codes.size()) {
flag = false;
break;
}
have[gem_codes[end++]]++;
}
if (flag && end - (i + 1) < answer[1] - answer[0]) {
answer[0] = i+1; answer[1] = end;
}
have[gem_codes[i]]--;
}
return answer;
}
๊ฒฐ๊ณผ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๊ฒฝ์ฃผ๋ก ๊ฑด์ค (2020 ์นด์นด์ค ์ธํด์ญ) (0) | 2022.01.18 |
---|---|
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋จ์ด ๋ณํ (0) | 2022.01.12 |
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋ถ๋ ์ฌ์ฉ์ (0) | 2021.12.29 |
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ํ ํธ์ง (3) | 2021.12.08 |
[ํ๋ก๊ทธ๋๋จธ์ค/C++] [1์ฐจ] ์ ํ๋ฒ์ค (0) | 2021.12.08 |