๋ฌธ์
ํ์์ด๋ ์ด๋ฒ ์์ด ์ํ์์ ํ๋ฆฐ ๋ฌธ์ ๋ฅผ ๋ฐํ์ผ๋ก ์์ด ๋จ์ด ์๊ธฐ๋ฅผ ํ๋ ค๊ณ ํ๋ค. ๊ทธ ๊ณผ์ ์์ ํจ์จ์ ์ผ๋ก ์์ด ๋จ์ด๋ฅผ ์ธ์ฐ๊ธฐ ์ํด ์์ด ๋จ์ด์ฅ์ ๋ง๋ค๋ ค ํ๊ณ ์๋ค. ํ์์ด๊ฐ ๋ง๋ค๊ณ ์ ํ๋ ๋จ์ด์ฅ์ ๋จ์ด ์์๋ ๋ค์๊ณผ ๊ฐ์ ์ฐ์ ์์๋ฅผ ์ฐจ๋ก๋ก ์ ์ฉํ์ฌ ๋ง๋ค์ด์ง๋ค.
- ์์ฃผ ๋์ค๋ ๋จ์ด์ผ์๋ก ์์ ๋ฐฐ์นํ๋ค.
- ํด๋น ๋จ์ด์ ๊ธธ์ด๊ฐ ๊ธธ์๋ก ์์ ๋ฐฐ์นํ๋ค.
- ์ํ๋ฒณ ์ฌ์ ์์ผ๋ก ์์ ์๋ ๋จ์ด์ผ์๋ก ์์ ๋ฐฐ์นํ๋ค
โM๋ณด๋ค ์งง์ ๊ธธ์ด์ ๋จ์ด์ ๊ฒฝ์ฐ ์ฝ๋ ๊ฒ๋ง์ผ๋ก๋ ์ธ์ธ ์ ์๊ธฐ ๋๋ฌธ์ ๊ธธ์ด๊ฐ M์ด์์ธ ๋จ์ด๋ค๋ง ์ธ์ด๋ค๊ณ ํ๋ค. ํ์์ด๊ฐ ๊ดด๋ก์ด ์๋จ์ด ์๊ธฐ๋ฅผ ํจ์จ์ ์ผ๋ก ํ ์ ์๋๋ก ๋จ์ด์ฅ์ ๋ง๋ค์ด ์ฃผ์.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์์ด ์ง๋ฌธ์ ๋์ค๋ ๋จ์ด์ ๊ฐ์ N๊ณผ ์ธ์ธ ๋จ์ด์ ๊ธธ์ด ๊ธฐ์ค์ด ๋๋ M์ด ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. (1≤N≤100000, 1≤M≤10)
๋์งธ ์ค๋ถํฐ N+1๋ฒ์งธ ์ค๊น์ง ์ธ์ธ ๋จ์ด๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค. ์ด๋์ ์ ๋ ฅ์ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ฃผ์ด์ง๋ฉฐ ๋จ์ด์ ๊ธธ์ด๋ 10์ ๋์ง ์๋๋ค.
๋จ์ด์ฅ์ ๋จ์ด๊ฐ ๋ฐ๋์ 1๊ฐ ์ด์ ์กด์ฌํ๋ ์ ๋ ฅ๋ง ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
ํ์์ด์ ๋จ์ด์ฅ์ ๋ค์ด ์๋ ๋จ์ด๋ฅผ ๋จ์ด์ฅ์ ์์ ์์นํ ๋จ์ด๋ถํฐ ํ ์ค์ ํ ๋จ์ด์ฉ ์์๋๋ก ์ถ๋ ฅํ๋ค.
ํ์ด
์ ๋ ฌ๊ณผ ๋งต์ ์ด์ฉํ ๋ฌธ์ ์ด๋ค.
1. ๊ธธ์ด๊ฐ M ์ด์์ธ ๋จ์ด๊ฐ ๋ค์ด์ฌ ๊ฒฝ์ฐ, ๋จ์ด์ฅ์ ์ถ๊ฐํด์ผ ํ๋ค.
(1) map์ ์ด์ฉํด ๋จ์ด๊ฐ ๋์จ ๊ฐ์๋ฅผ ์ธ์ค๋ค.
(2) ๋จ์ด๊ฐ map์ ์๋ ๊ฒฝ์ฐ(์ค๋ณต์ด ์๋ ๊ฒฝ์ฐ) word_list์๋ ์ถ๊ฐํ๋ค.
2. sort๋ฅผ ์ด์ฉํด word_list๋ฅผ ์ ๋ ฌํ๋ค. ์ด ๋, ์ํ๋ฒณ ์ฌ์ ์์ผ๋ก ์์ ์๋ ๋จ์ด๋ฅผ ์ฐ์ ์ผ๋ก ํด์ผ ํ๊ธฐ ๋๋ฌธ์ a < b๋ฅผ ํด์ค์ผ ํ๋ค. ( a > b๋ก ๋ฌด์ฌ์ฝ ํ๋ฉด..์คํจ์ ๊ตด๋ ์ ๊ฐํ๊ฒ ๋๋ค )
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
map<string, int> word_cnt;
/*
* ๊ธธ์ด๊ฐ m ์ด์์ธ ๋จ์ด๋ค๋ง ์๊ธฐ
* 1) ์์ฃผ ๋์ค๋ ๋จ์ด
* 2) ๋จ์ด ๊ธธ์ด ๊ธธ์๋ก
* 3) ์ํ๋ฒณ ์ฌ์ ์์ผ๋ก ์์ ์๋ ๋จ์ด
*/
bool cmp(const string &a, const string &b) {
if (word_cnt[a] != word_cnt[b])
return word_cnt[a] > word_cnt[b];
if (a.length() != b.length())
return a.length() > b.length();
return a < b;
}
int main() {
int n, m;
string word;
vector<string> word_list;
// ์
๋ ฅ
cin >> n >> m;
while (n--) {
cin >> word;
if (word.length() < m)
continue;
if (!word_cnt[word])
word_list.push_back(word);
word_cnt[word]++;
}
// ์ฐ์ฐ
sort(word_list.begin(), word_list.end(), cmp);
// ์ถ๋ ฅ
for (int i=0; i<word_list.size(); i++)
cout << word_list[i] << "\n";
}
'โจ Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค/C++] 2108๋ฒ: ํต๊ณํ (0) | 2022.07.24 |
---|---|
[๋ฐฑ์ค/C++] 1213๋ฒ: ํฐ๋ฆฐ๋๋กฌ ๋ง๋ค๊ธฐ (0) | 2022.07.24 |
[๋ฐฑ์ค/C++] 20291๋ฒ: ํ์ผ ์ ๋ฆฌ (0) | 2022.07.17 |
[๋ฐฑ์ค/C++] 19583๋ฒ: ์ธ์ด๋ฒ๊ฐ๊ฐ์ดํ (0) | 2022.07.17 |
[๋ฐฑ์ค/C++] 11478๋ฒ: ์๋ก ๋ค๋ฅธ ๋ถ๋ถ ๋ฌธ์์ด์ ๊ฐ์ (0) | 2022.07.17 |
๋๊ธ