๋ฐฑ์ค 14848
๋ฌธ์
ํ์ด
๊ทธ๋ฆฌ๋ํ๊ฒ ํ ์ ์์๊น ์๊ฐํด์ ์๋ํ์ง๋ง ํ์ง ๋ชปํ๋ค.
ํฌํจ ๋ฐฐ์ ์๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋กํ ์นด์ดํ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผํ๋ค.
ํฌํจ ๋ฐฐ์ ์ ์๋ฆฌ
ํฌํจ๋ฐฐ์ ์๋ฆฌ๋ ๊ฐ ์งํฉ์ ํฉ์งํฉ์ ํฌ๊ธฐ๋ฅผ ๊ตฌํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ์ด๋ค.
Ai๊ฐ ํ๋์ ์งํฉ์ผ๋, A1 ~An์ ํฉ์งํฉ์ ๊ตฌํ๊ธฐ ์ํด์๋ ๊ฒน์น๋ ๋ถ๋ถ(๊ต์งํฉ)์ ๋นผ์ค์ผํ๋ค.
ํ์ง๋ง ๊ต์งํฉ์ ๋นผ์ฃผ๋ ๊ณผ์ ์์ ์ค๋ณต๋ ๋ถ๋ถ์ด ์๊ธฐ๊ณ , ์ด ์ค๋ณต๋ ๋ถ๋ถ์ ๋ค์ ์ฒดํฌํด์ค์ผ ๋๋ค.
ํฌํจ ๋ฐฐ์ ์ ์๋ฆฌ๋ ์งํฉ์ ๊ฐ์๊ฐ ํ์์ผ๋ ์ ์ฒด ๊ฐ์์ ๋ํด์ฃผ๊ณ , ์ง์์ผ๋ ๋นผ์ ์ ์ฒด ํฉ์งํฉ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
๊ฒฐ๊ตญ [1, 2, 3, 4, 5]๋ผ๋ ์ ๋ ฅ์ด ๋ค์ด์์๋ [1], [1,2], [1,3] ~~~ [1,2,3,4,5]์ ๊ฐ์ ๋ชจ๋ ์งํฉ์ ์กฐํฉ์ ๊ฒฝ์ฐ์ ์๋ฅผ ์๊ฐํ๊ณ , ์์์ ์์ ๋ฐ๋ผ ์ ์ฒด ๊ฐ์๋ฅผ ์นด์ดํ ํด์ผ ํ๋ค.
๊ทธ๋ ๋ค๋ฉด ์ ์ฒด ๊ฐ์๋ฅผ ์ด๋ป๊ฒ ์นด์ดํ ํ๋ฉด ์ข์๊น
๋นํธ๋ง์คํน์ ์ด์ฉํ ์ ์ฒด ์กฐํฉ์ ๊ฒฝ์ฐ ํ์
๋ ํ๋๊ฒ ์ฒ๋ผ ๋ฐฑํธ๋ํน์ ์ด์ฉํด์ ์กฐํฉ์ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ค ํ๋๋ฐ ์ด๋ ๊ฒ ๋๋ค๋ฉด ๊ฐ๊ฐ์ leaf case์์ K๋งํผ ๋ฐฐ์ด์ ํ์ํด ์ด๋ค ์กฐํฉ์ธ์ง๋ฅผ ํ์ธํด์ผํ๋ฏ๋ก ์ฝ์คํธ๊ฐ ๋ง์ด ๋ค๊ฒ ๋๋ค.
ํ์ด๋ฅผ ๋ณด๋ ๋นํธ๋ง์คํน์ ํตํด ์ ์ฐํ๊ฒ ์กฐํฉ์ ๊ฐ์๋ฅผ ๊ตฌํ ์ ์๋ค๋ ๊ฒ์ ์๊ฒ๋์๋ค.
for(int i = 1; i<(1<<K); i++) {
for(int j=0; j<K; j++) {
if(i & (1<<j)) {
// ์กฐํฉ์ j๋ฒ์งธ ์๊ฐ ๋ค์ด๊ฐ๋์ง.
}
}
}
์ฒซ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์ 1๋ฅผ K๋งํผ left shiftํ ๊ฐ ๊น์ง ์ํํ๋ ๋ฐ๋ณต๋ฌธ์ด๋ค.
์ด๋ K๋งํผ์ ๋นํธ์์ ๋ฐ๋ฅธ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ํ๋ ๊ฒฝ์ฐ, ๊ฐ๊ฐ์ ๋นํธ์ ๋ค์ด๊ฐ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ 2๋ค. (0, 1) ๊ทธ๋ฌ๋ฏ๋ก 2^K๊ฐ์ง์ ๊ฒฝ์ฐ์ ์๊ฐ ์๊ธฐ๊ฒ ๋๋ค.
๋นํธ์ ๋ค์ด๊ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค์ ํํํ๋ฉด ๊ฐ๊ฐ์ ์์๋ค์ ์กฐํฉ์ผ๋ก ํํํ ์ ์๋ค. ๊ทธ๋ฌ๋ฏ๋ก ๋ชจ๋ ์กฐํฉ์ ๊ฒฝ์ฐ๋ฅผ ํ์ํ๊ธฐ ์ํด ์ด๋ ๊ฒ ํํํ์๋ค.
๋๋ฒ์งธ ๋ฐ๋ชฉ๋ฌธ์ 0๋ถํฐ K๋ฒ 1๋ฅผ leftshift ํ์ฌ ํน์ ๋นํธํ๋์ 1์ด ์๋์ง ํ์ธํ๋ ๊ฒฝ์ฐ์ด๋ค.
๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ ๊ฒฐ๊ตญ bitmap size K๋ก ๋์ด์๋ค. ๊ทธ๋ฌ๋ฏ๋ก K๋งํผ ์ผ์ชฝ์ผ๋ก shiftํ์ฌ ํด๋นํ๋์ง ์ํ๋์ง ํ์ธํ๋ค.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define ull unsigned long long
ull N, K, chk[101], prime[101], ans, arr[16];
ull gcd(ull a, ull b) {
if(b == 0) return a;
else return gcd(b, a%b);
}
ull lcm(ull a, ull b) {
return a*b/gcd(a, b);
}
int main() {
cin>>N>>K;
for(int i=0; i<K; i++) cin>>arr[i];
sort(arr, arr+K);
for(int i = 1; i<(1<<K); i++) {
int cnt = 0;
ull lcmnum = 1;
for(int j=0; j<K; j++) {
if(i & (1<<j)) {
cnt += 1;
lcmnum = lcm(lcmnum, arr[j]);
}
}
if(cnt%2) ans += N/lcmnum;
else ans -= N/lcmnum;
}
cout<<N-ans;
}