๋ฐฑ์ค 28325
๋ฌธ์
KOI ํธ์ซ๊ฐ์ ์ฌ๋ฌ ๊ฐ๋ฏธ๊ฐ ๋ชจ์ฌ ์ฌ๋ ๊ฐ๋ฏธ๊ตด์ด ์๋ค. ๊ฐ๋ฏธ๊ตด์ ๋ฅ๊ทผ ํธ์์ ๋๋ ๋ฅผ ๋ฐ๋ผ 1๋ถํฐ ๐๊น์ง์ ๋ฒํธ๊ฐ ๋ถ์ ๐๊ฐ์ ๋ฐฉ์ด ์ฐจ๋ก๋๋ก ์ํ์ผ๋ก ๋ฐฐ์น๋์ด ์์ผ๋ฉฐ, ๋ชจ๋ ๐ (1≤๐≤๐−1)์ ๋ํด ๐๋ฒ์งธ ๋ฐฉ๊ณผ ๐+1๋ฒ์งธ ๋ฐฉ์ด, ๊ทธ๋ฆฌ๊ณ ๐๋ฒ์งธ ๋ฐฉ๊ณผ 1๋ฒ์งธ ๋ฐฉ์ด ํต๋ก๋ก ์ง์ ์ฐ๊ฒฐ๋์ด ์๋ ํํ์๋ค.
ํ์ง๋ง ์ฌ๋ฌ ์ด์ ๋ก ์ธํด ๊ฐ ๋ฐฉ์์ ๋ช ๊ฐ์ ์ชฝ๋ฐฉ์ด ๊ฐ๋ผ์ง๊ธฐ ์์ํด์, ํ์ฌ๋ ๋ชจ๋ ๐ (1≤๐≤๐)์ ๋ํด, ๊ฐ๋ฏธ๊ตด์ ๐๋ฒ์งธ ๋ฐฉ์ ๐ถ๐๊ฐ์ ์ชฝ๋ฐฉ์ด ํต๋ก๋ก ์ง์ ์ฐ๊ฒฐ๋์ด ์๋ค. ๐๋ฒ์งธ ๋ฐฉ๊ณผ ์ฐ๊ฒฐ๋ ์ชฝ๋ฐฉ์ ๐๋ฒ์งธ ๋ฐฉ ์ด์ธ์ ๋ค๋ฅธ ๋ฐฉ๊ณผ ํต๋ก๋ก ์ฐ๊ฒฐ๋์ด ์์ง ์๋ค.
์๋ฅผ ๋ค์ด ๐=7์ด๊ณ , ๐ถ=[3,0,0,1,0,2,0]์ธ ๊ฐ๋ฏธ๊ตด์ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ํํ์ด๋ค.

๊ฐ๋ฏธ๊ตด์ ๊ฐ ๋ฐฉ๊ณผ ์ชฝ๋ฐฉ์๋ ์ต๋ ํ ๋ง๋ฆฌ์ ๊ฐ๋ฏธ๊ฐ ์ด ์ ์๋ค. ๋ง์ฝ ํต๋ก๋ก ์ง์ ์ฐ๊ฒฐ๋์ด ์๋ ๋ ๊ณณ(๋ฐฉ ๋๋ ์ชฝ๋ฐฉ) ๋ชจ๋์ ๊ฐ๋ฏธ๊ฐ ์ด๊ณ ์๋ค๋ฉด, ๋ ๊ฐ๋ฏธ๋ ์๋ก ๋ถํธํดํ๋ค. ์ด๋ฌํ ๋ถํธํจ์ ๋ฐฉ์งํ๊ธฐ ์ํด, ํ์ฌ ๊ฐ๋ฏธ๊ตด์ ๊ฐ ํต๋ก๊ฐ ์ง์ ์ฐ๊ฒฐํ๋ ๋ ๊ณณ ์ค ์ต๋ ํ ๊ณณ์๋ง ๊ฐ๋ฏธ๊ฐ ์ด๊ณ ์๋ค.
๊ฐ๋ฏธ๋ค์ ๋๋ํ๊ธฐ ๋๋ฌธ์, ์ด ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํ์ ์ต๋ํ ๋ง์ ์์ ๊ฐ๋ฏธ๋ค์ด ํ์ฌ ๊ฐ๋ฏธ๊ตด์ ์ด๊ณ ์๋ค๊ณ ํ๋ค. ํ์ฌ ๊ฐ๋ฏธ๊ตด์ ๊ตฌ์กฐ๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ๋ฏธ๊ตด์ ์ด๊ณ ์๋ ๊ฐ๋ฏธ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
ํ์ด
์กฐ๊ฑด๋ถ๋ก ํ๋ฉด ๋๋ค. ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๊น์ด ๊ฒ ๊ฐ๋ค.
์ชฝ๋ฐฉ์ ๋ฌด์กฐ๊ฑด ํ๊ฐ ์ด์์ด๋ค. ๊ทธ๋ฌ๋ฏ๋ก ํน์ ํ ๋ฐฉ์ ์ชฝ๋ฐฉ์ด ์์ผ๋ฉด, ๊ทธ ๋ฐฉ์๋ ๋ฌด์กฐ๊ฑด ํ๋ ์ด์์ ๊ฐ๋ฏธ๊ฐ ๋ค์ด๊ฐ ์ด ์ ์๊ณ , ๊ทธ ์๋ฐฉ ๋๊ฐ์๋ ๊ฐ๋ฏธ๊ฐ ๋ค์ด๊ฐ์ ์ด ์ ์๋ค.
๊ทธ๋ฌ๋ฏ๋ก ์ชฝ๋ฐฉ์ด ์๋ค๋ฉด ๋ฌด์กฐ๊ฑด์ ์ผ๋ก ์ฒดํฌํด์ผํ๊ณ , ์ชฝ๋ฐฉ๊ณผ ์ชฝ๋ฐฉ ์ฌ์ด์ ๋ฐฉ์ ๊ฐ์๋ฅผ ๊ณ์ฐํ์ฌ ๊ฐ๋ฏธ๊ฐ ์ผ๋ง๋ ๋ค์ด์์ ์ด ์ ์๋์ง ์๊ฐํ๋ฉด ๋๋ค.
์ํ์ธ ์ ๋ง ์ฃผ์ํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด ๋๋ค.
์ชฝ๋ฐฉ์ ๋ค์ด๊ฐ๋๊ฒ ๋ฌด์กฐ๊ฑด ์ข์๊ฑฐ๊ฐ๊ธดํ๋ฐ, ์ฆ๋ช
์ ๋ชปํ๊ฒ ๋ค. ๊ท๋ฅ๋ฒ์ผ๋ก ํ๋ฉด ๋๋?
์ฝ๋
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
ll N, arr[250001], ans;
vector<int>v, dist;
int main() {
cin>>N;
for(int i=0; i<N; i++) {
cin>>arr[i];
if(arr[i]) {
ans += arr[i];
v.push_back(i);
}
}
if(v.empty()) {
cout<<N/2;
return 0;
}
else if(v.size() == 1) {
dist.push_back(N - v.size());
}else{
for(int i=0; i<v.size(); i++) {
if(i == v.size()-1)
dist.push_back(v[0] + N-1-v[i]);
else
dist.push_back(v[i+1]-v[i]-1);
}
}
for(auto e : dist){
ans += e/2 + e%2;
}
cout<<ans;
}