- js
- ์ด๋ถํ์
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- ์ฌ๊ท
- Python
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- nestjs
- C++
- ํธ๋ฆฌ
- ์นด์นด์ค2021
- ๋ค์ต์คํธ๋ผ
- DP
- ์นด์นด์ค ์ฝํ
- BFS
- golang
- ์์ฝ๋
- ์ํฐ๋
- Union-Find
- LCs
- ๋นํธ๋งต
- ์น๋ฆฐ์ด
- ๋นํธ๋ง์คํน
- ํ๋ฆฌ์จ๋ณด๋ฉ
- go
- ์๊ณ ๋ฆฌ์ฆ
- DFS
- ๋ฐฑ์ค
- ํ๋ก๊ทธ๋๋จธ์ค
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- Today
- Total
Hello Ocean! ๐ผ
[ํ๋ก๊ทธ๋๋จธ์ค/C++] H-index , K๋ฒ์งธ ์ ๋ณธ๋ฌธ
H-index
์ถ์ฒ : https://programmers.co.kr/learn/courses/30/lessons/42747
๋ฌธ์ ์ค๋ช
H-Index๋ ๊ณผํ์์ ์์ฐ์ฑ๊ณผ ์ํฅ๋ ฅ์ ๋ํ๋ด๋ ์งํ์ ๋๋ค. ์ด๋ ๊ณผํ์์ H-Index๋ฅผ ๋ํ๋ด๋ ๊ฐ์ธ h๋ฅผ ๊ตฌํ๋ ค๊ณ ํฉ๋๋ค. ์ํค๋ฐฑ๊ณผ1์ ๋ฐ๋ฅด๋ฉด, H-Index๋ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํฉ๋๋ค.
์ด๋ค ๊ณผํ์๊ฐ ๋ฐํํ ๋ ผ๋ฌธ nํธ ์ค, h๋ฒ ์ด์ ์ธ์ฉ๋ ๋ ผ๋ฌธ์ด hํธ ์ด์์ด๊ณ ๋๋จธ์ง ๋ ผ๋ฌธ์ด h๋ฒ ์ดํ ์ธ์ฉ๋์๋ค๋ฉด h์ ์ต๋๊ฐ์ด ์ด ๊ณผํ์์ H-Index์ ๋๋ค.
์ด๋ค ๊ณผํ์๊ฐ ๋ฐํํ ๋ ผ๋ฌธ์ ์ธ์ฉ ํ์๋ฅผ ๋ด์ ๋ฐฐ์ด citations๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ด ๊ณผํ์์ H-Index๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
๊ณผํ์๊ฐ ๋ฐํํ ๋
ผ๋ฌธ์ ์๋ 1ํธ ์ด์ 1,000ํธ ์ดํ์
๋๋ค.
๋
ผ๋ฌธ๋ณ ์ธ์ฉ ํ์๋ 0ํ ์ด์ 10,000ํ ์ดํ์
๋๋ค.
ํ์ด
์ฃผ์ด์ง ๋ฐฐ์ด(๋
ผ๋ฌธ๋น ์ธ์ฉ ํ์)๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค,
๋ฐ๋ณตํ๋ฉด์ i๋ฒ์งธ์ ์ธ์ฉ ํ์๊ฐ i๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ผ๋ฉด(ํฌ์ง ์์ผ๋ฉด) ๋ฐ๋ณต๋ฌธ์ด ์ข
๋ฃ๋๋๋ก ์์ฑ
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int solution(vector<int> citations) {
int answer = 0;
sort(citations.begin(), citations.end(), greater<int>()); //๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
for (int i = 0; i < citations.size(); i++){
if (citations[i] <= answer) break;
answer++;
}
return answer;
}
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์
๋๋ค.
ํ์ด
์ฃผ์ด์ง ๋ฐฐ์ด์ i~j๋ฒ์งธ๊น์ง๋ฅผ temp์ ๋ด๊ณ ,
temp๋ฅผ ์ ๋ ฌํ ํ์
k๋ฒ์งธ๋ก ํฐ ์๋ฅผ answer๋ฐฐ์ด์ ๋ฃ์
#include <vector>
#include <algorithm>
using namespace std;
vector<int> solution(vector<int> array, vector<vector<int>> commands) {
vector<int> answer;
for (int i = 0; i < commands.size(); i++){
vector<int> temp;
for (int j = commands[i][0] - 1; j < commands[i][1]; j++) //์ํ๋ ๋ถ๋ถ๋ง temp์ ๋ด๊ธฐ
temp.push_back(array[j]);
sort(temp.begin(), temp.end()); //temp ์ ๋ ฌ
answer.push_back(temp[commands[i][2] - 1]); //temp์์ k๋ฒ์งธ ์๋ฅผ answer์ ๋ด๊ธฐ
}
return answer;
}
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ต๋ ์ต์ ์ฐพ๊ธฐ (ํ ๋๋จผํธ ํธ๋ฆฌ) (0) | 2020.09.07 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ํ์ ์๊ณ ๋ฆฌ์ฆ (์ ํ, ์ด๋ถ, ํด์, BST) (0) | 2020.08.31 |
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ(์ฝ์ , ๋ฒ๋ธ, ํต) (0) | 2020.08.17 |
[์คํฐ๋] ๋นํธ์กฐ์ , ์์ ํ์ (0) | 2020.08.03 |
[์๊ณ ๋ฆฌ์ฆ ์คํฐ๋] ์๋ฃ๊ตฌ์กฐ_2 (0) | 2020.07.28 |