๊ณจ๋“œ1 : ๋™์  ๊ณ„ํš๋ฒ• ๋ฌธ์ œ์ด๋‹ค.

์ƒ๊ฐ

dp์˜ ์ •์˜๋Š” ๊ฐ„๋‹จํ•˜๊ฒŒ ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ๋‹ค. ํŠน์ •ํ•œ ์ƒํƒœ์˜ ๋ฐœ์ „์†Œ๋กœ ์˜ค๋Š” ๋ฐฉ๋ฒ•์€ ๋ช‡๊ฐ€์ง€๋กœ ์ •ํ•ด์ง€๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ๊ทธ๋ž˜์„œ ์ •์˜๋ฅผ ์žก์œผ๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

์ •์˜

dp[์ƒํƒœ] = ๋ฐœ์ „์†Œ์˜ ์ƒํƒœ์—์„œ์˜ ๋ฐœ์ „์†Œ๋ฅผ ๊ณ ์น˜๋Š”๋ฐ ๋ฐœ์ƒํ•˜๋Š” ๋น„์šฉ์˜ ์ตœ์†Ÿ๊ฐ’

๊ทธ๋ ‡๋‹ค๋ฉด ์ƒํƒœ๋Š” ์–ด๋–ป๊ฒŒ ์ •์˜ํ•  ์ˆ˜ ์žˆ์„๊นŒ?

๋น„ํŠธ๋งˆ์Šคํฌ

YNN์€ 100์œผ๋กœ ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋ ‡๋‹ค๋ฉด ์ด ์ƒํƒœ์—์„œ ๋‹ค์Œ์ƒํƒœ๋กœ๋Š” ์–ด๋–ป๊ฒŒ ๊ฐˆ ์ˆ˜ ์žˆ์„๊นŒ?

  1. ์ผœ์ ธ์žˆ๋Š” ๋ฐœ์ „์†Œ๋ฅผ ํ™•์ธํ•œ๋‹ค.
  2. ํ•ด๋‹น ๋ฐœ์ „์†Œ์—์„œ ๊บผ์ ธ์žˆ๋Š” ๋ฐœ์ „์†Œ๋ฅผ ํ™•์ธํ•œ๋‹ค.
  3. ๊บผ์ ธ์žˆ๋Š” ๋ฐœ์ „์†Œ๋ฅผ ํ‚จ๋‹ค.
  4. ๋‹ค๋ฅธ ์ƒํƒœ์—์„œ ๋˜ ๊ฐ™์€ ์ƒํƒœ๋กœ ์˜ฌ ๋•Œ, ์ตœ์†Œ๊ฐ’์œผ๋กœ ์—…๋ฐ์ดํŠธ ํ•œ๋‹ค.

์ฃผ์˜ํ•  ์ 

์ดˆ๊ธฐ๊ฐ’์„ ๋ชจ๋‘ -1๋กœ ๋งŒ๋“  ์ƒํƒœ์—์„œ ๊ฐ’์„ ์ถœ๋ ฅํ•˜๋Š” ๊ฒƒ์ด ์ข‹๋‹ค. ๋งŒ๋“ค์ง€ ๋ชปํ•˜๋Š” ๊ฒฝ์šฐ๋ฅผ ์ถœ๋ ฅํ•˜๊ธฐ ์œ„ํ•จ์ด๋‹ค. ๋˜ํ•œ 0๊ฐœ์˜ ๋ฐœ์ „์†Œ๋ฅผ ํ‚ค๋ผ๋Š” ์กฐ๊ฑด์—์„œ -1์„ ๋ฆฌํ„ดํ•˜๋ฉด ์•ˆ๋˜๊ณ  0์„ ๋ฆฌํ„ดํ•ด์•ผ ํ•œ๋‹ค.

Code

#include<iostream>
#include<vector>
#include<string>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int N;
int a[17][17];
string str;
int dp[1<<16];
int p;
 
int main(){
    cin >> N;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cin >> a[i][j];
        }
    }
    int start = 0;
    for (int i = 0; i < N; i++) {
        char temp;
        cin >> temp;
        if (temp == 'Y') start += (1<<i); // YNN -> 001๋กœ ์ €์žฅํ•œ๋‹ค. ์ด์ง„์ˆ˜์˜ shift์—ฐ์‚ฐ ์ค‘์—๋Š” ์ด๊ฒŒ ํŽธํ•˜๋‹ค.
    }
    cin >> p;
 
    // ๊ธฐ๋ณธ dp์˜ ๊ฐ’์„ -1๋กœ ํ•ด๋‘”๋‹ค.
    // ์ผ๋‹จ ๋‹ค ๋ชป ๋งŒ๋“ ๋‹ค๊ณ  ๊ฐ€์ •ํ•˜๋Š” ๊ฒƒ
    memset(dp, -1, sizeof(dp));
    dp[start] = 0;    //  start์—์„œ dp๊ฐ’์€ 0์ด๋‹ค. ์ตœ์†Œ๊ฐ’์ด 0
    for (int i = 0; i < (1<<N); i++) {
        if (dp[i] == -1) continue; // ์ƒํƒœ์— ๋Œ€ํ•œ ์ตœ์†Œ๊ฐ’์ด ์—†๋‹ค๋ฉด ์ง„ํ–‰ํ•  ์ˆ˜ ์—†๋‹ค.
        for (int j = 0; j < N; j++) {   // ๋ฐœ์ „์†Œ๋ฅผ ์ˆœ์ฐจ์ ์œผ๋กœ ์ฒดํฌํ•˜๋ฉฐ ๋‹ค์Œ ์ƒํƒœ๋ฅผ ๋งŒ๋“ ๋‹ค.
            if (i&(1<<j)){    // ํ˜„์žฌ ๋ฐœ์ „์†Œ์˜ ์ƒํƒœ์ค‘ j๋ฒˆ์งธ ๋ฐœ์ „์†Œ๊ฐ€ ์žˆ๋‹ค๋ฉด
                for (int k = 0; k < N; k++) {
                    if ((i&(1<<k)) == 0){   // ํ˜„์žฌ ๋ฐœ์ „์†Œ์˜ ์ƒํƒœ์—์„œ j๋ฒˆ์งธ ๋ฐœ์ „์†Œ๋ฅผ ๊ฐ€์ง€๊ณ  k์œ„์น˜์˜ ๋ฐœ์ „์†Œ๋ฅผ ํ‚ค๋ ค๊ณ  ํ• ๋•Œ k์œ„์น˜ ๋ฐœ์ „์†Œ๊ฐ€ ๊บผ์ ธ์žˆ๋‹ค๋ฉด
                        if (dp[i|(1<<k)] == -1 || dp[i|(1<<k)] > dp[i] + a[j][k]) {
                            dp[i|(1<<k)] = dp[i]+a[j][k];
                        }
                    }
                }
            }
        }
    }
 
    int ans = -1;
    for (int i = 0; i < (1<<N); i++) {
        if (dp[i] == -1) continue;
        int count = 0;
        for (int j = 0; j < N; j++) {
            if (i&(1<<j)) count++;
        }
        if (count >= p) {
            if (ans == -1 || ans > dp[i]) ans = dp[i]; // ans๋ฅผ -1๋กœ ํ–ˆ๊ธฐ ๋•Œ๋ฌธ์— ์ฒ˜์Œ์— scope๋“ค์–ด์˜ค๊ธฐ ์œ„ํ•ด ์กฐ๊ฑด ์ถ”๊ฐ€
        }
    }
    cout << ans << '\n';
}

Reference