์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ | ์ ๋ต ๋น์จ |
1์ด | 256MB | 19.578% |
13414๋ฒ: ์๊ฐ์ ์ฒญ
์ ๋ ฅ ๋ฐ์ดํฐ๋ ํ์ค ์ ๋ ฅ์ ์ฌ์ฉํ๋ค. ์ ๋ ฅ์ 1๊ฐ์ ํ ์คํธ ๋ฐ์ดํฐ๋ก ๊ตฌ์ฑ๋๋ค. ์ ๋ ฅ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ๊ณผ๋ชฉ์ ์๊ฐ ๊ฐ๋ฅ ์ธ์ K(1 ≤ K ≤ 100,000)์ ํ์๋ค์ด ๋ฒํผ์ ํด๋ฆญํ ์์๋ฅผ ๊ธฐ๋กํ ๋๊ธฐ๋ชฉ๋ก์ ๊ธธ์ด L(1 ≤ L ≤ 500,000)์ด ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค๋ถํฐ L๊ฐ์ ์ค์๋ ์๊ฐ์ ์ฒญ์ ๋ฒํผ์ ํด๋ฆญํ ํ์์ ํ๋ฒ์ด ํด๋ฆญ ์์๋๋ก ์ฃผ์ด์ง๋ค. ํ๋ฒ์ 8์๋ฆฌ์ ์ซ์๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
www.acmicpc.net
๋ฌธ์
์ํ์ฐฉ์ค
์ฒ์์ ์ ๊ทผ์ ์๋ชปํด์ ์ด๋ผ ๋ง์ด ํ๋ฆผ. ๋ฐํ์์๋ฌ๋ ๋ฌ์๊ณ ๋ฐํ์์๋ฌ ์ก์ผ๋ ์๊ฐ์ด๊ณผ ๋ ์ ์์ ๋ฉ๋ถ..
์ ๋ ฅ์ผ๋ก ๋ค์ด์จ ํ๋ฒ๋ค์ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ ์ฅํ์ง ์๊ณ ๋จ์ map์ผ๋ก๋ง ํ ์ ์์ง ์์๊น ์ถ์ด์ map์ {ํ๋ฒ, ์์}๋ฅผ ์ ์ฅํ๊ณ ๊ทธ ํ์, key๊ฐ ์๋ value๋ก ์ ๋ ฌํ๊ณ ์ถ์ด์ vector๋ก ๋ณต์ฌํ๊ณ , cmpํจ์ ์ฌ์ฉํด์ ์ ๋ ฌํ๊ณ , ์ถ๋ ฅํ๋ ๋ฐฉ์์ผ๋ก ํ์๋ค.
๊ทธ๋ฐ๋ฐ ์๊ฐ์ด๊ณผ๊ฐ ์๋ ๊ฒ ๊ฐ์๋๋ฐ ๋ณต์ฌํ๋๋ฐ ์ค๋๊ฑธ๋ฆฐ๊ฑด์ง.. ๋๋์ฒด ์ ์๊ฐ์ด๊ณผ ๋ฌ๋์ง ์์ง๋ ์ ๋ชจ๋ฅด๊ฒ ์ง๋ง ๊ฒฐ๊ตญ ์ ๋ถ ์ง์ฐ๊ณ ๋ค์ํ์๋๋ฐ, map์ value๊ฐ์ผ๋ก ์ ๋ ฌํ๋ ๊ฒ๋ณด๋ค ์ ๋ ฅ๋ฐ์์ ๋ ์ ๋ ฅ๋ฐ์ ํ๋ฒ๋ค์ ๋ฐฐ์ด์ ์ ์ฅํด์ ๋ฐฐ์ด์ ์ด์ฉํด์ ํ ์ ์์๋ค.
๊ทธ๋ฆฌ๊ณ ๋ ํ๋ ์ด๋ ค์ ๋ ์ ์ string์ ์ฐ์ง ์๊ณ intํ์ผ๋ก ์ ๋ ฅ์ ๋ฐ๋ค๋ณด๋ 0000000 ์ด๋ฐ ๊ฐ์ 0์ผ๋ก ์ธ์๋์ด์ 8์๋ฆฌ๋ฅผ ๋ง์ถ๊ธฐ ์ํ์ฌ ์ถ๋ ฅํ์์ "%08d" ์ด๋ ๊ฒ ์ผ๋ค. ์๋ฏธ๋ 8์๋ฆฌ ์ผ์ชฝ์ ๋ ฌ์ด๋ฉฐ ๋น ๊ณต๊ฐ์ 0์ผ๋ก ์ฑ์ฐ๊ฒ ๋ค๋ ์๋ฏธ์ด๋ค. %08d ํ์์ง์ ์๋ฅผ ์์ผ๋ก์จ string์ ์ ์ถ๋ ฅ์ ์ํด ์ฌ์ฉํด์ผํ๋ ์๋ ๋ฌธ์ฅ๋ค์ ์์จ๋ ๋ผ์ ์ฐธ ์ข์๋ค.
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
์ฐธ๊ณ ๋งํฌ 1. vector ์ ๋ ฌ: vector cmp ํจ์ ๊ด๋ จ
How do I sort a vector of pairs based on the second element of the pair?
If I have a vector of pairs: std::vector<std::pair<int, int=""> > vec; Is there and easy way to sort the list in increasing order based on the second element of the pair? I know I can w...</std::pair<int,>
stackoverflow.com
์ฐธ๊ณ ๋งํฌ 2. ์ธ์ด๋ณ input method ๋น๊ต: cin, cout ์ธ ๋ ์์ ๋ฌธ์ฅ์ ์จ์ผํ๋ ์ด์
algospot.com :: ์์ ๊ฒ์ํ: ๊ฐ ์ธ์ด๋ณ input method ๋น๊ต
๊ฐ ์ธ์ด๋ณ input method ๋น๊ต 13๊ฐ์ ๋๊ธ์ด ์์ต๋๋ค.
algospot.com
์ฝ๋ ์ผ๋ถ
bool cmp(const p& a, const p& b) {
return a.second < b.second;
}
// ๋ฉ์ธํจ์
map<int, int> m;
...
// map ๋ณต์ฌ
vector<p> v(m.begin(), m.end());
//sort(v.begin(), v.end(), cmp);
// c++14 ์์๋ auto๋ฅผ ํ์ฉํ์ฌ ์ด๋ ๊ฒ ์ ๋ ฌํ ์๋ ์๋ค.
sort(v.begin(), v.end(), [](auto& left, auto& right) {
return left.second < right.second;
});
...
ํด๊ฒฐ
key point, map์ ํ์ฉํด์ ๊ฐ ํ์์ด ์ต์ข ์ ์ผ๋ก ๋ช ๋ฒ์งธ๋ก ๋ค์ด์๋์ง ์ ์ฅํ๋ค.
- ํ๋ฒ์ key๋ก, ๋ค์ด์จ ์์๋ฅผ value๋ก map์ ๊ตฌ์ฑํ๋ค.
- ์ ๋ ฅ๋ฐ์ ํ๋ฒ์ ๋ ๋ค๋ฅธ int๋ฐฐ์ด์ ์์๋๋ก ์ ์ฅํ๋ค.
- 1๋ถํฐ ๋ง์ง๋ง ์์๊น์ง ์ฐจ๋ก๋ก ๋๋ฉด์ i๋ฒ์งธ๋ก ๋ค์ด์จ ํ์์ด map์์ ์ ์ฅํ ์์์ ๊ฐ์์ง ํ๋จํ์ฌ ๊ฐ์ผ๋ฉด ์ถ๋ ฅํ๊ณ cnt๋ฅผ ์ฆ๊ฐ์ํจ๋ค.
- cnt๊ฐ k์ ๊ฐ์์ง๋ฉด k๋ช ๊น์ง ๋ชจ๋ ์ ์ ๋ ๊ฒ์ด๋ฏ๋ก ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๋ค.
์ฝ๋
๋ฉ๋ชจ๋ฆฌ | ์๊ฐ |
13312 KB | 472 ms |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
int k, l, arr[500005];
map<int, int> m;
int main() {
scanf("%d %d", &k, &l);
string s;
for (int i = 0; i < l; i++) {
scanf("%d", &arr[i]);
m[arr[i]] = i;
}
int cnt = 0;
for (int i = 0; i < l; i++) {
if (cnt >= k)break;
if (m[arr[i]] == i) {
printf("%08d\n", arr[i]);
cnt++;
}
}
return 0;
}
|
cs |
ํ๊ธฐ
์ฒ์ ์ ๊ทผ์ ์๋ชปํด์ ํฐ ์ฝ ๋ค์น ๋ฌธ์ .. ์์ง ์๊ฒ ์ด
๊ทธ๋ฆฌ๊ณ ์ด๋ฒ ๋ฌธ์ ๋ํ k๋์ ์์๋ฅผ ์จ์ ๋ง์ด ํ๋ ธ๋๋ฐ... ๋ง์ง๋ง ์ค์์ด๊ธธ
'๐ฅ PS(Problem Solving) ๐ฅ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] #1912 ์ฐ์ํฉ (0) | 2020.05.11 |
---|---|
[BOJ] #2512 ์์ฐ (0) | 2020.05.11 |
[BOJ] #1748 ์ ์ด์ด ์ฐ๊ธฐ 1 (0) | 2020.04.23 |
[BOJ] #1953 ํ๋ฐฐ๋ถ (0) | 2020.04.21 |
[BOJ] #1068 ํธ๋ฆฌ (1) | 2020.04.17 |
๋๊ธ