https://www.acmicpc.net/problem/13423
๋ฌธ์
์ง์ ์์ ์๋ก ๋ค๋ฅธ N๊ฐ์ ์ ์ด ์ฐํ ์๋ค. ์ i์ ์์น๋ Xi์ด๋ค. N๊ฐ์ ์ ์ค 3๊ฐ๋ฅผ ๊ณจ๋ผ ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ ์ ์ a, ๊ฐ์ด๋ฐ ์๋ ์ ์ b, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ ์ ์ c๋ผ๊ณ ํ์. ๊ฐ๊ฐ์ ์ ์ ์์น๋ Xa, Xb, Xc์ด๋ค. ์ด๋ ์ a, b ์ฌ์ด์ ๊ฑฐ๋ฆฌ์ ์ b, c์ฌ์ด์ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ผ๋ฉด ์ธ ์ ์ ๊ฐ๊ฒฉ์ด ๊ฐ๋ค๊ณ ํ๋ค. ์ฆ, Xb - Xa = Xc – Xb์ผ ๋ ์ธ ์ ์ ๊ฐ๊ฒฉ์ด ๊ฐ๋ค. ๋ค์์ N = 5์ธ ๊ฒฝ์ฐ์ ์์์ด๋ค.
์ ์์์์ ์ ์ ์์น๋ ๊ฐ๊ฐ -4, -1, 0, 2, 4์ด๋ค. ์ด์ค -4, -1, 0์์น์ ์ธ ์ ์ ๊ฐ๊ฐ a, b, c๋ผ๊ณ ํ๋ฉด Xb - Xa = 3, Xc – Xb = 1๋ก ๊ฐ๊ฒฉ์ด ๊ฐ์ง ์๋ค. ๊ทธ๋ฌ๋ -4, -1, 2 ์์น์ ์ธ ์ ์ ๊ฐ๊ฐ a, b, c๋ผ๊ณ ํ๋ฉด Xb - Xa = 3, Xc – Xb = 3์ผ๋ก ์ธ ์ ์ ๊ฐ๊ฒฉ์ด ๊ฐ๋ค. ์ ์์์์ ๊ฐ๊ฒฉ์ด ๊ฐ์ ์ธ ์ a, b, c๋ก ๊ฐ๋ฅํ ๊ฒฝ์ฐ๋ (-4, -1, 2), (-4, 0, 4), (0, 2, 4)์ 3๊ฐ์ง๊ฐ ์๋ค. N๊ฐ์ ์ ์ ์์น๊ฐ ์ฃผ์ด์ก์ ๋, ๊ฐ๊ฒฉ์ด ๊ฐ์ ์ธ ์ ์ผ๋ก ๊ฐ๋ฅํ ๊ฒฝ์ฐ๊ฐ ๋ชจ๋ ๋ช ๊ฐ์ง ์๋์ง ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์์ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๋ค์ ์ค๋ถํฐ ์ฐจ๋ก๋ก T๊ฐ์ ํ ์คํธ ์ผ์ด์ค๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ๊ฐ์ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ์งธ ์ค์ ์ ์ ๊ฐ์ N(3 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ํ ์คํธ ์ผ์ด์ค์ ๋์งธ ์ค์๋ N๊ฐ์ ์ ์ ์์น X1, X2, X3 … Xn์ด ์ฐจ๋ก๋ก ์ฃผ์ด์ง๋ค. ๋ชจ๋ ์ ์ ์์น๋ -100,000,000์ด์ 100,000,000์ดํ์ ์ ์์ด๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ต์ ์์๋๋ก ์ถ๋ ฅํ๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค๋ง๋ค ์ฒซ์งธ ์ค์ ๊ฐ๊ฒฉ์ด ๊ฐ์ ์ธ ์ a, b, c๋ก ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ค๋ฒ2 ๋ง๋..?
์์งํ ๋ ๋๊ฒ ์ณ์ค์ผํจ
์์ ์ ์ํ์ผ๋ก ํ๋ค๊ฐ ์ฅ๋ ฌํ๊ฒ ์คํจํ ๋ฌธ์ ์ธ๋ฐ, ์ด๋ฒ์ฃผ์ ์ฝ์๋ผ ์คํฐ๋์์ ์ด๋ถํ์ ๋ค๋ฃจ๊ธธ๋
๋ค์ ํ์ด๋ณด์๋ค!
๋ณดํต์ ์ ๊ทผ๋ฐฉ๋ฒ์ด
left์ right ์ธ๋ฑ์ค ์ง์ ํด์ ๊ฐ์ด๋ฐ ๊ฐ์ ์ฐพ๋ ์์ผ๋ก ์ ๊ทผํ๋๋ฐ,
๋๋ middle ๊ฐ์ ๋จผ์ ์ง์ ํด์ฃผ๊ณ , left ๊ฐ๊ฒฉ๊ณผ right ๊ฐ๊ฒฉ์ ์ด์ฉํด์ ํ์์ ํด์ฃผ์๋ค. ์ด๊ฒ๋ ์ด๋ถํ์์ธ๊ฐ..?
์ด์จ๋ ๋ ์ด ํ์ด๊ฐ ๋ ํธํ์!
์ ๋ ฌ์ ํ์!
์ฌ์ค ์ด๊ฑฐ ๋ฆฌ์คํธ ์ฒ์์ vector๋ก ์ํ๊ณ ๊ฑ intํ ๋ฐฐ์ด๋ก 1001ํฌ๊ธฐ ์ ์ธํด์ ํ๋จ ๋ง์ด์ง
๊ทผ๋ฐ ๊ทธ๊ฑธ ์ ๋ ฌํ๋ฉด -4, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...์ด๋ด์์ผ๋ก ๋๋๋ฐ
๊ทธ๊ฑธ ๋ฐ๊ฒฌ๋ชปํด์ ๋ช ๋ถ ์ ๋ ํค๋ฉจ๋ค ๋ง์ํ
^^...
๋์ ํ์ด
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t;
int n;
cin >> t;
for (int i = 0; i < t; ++i){
vector<int> dots;
int dot;
cin >> n;
for (int j = 0; j < n;++j){
cin >> dot;
dots.push_back(dot);
}
sort(dots.begin(), dots.end());
int cnt = 0;
for (int m = 1; m < n-1; ++m){
int left = 0;
int right = n - 1;
while(left<right){
if(left==m || m==right) break;
int l_to_m = dots[m] - dots[left];
int m_to_r = dots[right] - dots[m];
if(l_to_m == m_to_r) {
cnt++;
left++;
}
else if(l_to_m > m_to_r) left++;
else right--;
}
}
cout << cnt << "\n";
}
}
๊ทธ๋์ ๋ ์๊ณ ๋ฆฌ์ฆ ์๋์ฐ๋ ๊นํ๋ธ ๋ ํฌ๊ฐ ํฐ์ ธ๋ฒ๋ ธ๋๋ฐ,,, 500
์กฐ์ก๊ตฐ
๋น ๋ฅธ ๋ณต๊ตฌ ๊ธฐ์
๊ทธ๋ฆฌ๊ณ ์์ฆ ๋ธ๋ก๊ทธ ์์ต์ด ์ ์ง๋ง ์๊ทผ ์งญ์งคํด์ ๊ธฐ๋ถ์ด ์ข๋ค
ํฐ์คํ ๋ฆฌ ์ต๊ณ !
'๐ ์๊ณ ๋ฆฌ์ฆ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++/BOJ] 2343 : ๊ธฐํ ๋ ์จ (์ด์งํ์) / ์์ (0) | 2023.03.28 |
---|---|
[C++/BOJ] 5549 : ํ์ฑ ํ์ฌ (๋์ ํฉ) / ์ฝ์ง ๊ธฐ๋ก (0) | 2023.03.28 |
[C++/BOJ] 17609 : ํ๋ฌธ (ํฌํฌ์ธํฐ) / ํ ์คํธ์ผ์ด์ค / ์ฝ์ง ๊ธฐ๋ก (0) | 2023.03.25 |
[C++/BOJ] 14891 : ํฑ๋๋ฐํด (์๋ฎฌ๋ ์ด์ ) (0) | 2023.03.23 |
[C++/BOJ] 17836 : ๊ณต์ฃผ๋์ ๊ตฌํด๋ผ! (์๋ฎฌ๋ ์ด์ ) / ์ฝ์ง ๊ธฐ๋ก (0) | 2023.03.23 |