2023. 12. 1. 11:34ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1265
-> ์ด์ ๋ฌธ์ ํ์ด
1. ํฉ์ด ๊ฐ์ ๋ถ๋ถ์งํฉ (DFS, ์๋ง์กด ์ธํฐ๋ทฐ)
์ค๋ช
N๊ฐ์ ์์๋ก ๊ตฌ์ฑ๋ ์์ฐ์ ์งํฉ์ด ์ฃผ์ด์ง๋ฉด,
์ด ์งํฉ์ ๋ ๊ฐ์ ๋ถ๋ถ์งํฉ์ผ๋ก ๋๋์์ ๋ ๋ ๋ถ๋ถ์งํฉ์ ์์์ ํฉ์ด ์๋ก ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ฉด “YES"๋ฅผ ์ถ๋ ฅํ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ”NO"๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
๋๋ก ๋๋๋ ๋ ๋ถ๋ถ์งํฉ์ ์๋ก์ ์งํฉ์ด๋ฉฐ, ๋ ๋ถ๋ถ์งํฉ์ ํฉํ๋ฉด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์๋์ ์งํฉ์ด ๋์ด ํฉ๋๋ค.
์๋ฅผ ๋ค์ด {1, 3, 5, 6, 7, 10}์ด ์ ๋ ฅ๋๋ฉด {1, 3, 5, 7} = {6, 10} ์ผ๋ก ๋ ๋ถ๋ถ์งํฉ์ ํฉ์ด 16์ผ๋ก ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ ๊ฒ์ ์ ์ ์๋ค.
์ ๋ ฅ ์ค๋ช
์ฒซ ๋ฒ์งธ ์ค์ ์์ฐ์ N(1<=N<=10)์ด ์ฃผ์ด์ง๋๋ค.
๋ ๋ฒ์งธ ์ค์ ์งํฉ์ ์์ N๊ฐ๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์์๋ ์ค๋ณต๋์ง ์๋๋ค.
์ถ๋ ฅ ์ค๋ช
์ฒซ ๋ฒ์งธ ์ค์ “YES" ๋๋ ”NO"๋ฅผ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ ์์ 1
6
1 3 5 6 7 10
์ถ๋ ฅ ์์ 1
YES
๋ฌธ์ ํ์ด 1
public class SubsetsWithTheSameSum2
{
static String answer = "NO";
static int n, total = 0;
boolean flag = false;
public void DFS(int L, int sum, int[] arr)
{
if (flag) return;
if (sum > total/2) return;
if (L == n) {
if ((total- sum) == sum){
flag = true;
answer = "YES";
}
}else {
DFS(L + 1, sum + arr[L], arr);
DFS(L + 1, sum, arr);
}
}
public static void main(String[] args)
{
SubsetsWithTheSameSum2 subsetsWithTheSameSum2 = new SubsetsWithTheSameSum2();
Scanner scanner = new Scanner(System.in);
n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i <n; i++)
{
arr[i] = scanner.nextInt();
total += arr[i];
}
subsetsWithTheSameSum2.DFS(0, 0, arr);
System.out.println("answer = " + answer);
}
}
๐พ :
https://hyejin.tistory.com/1258
์ด์ ์ ํ์๋ ๋ถ๋ถ์งํฉ ์ฒ๋ผ ๋ฌธ์ ๋ฅผ ํ๋ฉด ๋๋ค๊ณ ํ๋ค.
๋ฌธ์ ์์ ์ํ๋ ๊ฒ์ด ์ฃผ์ด์ง ์งํฉ์์ ๋ ๊ฐ์ ๋ถ๋ถ ์งํฉ์ผ๋ก ๋๋์์ ๋ ๋ ๋ถ๋ถ ์งํฉ์ ์์์ ํฉ์ด ์๋ก ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ฉด yes๋ฅผ ๋ฆฌํดํ๋ผ๊ณ ํ๋ค.
-> ๊ทธ๋ฆผ์์ ์ฒ๋ผ D(0,0) ์ผ๋ก ์์ํด์, ๋ค์ ๋ ๋ฒจ๋ก ๋์ด๊ฐ์ ์์ 1์ ํฌํจํ๋ค, ํฌํจํ์ง ์๋๋ค ํด์
D(1,1) -> ๋ ๋ฒจ 1๋ก ๋์ด๊ฐ์ ์์ 1์ ํฌํจํด์ ์ดํฉ์ด 0 +1 ์ด๋ผ๋ ๋ป์ด๋ค.
D(1,0) -> ๋ ๋ฒจ 1๋ก ๋์ด์๋๋ฐ ์์ 1์ ํฌํจํ์ง ์๊ณ , ์ดํฉ์ด 0 ์ด๋ผ๋ ๋ป์ด๋ค.
D(2,4) -> ๋ ๋ฒจ 2๋ก ๋์ด์์ ์์ 3์ ํฌํจํ๊ณ , ์ดํฉ์ด 0 + 1 + 3 ์ด๋ผ๋ ๋ป์ด๋ค.
D(2,1) -> ๋ ๋ฒจ 2๋ก ๋์ด์์ ์์ 3์ ํฌํจํ์ง ์๊ณ , ์ดํฉ์ด 0 + 1 ์ด๋ผ๋ ๋ป์ด๋ค.
... ์ด๋ ๊ฒ ๋ฐ๋ณตํด์ ๋ ๋ถ๋ถ ์งํฉ์ ํฉ์ด ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์๋ค๋ฉด YES ๋ฅผ ์ถ๋ ฅํ๋ฉด ๋๋ค.
static String answer = "NO";
static int n, total = 0;
boolean flag = false;
์ด ๋ฌธ์ ์์๋ ์ฐ์ n, total, answer๋ฅผ static ๋ณ์๋ก ์ ์ธํด์ค๋ค. ๊ทธ๋ฆฌ๊ณ flag์์๋ ๋ ๋ถ๋ถ ์งํฉ์ ํฉ์ด ๊ฐ์ ๊ฒฝ์ฐ true๋ก ๋ฐ๊พธ๊ณ , flag๊ฐ true์ด๋ฉด DFS๋ฅผ ์ข ๋ฃํ๋๋ก ํ๋ค.
public void DFS(int L, int sum, int[] arr)
{
if (flag) return;
if (sum > total/2) return;
if (L == n) {
if ((total- sum) == sum){
flag = true;
answer = "YES";
}
}else {
DFS(L + 1, sum + arr[L], arr);
DFS(L + 1, sum, arr);
}
}
-> L : ๋ ๋ฒจ์ ๋ปํ๊ณ , sum ์ ์์์ ์ด ํฉ, arr์ ์ฃผ์ด์ง ๋ฐฐ์ด์ด๋ค. (์ฌ๊ธฐ์ ์ ๊ฐ์๊ธฐ ๋ฐฐ์ด์ DFS์ ํฌํจ์์ผฐ๋์ง๋.. ๋ชจ๋ฅด๊ฒ ๋ค ใ )
DFS์ด๋ฏ๋ก if-else๋ก ์์ํด์ค๋ค. ๋จผ์ L์ด n์ด๋ฉด ์์๋ฅผ ๋ค ๋์๋ค๋ ๋ป์ด๋ฏ๋ก ์ฌ๊ธฐ์ ์ด์ ๊ฒ์ฆ์ ํ๋๋ฐ ์ด๋
์ดํฉ total - sum์ด sum ๊ณผ ๊ฐ๋ค๋ฉด YES ๋ก answer ๋ฅผ ๋ฐ๊ฟ์ฃผ๊ณ , flag๋ฅผ true๋ก ์ค์ ํด์ค๋ค.
L์ด n์ด ์๋๋ผ๋ฉด DFS ์ฌ๊ทํจ์ ํธ์ถ์ ํตํด DFS(L+ 1, sum + arr[L] , arr) ๊ณผ DFS(L + 1, sum, arr) ๋ฅผ ํธ์ถํด์ฃผ๋๋ฐ
์์ DFS ํธ์ถ์ ํด๋น ์์๋ฅผ ํฌํจํ์ฌ ๋ํ ๊ฐ์ ๋๊ฒจ์ฃผ๊ณ , ๋ค DFS ํธ์ถ์ ํด๋น ์์๋ฅผ ํฌํจํ์ง ์๊ณ ๋ํ ๊ฐ์ ๋๊ฒจ์ค๋ค.
if (flag) return;
if (sum > total/2) return;
DFS ํธ์ถ ํ flag๊ฐ true์ด๋ฉด ์ด๋ฏธ ๊ฐ์ ๊ตฌํ๋ค๋ ๋ป์ด๋ฏ๋ก ๋ค๋ฅธ ๊ฐ์ ๊ตฌํด๋ณผ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋ก return ํด์ฃผ๊ณ ,
๋ง์ฝ sum์ด total/2 ๊ฐ์ ๋๊ฒจ๋ฒ๋ ธ๋ค๋ฉด ๊ตฌํ๊ณ ์ ํ๋ ๊ฐ์ด ์๋๋ฏ๋ก ๊ทธ๋ฅ return ํด์ค๋ค.