algorithm

๋ฐฑ์ค€ 14848

rkawk 2024. 8. 2. 10:50

๋ฌธ์ œ

ํ’€์ด

๊ทธ๋ฆฌ๋””ํ•˜๊ฒŒ ํ’€ ์ˆ˜ ์žˆ์„๊นŒ ์ƒ๊ฐํ•ด์„œ ์‹œ๋„ํ–ˆ์ง€๋งŒ ํ’€์ง€ ๋ชปํ–ˆ๋‹ค.

 

ํฌํ•จ ๋ฐฐ์ œ ์›๋ฆฌ๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœํ•œ ์นด์šดํŒ… ๋ฐฉ์‹์œผ๋กœ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด์•ผํ•œ๋‹ค.

 

ํฌํ•จ ๋ฐฐ์ œ์˜ ์›๋ฆฌ

ํฌํ•จ๋ฐฐ์ œ ์›๋ฆฌ๋ž€ ๊ฐ ์ง‘ํ•ฉ์˜ ํ•ฉ์ง‘ํ•ฉ์˜ ํฌ๊ธฐ๋ฅผ ๊ตฌํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋˜๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

 

์œ„ํ‚ค๋ฐฑ๊ณผ

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;
}