- Python
- ์ ์๋ก
- ์ ๋ ฌ
- BOJ
- greedy
- queue
- dfs
- stack
- ๊ตฌํ
- Dynamic Programming
- ๋ฌธ์์ด
- DP
- LV2
- PGM
- CodingTest
- ์๋ฎฌ๋ ์ด์
- SpringBoot
- ๋๋น ์ฐ์ ํ์
- ๊ต์ฌ
- Study
- ์ํ
- BFS
- ๊น์ด ์ฐ์ ํ์
- ๊ทธ๋ํ ์ด๋ก
- ๊ทธ๋ํ ํ์
- ๋ฐฑํธ๋ํน
- Java
- sort
- Brute Force Algorithm
- ์๋ฃ๊ตฌ์กฐ
๊ธฐ๋ก๋ฐฉ
PGM : K๋ฒ์งธ์ ๋ณธ๋ฌธ
๐น ๋ฌธ์ ๐น
๋ฐฐ์ด array์ i๋ฒ์งธ ์ซ์๋ถํฐ j๋ฒ์งธ ์ซ์๊น์ง ์๋ฅด๊ณ ์ ๋ ฌํ์ ๋, k๋ฒ์งธ์ ์๋ ์๋ฅผ ๊ตฌํ๋ ค ํฉ๋๋ค.
์๋ฅผ ๋ค์ด array๊ฐ [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3์ด๋ผ๋ฉด
- array์ 2๋ฒ์งธ๋ถํฐ 5๋ฒ์งธ๊น์ง ์๋ฅด๋ฉด [5, 2, 6, 3]์ ๋๋ค.
- 1์์ ๋์จ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ฉด [2, 3, 5, 6]์ ๋๋ค.
- 2์์ ๋์จ ๋ฐฐ์ด์ 3๋ฒ์งธ ์ซ์๋ 5์ ๋๋ค.
๋ฐฐ์ด array, [i, j, k]๋ฅผ ์์๋ก ๊ฐ์ง 2์ฐจ์ ๋ฐฐ์ด commands๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, commands์ ๋ชจ๋ ์์์ ๋ํด ์์ ์ค๋ช ํ ์ฐ์ฐ์ ์ ์ฉํ์ ๋ ๋์จ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐น ์ ํ์ฌํญ ๐น
- array์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- array์ ๊ฐ ์์๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- commands์ ๊ธธ์ด๋ 1 ์ด์ 50 ์ดํ์ ๋๋ค.
- commands์ ๊ฐ ์์๋ ๊ธธ์ด๊ฐ 3์ ๋๋ค.
๐น ์ ์ถ๋ ฅ ๐น
์์
์ค๋ช
array commands return [1, 5, 2, 6, 3, 7, 4] [[2, 5, 3], [4, 4, 1], [1, 7, 3]] [5, 6, 3]
[1, 5, 2, 6, 3, 7, 4]๋ฅผ 2๋ฒ์งธ๋ถํฐ 5๋ฒ์งธ๊น์ง ์๋ฅธ ํ ์ ๋ ฌํฉ๋๋ค. [2, 3, 5, 6]์ ์ธ ๋ฒ์งธ ์ซ์๋ 5์ ๋๋ค.
[1, 5, 2, 6, 3, 7, 4]๋ฅผ 4๋ฒ์งธ๋ถํฐ 4๋ฒ์งธ๊น์ง ์๋ฅธ ํ ์ ๋ ฌํฉ๋๋ค. [6]์ ์ฒซ ๋ฒ์งธ ์ซ์๋ 6์ ๋๋ค.
[1, 5, 2, 6, 3, 7, 4]๋ฅผ 1๋ฒ์งธ๋ถํฐ 7๋ฒ์งธ๊น์ง ์๋ฆ ๋๋ค. [1, 2, 3, 4, 5, 6, 7]์ ์ธ ๋ฒ์งธ ์ซ์๋ 3์ ๋๋ค.
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
๋ฐฐ์ด์ ์๋ฅด๊ณ , ์ ๋ ฌํ๊ณ , ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ๊ฐ์ ธ์ค๋ ๋ฌธ์ ์ ๋๋ค.
๋ฐฐ์ด์ vector<int> ๋ฅผ ์ฌ์ฉํ์ต๋๋ค.
๐ธ ์ฝ๋ ๐ธ
//#include<iostream>
#include <vector>
#include<algorithm>
using namespace std;
vector<int> solution(vector<int> array, vector<vector<int>> commands) {
vector<int> answer;
for (vector<int> cm : commands) {
vector<int> temp(cm[1]-cm[0]+1);
copy(array.begin()+cm[0]-1,array.begin()+cm[1],temp.begin());
sort(temp.begin(),temp.end());
answer.push_back(temp[cm[2]-1]);
}
return answer;
}
๐ธ ์ฝ๋ ํด์ ๐ธ
copy() ํจ์๋ฅผ ํตํด ๋ฐฐ์ด์ ์ฌ๋ผ์ด์ฑ ํ์ต๋๋ค.
๐ธ code review ๐ธ
for (vector<int> cm : commands) {
- A : cm์ด ๋ณต์ฌ ์์ฑ๋๊ณ ์์ต๋๋ค. vector& ๋๋ auto&๋ก ๋ฐ๊ฟ์ฃผ์ธ์.
- ๋ : K๋ฒ์งธ์ ๋ฌธ์ ์์, vector์ ํน์ ๋ถ๋ถ์ ๋ณต์ฌํ๋๋ฐ temp๋ฅผ ์ฌ์ฉํ์ต๋๋ค. ์ด๋ temp๋ฅผ ์ ์ธํ๊ณ reserve๋ก ๊ณต๊ฐ๋ง ํ ๋นํ๋ฉด ๋ณต์ฌ๊ฐ ์๋๋๋ผ๊ตฌ์..? ๊ทธ๋์ for๋ฌธ์์ vector๋ฅผ ๊ณ์ ๋ฐ๋ณตํ๋๋ฐ ์ข ๋ญ๋น์ธ ๊ฒ ๊ฐ์ ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์์๊น ํฉ๋๋ค.
B : reserve ํจ์๋ฅผ ์ด์ฉํ์ฌ capacity๋ฅผ ๋ถ์ฌํ ๊ฒฝ์ฐ์๋, ๊ณต๊ฐ์ ์์ฝ์ ํ์ง๋ง, ์ค์ ๋ก ํ ๋น์ด ๋์ด์์ง ์๊ธฐ ๋๋ฌธ์, temp.begin() ํจ์์์๋ ์ฃผ์๊ฐ ์๋ค๊ณ ํ๋จ์ ํ๋ ๊ฒ์ ๋๋ค.
๋ฐ๋ผ์ back_inserter ํจ์๋ฅผ ์ด์ฉํ์ฌ temp์ ํ ๋นํ๋ฉฐ ์ฝ์ ์ ํด์ผํฉ๋๋ค!
ํด๋น ํจ์๋ push_back ํจ์๊ฐ ๋ด์ฅ๋์ด์์ด์ ์ค๋ฒ๋ก๋ฉ์ด ์๋์ผ๋ก ๋๋ค๊ณ ํ๋ค์.
copy ํจ์๋ = ์ฐ์ฐ์ ํ๋ค๊ณ ํ๋ค์.
=> ์ด๊ฑฐ ๋๋ฌธ์ ์ค์ size๊ฐ ์๋ ๊ฑธ = ์ฐ์ฐํ๋ ค๋ ๋ฌธ์ ๊ฐ ์๊ธฐ๋ ๊ฒ ๊ฐ์์.
์๋์๋ ์์ต๋๋ค.. ใ ใ ;
A : copy๋ capacity๊ฐ ์๋๋ผ size๊ฐ ํ๋ณด๋์ด ์์ด์ผ ํฉ๋๋ค.
A : ํ์ํ ๋ถ๋ถ๋ง ๋ณต์ฌํ๋ ๊ฐ์ฅ ๊ฐ๊ฒฐํ ์ฝ๋๋ฅผ ๋ง๋๋ ค๋ฉด ๋ฒกํฐ์ ์์ฑ์ ์ค์ ์ด๊ธฐ ๋ฐ์ดํฐ๋ฅผ ์ํํ๊ธฐ ์ํ ๋ฐ๋ณต์ ์์ ์ธ์๋ก ๋ฐ๋ ๋ฒ์ ์ด ์๋๋ฐ ๊ทธ๊ฑธ ํตํด์ temp ๋ฒกํฐ๋ฅผ ์์ฑํด์ฃผ๋ ๊ฒ์ ๋๋ค.
๊ฐ์ฅ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก๋ temp ๋ฒกํฐ๋ฅผ for๋ฌธ ๋ฐ์ผ๋ก ๋นผ๋ด์ ๋งค ๋ฐ๋ณต๋ง๋ค vector๊ฐ ์๋ฉธํ์ง ์๋๋ก ํด์ฃผ๊ณ , for๋ฌธ ์ง์ ์ ์ array.size()๋งํผ์ capacity๋ฅผ ํ๋ณดํ ํ for๋ฌธ ๋ด์์๋ assign์ ํตํด ํ์ํ ํญ๋ชฉ์ด์ด ๋ณต์ฌ๋๋๋ก ํ๋ ๊ฒ์ ๋๋ค.
์ด๋ ๊ฒ ํ๋ฉด ๋ฒกํฐ์ ํญ๋ชฉ์ด์ด ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๋ ๋ณํ์ง ์์ผ๋ฉด์ ํ์ํ ๋งํผ๋ง ๋์ ์ผ๋ก resize๋๋ฉฐ ๋ถํ์ํ ์ค๋ณต ์ด๊ธฐํ๋ ๋ฐ์ํ์ง ์์ต๋๋ค.
๐ธ feedback code ๐ธ
#include <vector>
#include<algorithm>
using namespace std;
vector<int> solution(vector<int> array, vector<vector<int>> commands) {
vector<int> answer;
vector<int> temp(array.size());
for (vector<int>& cm : commands) {
temp.assign(array.begin() + cm[0] - 1, array.begin() + cm[1]);
sort(temp.begin(), temp.end());
answer.push_back(temp[cm[2] - 1]);
}
return answer;
}
๐ธ end ๐ธ
vector์ ๋ณต์ฌ๊ฐ ์์ง ์ต์ํ์ง ์์์ copy๋ฅผ ์ธ๋ฐ ์์ด ์ฌ์ฉํ ๊ฒ ๊ฐ๋ค.
vector์ capacity ํ ๋น๊ณผ ๊ฐ ํ ๋น์ ๊ตฌ๋ถํ ์ ์์ด์ผ ๊ฒ ๋ค.
'CodingTest > C++' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_2204 : ๋๋น์ ๋๋ ์ฆ ํ ์คํธ (0) | 2022.05.18 |
---|---|
BOJ_22351 : ์ํ์ ์ฒด์ก๊ณผ๋ชฉ ์ ๋๋ค 3 (0) | 2022.05.12 |
PGM : lv2_์ฌ์ ์ ๋ถ๋ถ๋ฌธ์์ด (0) | 2022.04.02 |
PGM : ๋ ๋งต๊ฒ (0) | 2022.04.02 |
BOJ_1021 : ํ์ ํ๋ ํ (0) | 2022.03.27 |