2023. 12. 5. 16:34ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1266
-> ์ด์ ๋ฌธ์ ํ์ด
2. ๋ฐ๋์ด ์น์ฐจ
์ค๋ช
์ฒ ์๋ ๊ทธ์ ๋ฐ๋์ด๋ค์ ๋ฐ๋ฆฌ๊ณ ์์ฅ์ ๊ฐ๋ ค๊ณ ํ๋ค. ๊ทธ๋ฐ๋ฐ ๊ทธ์ ํธ๋ญ์ Cํฌ๋ก๊ทธ๋จ ๋๊ฒ ํ์ธ์๊ฐ ์๋ค.
์ฒ ์๋ C๋ฅผ ๋์ง ์์ผ๋ฉด์ ๊ทธ์ ๋ฐ๋์ด๋ค์ ๊ฐ์ฅ ๋ฌด๊ฒ๊ฒ ํ์ฐ๊ณ ์ถ๋ค.
N๋ง๋ฆฌ์ ๋ฐ๋์ด์ ๊ฐ ๋ฐ๋์ด์ ๋ฌด๊ฒ W๊ฐ ์ฃผ์ด์ง๋ฉด,
์ฒ ์๊ฐ ํธ๋ญ์ ํ์ธ ์ ์๋ ๊ฐ์ฅ ๋ฌด๊ฑฐ์ด ๋ฌด๊ฒ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์์ฐ์ C(1<=C<=100,000,000)์ N(1<=N<=30)์ด ์ฃผ์ด์ง๋๋ค.
๋์งธ ์ค๋ถํฐ N๋ง๋ฆฌ ๋ฐ๋์ด์ ๋ฌด๊ฒ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ๊ฐ์ฅ ๋ฌด๊ฑฐ์ด ๋ฌด๊ฒ๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
259 5
81
58
42
33
61
์์ ์ถ๋ ฅ 1
242
๋ฌธ์ ํ์ด 1
public class BadukiRiding
{
static int c, n, answer = 0;
static int[] arr;
// ๋ถ๋ถ ์งํฉ ์ฝ๋์ ๊ฑฐ์ ์ ์ฌํ๊ฒ ํ๋ฉด ๋๋ค.
public void DFS(int L, int sum )
{
if (sum > c) {
return;
}
if (L == n) {
if (answer < sum) answer = sum;
}else {
DFS(L + 1, sum + arr[L]);
DFS(L + 1, sum);
}
}
public static void main(String[] args)
{
BadukiRiding badukiRiding = new BadukiRiding();
Scanner scanner = new Scanner(System.in);
c = scanner.nextInt(); // ์ต๋ ๋ฌด๊ฒ
n = scanner.nextInt();
arr = new int[n];
for (int i = 0; i< n; i++)
{
arr[i] = scanner.nextInt();
}
badukiRiding.DFS(0, 0);
System.out.println(answer);
}
}
๐ฉ๐ป : ์ด ๋ฌธ์ ๋ ์ด์ ๋ฌธ์ ์์ ํ์๋ ํฉ์ด ๊ฐ์ ๋ถ๋ถ ์งํฉ ๊ตฌํ๋ ๊ฒ๊ณผ ๋์ผํ๊ฒ ๋ฌธ์ ๋ฅผ ํ๋ฉด ๋๋ค. (ํ์ด ๋ฐฉ์์ด ๊ฑฐ~~์ ๋น์ทํจ)
static int c, n, answer = 0;
static int[] arr;
-> ๋จผ์ static ๋ณ์๋ก c, n, answer๋ฅผ ๋ชจ๋ ์ ์ธํด์ฃผ๋๋ฐ c๋ ์ต๋ ๋ฌด๊ฒ n์ ๋ฐ๋์ด ๋ง๋ฆฌ ์, answer์ ๋ฐ๋์ด๋ค์ ํ์ธ ์ ์๋ ์ต๋ ๋ฌด๊ฒ๋ฅผ ๋ด์ ๋ณ์์ด๋ค. (arr์ ๊ฐ ๋ฐ๋์ด๋ค ๋ฌด๊ฒ)
public void DFS(int L, int sum )
{
if (sum > c) {
return;
}
if (L == n) {
if (answer < sum) answer = sum;
}else {
DFS(L + 1, sum + arr[L]);
DFS(L + 1, sum);
}
}
-> DFS ๋ฉ์๋์๋ L (๋ ๋ฒจ)๊ณผ sum์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ๊ฒ์ด๋ค.
๋ง์ฝ sum์ด c๋ฅผ ์ด๊ณผํ๋ฉด ๋ ์ด์ ๋ฐ๋์ด๋ฅผ ํ์ธ ์ ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋ก ๋ฆฌํดํด์ค๋ค.
์๋๋ฉด L์ด ๋ฐ๋์ด ๋ง๋ฆฌ์๋งํผ ๋ํ๋ค๋ฉด ์ด์ ์ด sum์ด answer ๋ณด๋ค ํฌ๋ค๋ฉด answer์ sum ๊ฐ์ ๋ด์์ค๋ค. (c๋ณด๋ค ํฐ ๊ฒฝ์ฐ๋ ์์์ ๊ฑธ๋ฌ์คฌ๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋ก ๋ด์๋ ๋๋ค.)
์ด ๊ฒฝ์ฐ๋ ์๋๋ผ๋ฉด DFS๋ฅผ ํธ์ถํ ๋ sum์ ํด๋น ๋ฐ๋์ด๋ฅผ ํ์ด ํฉ๊ณผ, ํ์ฐ์ง ์์ ํฉ์ ๊ฐ๊ฐ ์ฌ๊ท ํจ์๋ฅผ ํตํด ํธ์ถํด์ฃผ๋ฉด ๋๋ค.
๋ฌธ์ ํ์ด 2
static int answer = Integer.MIN_VALUE, c, n;
public void DFS(int L, int sum, int[] arr)
{
if (sum > c) return;
if (L == n) {
answer = Math.max(sum, answer);
}else {
DFS(L+1, sum + arr[L], arr);
DFS(L+1, sum, arr);
}
}
๐พ : ๊ฐ์ฌ๋์ด ํ์ดํ ๋ฐฉ์๋ ๊ฑฐ์ ๋น์ทํ๊ธด ํ๋ค. ๋ค๋ฅธ ๋ถ๋ถ์ด๋ผ๋ฉด answer์ ๊ฐ์ ๊ตฌํ ๋ Math.max ๋ฉ์๋๋ฅผ ํตํด sum๊ณผ answer ์ค์ ํฐ ๊ฐ์ answer์ ๋ด์์ฃผ๋ ๋ถ๋ถ์ด๋ค.