๐ ๋ฌธ์
๋ฌธ์
ํ์ ํ๋ฒ๊ฑฐ๋ฅผ ์ข์ํ๋ ๋ฏผ๊ธฐ๋ ์ต๊ทผ ๋ถ์ฉ ๋์ด๋ ์ด ๋๋ฌธ์ ๊ฑฑ์ ์ด ๋ง๋ค.
๊ทธ๋ ๋ค๊ณ ํ๋ฒ๊ฑฐ๋ฅผ ํฌ๊ธฐํ ์ ์์๋ ๋ฏผ๊ธฐ๋ ํ๋ฒ๊ฑฐ์ ๋ง์ ์ต๋ํ ์ ์งํ๋ฉด์ ์ ํด์ง ์นผ๋ก๋ฆฌ๋ฅผ ๋์ง ์๋ ํ๋ฒ๊ฑฐ๋ฅผ ์ฃผ๋ฌธํ์ฌ ๋จน์ผ๋ ค๊ณ ํ๋ค.
๋ฏผ๊ธฐ๊ฐ ์ฃผ๋ก ์ด์ฉํ๋ ํ๋ฒ๊ฑฐ ๊ฐ๊ฒ์์๋ ๊ณ ๊ฐ์ด ์ํ๋ ์กฐํฉ์ผ๋ก ํ๋ฒ๊ฑฐ๋ฅผ ๋ง๋ค์ด์ ์ค๋ค.
ํ์ง๋ง ์ฌ๋ฃ๋ ๋ฏธ๋ฆฌ ๋ง๋ค์ด์ ์ค๋นํด๋๊ธฐ ๋๋ฌธ์ ์กฐํฉ์ ๋ค์ด๊ฐ๋ ์ฌ๋ฃ๋ฅผ ์๋ผ์ ์กฐํฉํด์ฃผ์ง๋ ์๊ณ , ์ฌ๋ฃ๋ฅผ ์ ํํ๋ฉด ์ค๋นํด๋์ ์ฌ๋ฃ๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ์ฌ ์กฐํฉํด์ค๋ค.
๋ฏผ๊ธฐ๋ ์ด ๊ฐ๊ฒ์์ ์์ ์ด ๋จน์๋ ํ๋ฒ๊ฑฐ์ ์ฌ๋ฃ์ ๋ํ ๋ง์ ์์ ์ ์ค๋ ๊ฒฝํ์ ํตํด ์ ์๋ฅผ ๋งค๊ฒจ๋์๋ค.
๋ฏผ๊ธฐ์ ํ๋ฒ๊ฑฐ ์ฌ๋ฃ์ ๋ํ ์ ์์ ๊ฐ๊ฒ์์ ์ ๊ณตํ๋ ์ฌ๋ฃ์ ๋ํ ์นผ๋ก๋ฆฌ๊ฐ ์ฃผ์ด์ก์ ๋,
๋ฏผ๊ธฐ๊ฐ ์ข์ํ๋ ํ๋ฒ๊ฑฐ๋ฅผ ๋จน์ผ๋ฉด์๋ ๋ค์ด์ดํธ์ ์ฑ๊ณตํ ์ ์๋๋ก ์ ํด์ง ์นผ๋ก๋ฆฌ ์ดํ์ ์กฐํฉ ์ค์์ ๋ฏผ๊ธฐ๊ฐ ๊ฐ์ฅ ์ ํธํ๋ ํ๋ฒ๊ฑฐ๋ฅผ ์กฐํฉํด์ฃผ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
(๋จ ์ฌ๋ฌ ์ฌ๋ฃ๋ฅผ ์กฐํฉํ์์ ํ๋ฒ๊ฑฐ์ ์ ํธ๋๋ ์กฐํฉ๋ ์ฌ๋ฃ๋ค์ ๋ง์ ๋ํ ์ ์์ ํฉ์ผ๋ก ๊ฒฐ์ ๋๊ณ , ๊ฐ์ ์ฌ๋ฃ๋ฅผ ์ฌ๋ฌ ๋ฒ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ํ๋ฒ๊ฑฐ์ ์กฐํฉ์ ์ ํ์ ์นผ๋ก๋ฆฌ๋ฅผ ์ ์ธํ๊ณ ๋ ์๋ค.)
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ํ
์คํธ ์ผ์ด์ค์ ์ T๊ฐ ์ฃผ์ด์ง๋ค.
๊ฐ ํ
์คํธ ์ผ์ด์ค์ ์ฒซ ๋ฒ์งธ ์ค์๋ ์ฌ๋ฃ์ ์, ์ ํ ์นผ๋ก๋ฆฌ๋ฅผ ๋ํ๋ด๋ N, L(1 ≤ N ≤ 20, 1 ≤ L ≤ 104)๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค.
๋ค์ N๊ฐ์ ์ค์๋ ์ฌ๋ฃ์ ๋ํ ๋ฏผ๊ธฐ์ ๋ง์ ๋ํ ์ ์์ ์นผ๋ก๋ฆฌ๋ฅผ ๋ํ๋ด๋ Ti, Ki(1 ≤ Ti ≤ 103, 1 ≤ Ki ≤ 103)๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
๊ฐ ์ค๋ง๋ค "#T" (T๋ ํ ์คํธ ์ผ์ด์ค ๋ฒํธ)๋ฅผ ์ถ๋ ฅํ ๋ค, ์ฃผ์ด์ง ์ ํ ์นผ๋ก๋ฆฌ ์ดํ์ ์กฐํฉ์ค์์ ๊ฐ์ฅ ๋ง์ ๋ํ ์ ์๊ฐ ๋์ ํ๋ฒ๊ฑฐ์ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ
1 5 1000 100 200 300 500 250 300 500 1000 400 400 |
//Test Case ๊ฐฏ์ //Test Case #1, N = 5, L = 1000 //Test Case #1, ์ฒซ๋ฒ์งธ ์ฌ๋ฃ ์ ๋ณด |
์ถ๋ ฅ
#1 750 | //Test Case #1์ ์ ๋ต |
โ๏ธ ํ์ด
DFS๋ก ์กฐํฉ ์ฝ๋๋ฅผ ์ง์ ํธ๋ ๋ฒ๊ณผ, DP๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ ๋ ๊ฐ์ง๊ฐ ์๋ค.
๋๋ ์กฐํฉ์ ์ฐ์ตํ๊ธฐ์๋ ์ ๋ฌธ์ ๊ฐ ์ต๊ณ ์งฑ์งฑ์ด๋ผ๊ณ ์๊ฐํ๋๋ฐ, DP ์ฐ์ต์ผ๋ก๋ ์ข์๋ฏ..?
๐ก DFS๋ก ํ๊ธฐ
์กฐํฉ์ ํ๊ณ ์ถ์ผ๋ฉด ์ด ๋ฌธ์ ๋ฅผ ํ๋ฉด ๋๋ค! ์ธํผ์์ ์กฐํฉ์ผ๋ก ๋ค์ด๊ฐ ๋ ์ด ๋ฌธ์ ๋ถํฐ ํ์๊ณ ํ๋ค (ใ ใ )
ํ๋ฒ๊ฑฐ ์ฌ๋ฃ๋ฅผ ์ด๋ป๊ฒ ์กฐํฉํ ์ง ์ ํํ๋ฉด ๋๋ค.
๋ฌธ์ ๋ฅผ ์ ๋ฆฌํ์๋ฉด ์๋์ ๊ฐ๋ค.
1. ํน์ ์ฌ๋ฃ๋ฅผ ์ ํํ ์๋ ์๊ณ , ์ ํ ์ํ ์๋ ์๋ค. => ์กฐํฉ
2. ๊ฐ์ ์ฌ๋ฃ๋ฅผ ์ฌ๋ฌ ๋ฒ ์ฌ์ฉํ ์ ์๋ค => ์ค๋ณต์กฐํฉ์ด ์๋
3. ๋ง๋ ์กฐํฉ์ด ์นผ๋ก๋ฆฌ ์ ํ์ ๋์ผ๋ฉด ์๋๋ค => DFS๋ฌธ์ ๋น ์ ธ๋์ฌ ์กฐ๊ฑด๋ฌธ
4. ์กฐํฉํ ์ฌ๋ฃ๋ค์ ์ ํธ๋ ํฉ์ด ์ ์ผ ํฐ ๊ฒ์ ์ฐพ์์ผ ํ๋ค => ์กฐํฉ์ ๋ง์น ๋๋ง๋ค ์ฒดํฌ
์ ์กฐ๊ฑด์ ๋ง๊ฒ DFS ์ฝ๋๋ฅผ ์ง์ผ ํ๋๋ฐ, ์์ธํ ์ค๋ช ์ ์ฝ๋์ ์ฃผ์์ผ๋ก ์ฒจ๋ถํ๊ฒ ๋ค.
๐ก DP๋ก ํ๊ธฐ
์ ๋ ์์ง DP๋ฅผ ํ์ง ๋ชปํด์.....์ธํผ ๋น์ ๋๊ธฐ ๋ถ์ ์ฝ๋ ์ด์ง ๋ฐ๊ฟ๋๊ฑธ ์ฒจ๋ถํ ๊ฒ์ผ๋ก ๋์ฒดํ๊ฒ ์ต๋๋ค(^^)
ํ ์ค ์๋ ๋ถ๋ค์ ์๋ ์ฝ๋ ๋ณด๋ฉด ์์ค ๊ฒ....
๐โ๏ธ ์๊ฒฌ
๐๏ธ 2021.8.11
ํ์ง ๋ชปํ๋ค...........์ธ์ ์์ง ํ์ด๋ณด๋ผ๊ณ ํ๋๋ฐ ๊ทธ๋๋ ๋ชปํ์๋ค.
๊ต์๋์ด ์ด์ ๋ฌธ์ ๋ช ๊ฐ ํ์ด๋ดค์ผ๋ ๋ค์ ํ์ด๋ณด๋ผ๊ณ ์๊ฐ์ ์ฃผ์ จ๋๋ฐ ๋ ๋ชปํ์๋ค. ์ด๊ฒ ์ด๋ป๊ฒ D3์ง? D4๋ ๋์ด์ผํ๋ ๊ฒ ์๋๊ฐ์...
๋ค๋ค ์ ํธ๋ค..ใ ใ ์ง์ง ๋๋ฌด...์์กด๊ฐ์ด ๋ฐ๋ฅ์น๋ ๊ฒ ๊ฐ๋ค. ์คํธ๋ ์ค๊ฐ ๊ทน์น๋ฅผ ์ฐ๋๋ค. ๋๋ง์น๊ณ ์ถ๋ค..
ํธ๋ ๋ฐฉ์๋ค์ด ๋ค ๋๊ฐ๋ค. DFS์ฒ๋ผ ์ฌ๊ท๋ฅผ ์ฌ์ฉํด์ ๋ถ๋ถ์งํฉ์ ๋ชจ๋ ๊ฐ๋ณธ๋ค.
์!!!! ๋ ๋ฐ๋ณด๋ค..ใ ใ ใ ใ ๋ถ๋ถ์งํฉ์ ์ ํ๋ธ ๋ผ์ด๋ธ ๊ฐ์์์ ์์ด/์กฐํฉ์ผ๋ก ํ์ด๋ดค์์!!!!!!
ํ๋ฒ๊ฑฐ ๋ฌธ์ =๋ถ๋ถ์งํฉ์ด๋ผ๊ณ ์๊ฐ์ด ๊ท๊ฒฐ๋์ง ์์๋ค.
๐๏ธ ๊ธ์ฐ๋ ํ์ฌ
2๋ ์ ์ ๋.....์ ๋ฒ ๊ท์ฌ์ ๊ตฐ(ใ ใ ) ๐ฅน
์ ๋ ๋๋ ์ฝ๋ฉํ ์คํธ๋ผ๋๊ฑด ํด๋ณธ ์ ๋ ์๋๋ฐ ์ธํผ์ ์ ์ํด์,
๐ฆ (๊ต์๋): ์ฌ๋ฌ๋ถ๋ค ๊ทธ๋ผ ์ด๋ฒ์ ์ด ๋ฌธ์ ๋ฅผ ๊ฐ์ ํ์ด๋ณผ๊น์~?
๐ฅ : ๋ค์~!!!
์ด๋ ค์ํ๋ ์ฌ๋ ์์ด ์ฐฉ์ฐฉ์ฐฉ ์งํ๋๋ ๊ฐ์์ ํผ์ ์ ์ํ์ง ๋ชปํ๋ ๊ธฐ์ต์ด ๋๋ค.
๋๋ง....์ด๋ฐ๊ฑฐ ํ ์ค ๋ชฐ๋ผ? ๋๋ง ๋ฌธ์ ํธ๋ ๋ฒ ๋ชฐ๋ผ? ๋๋ง ํจ์ ๋ชฐ๋ผ? ๋๋ง ์๊ณ ๋ฆฌ์ฆ ๋ชฐ๋ผ?
ใ ใ ใ ใ ๋ฌดํ์ ๋ฌผ์ํ ใ ใ ใ ใ ใ ใ ใ ใ ใ
ํ์ง๋ง ๋ค์ ์๊ฐํด๋ด๋ ์ด๋ ๋ค๋ฅธ ์ฌ๋๋ค ์ฝ๋๋ ๋ณด๊ณ , ๊ต์๋์ ํ์ด๋ฅผ ๋ณด์๋๊ฒ ์ง๊ธ์ ๋ด๊ฒ ํฐ ๋์์ด ๋์๋ ๊ฒ ๊ฐ๋ค.
ํผ์ ์ด๊ฑธ ์ด๋ป๊ฒ ํ๋ํ๋ ๋ค ๊ณต๋ถํด.... ์๊ฐ๋ ์ค๋ ๊ฑธ๋ ธ์ ๊ฒ์ด๊ณ , ๊ทธ๋งํผ์ ์์ง๋ ฅ๋ ์๋์ ๊ฒ์ด๋ค.
์๋ฌด๊ฒ๋ ๋ชจ๋ฅด๋ ๋ณ์๋ฆฌ ์ ์ ๊ฐ์ ๋ก ๋ฒ๋ ค ์ฝ๋๋ฅผ ๋ฃ์ด์คฌ๋ ์ธํผ....์ง๊ธ๋ ์ฌ๋ํด๐ซถ
๐ป ์์ค์ฝ๋: ์๋ฐ(Java)
DFS
public class Solution_SWEA_5215_ํ๋ฒ๊ฑฐ๋ค์ด์ดํธ_D3 {
static int[] taste, cal;
static int N, L, max;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int T = Integer.parseInt(br.readLine()); //ํ
์คํธ์ผ์ด์ค
for (int testCase = 1; testCase <= T; testCase++) {
st = new StringTokenizer(br.readLine(), " ");
N = Integer.parseInt(st.nextToken());//์ฌ๋ฃ์ ์
L = Integer.parseInt(st.nextToken());//์ ํ ์นผ๋ก๋ฆฌ
taste = new int[N]; //๋ง ์ ์
cal = new int[N]; //์นผ๋ก๋ฆฌ
for (int i = 0; i < N; i++) {
st = new StringTokenizer(br.readLine(), " ");
taste[i] = Integer.parseInt(st.nextToken());
cal[i] = Integer.parseInt(st.nextToken());
}//end of input
max = 0;
getSubSet(0, 0, 0);
sb.append("#").append(testCase).append(" ").append(max).append("\n");
}
System.out.print(sb);
}
private static void getSubSet(int cnt, int calSum, int tasteSum) { //์ฌ๋ฃ ๋ถ๋ถ์งํฉ ๊ตฌํ๊ธฐ
if (calSum > L) return; //์ต๋ ์นผ๋ก๋ฆฌ ์ด๊ณผํ๋ฉด ๋์๊ฐ๊ธฐ
if (cnt == N) {
// ๋ง์ง๋ง ์ฌ๋ฃ๊น์ง ํ์ธํ์ผ๋ฉด(์กฐํฉ์ผ๋ก ํฌํจํ๋ ์ํ๋ ) DFS์์ ๋น ์ ธ๋์จ๋ค
// ๊ทธ ์ ์ ์ง๊ธ๊น์ง ์กฐํฉ์ ์นผ๋ก๋ฆฌ ํฉ์ด ์ต๋๋ฅผ ๋์ง ์์์ผ๋ฉด, max๊ฐ์ ๊ฐฑ์ ํ๋ค.
if(calSum <= L) max = Math.max(max, tasteSum);
return;
}
//ํด๋น ์ฌ๋ฃ ์ ํํ์ ๋
getSubSet(cnt + 1, calSum + cal[cnt], tasteSum + taste[cnt]);
//ํด๋น ์ฌ๋ฃ ์ ํํ์ง ์์์ ๋
getSubSet(cnt + 1, calSum, tasteSum);
}
}
DP
public static void main(String[] args) throws Exception {
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
int tc= Integer.parseInt(br.readLine());
StringBuilder sb= new StringBuilder();
for(int t= 1; t<= tc ;t++) {
StringTokenizer st = new StringTokenizer(br.readLine()," ");
int n = Integer.parseInt(st.nextToken()); //์ฌ๋ฃ์ ์
int l = Integer.parseInt(st.nextToken()); //์ ํ ์นผ๋ก๋ฆฌ
int[] T = new int[n+1];
int[] K = new int[n+1];
for(int i=1;i<=n;i++) {
StringTokenizer st1 = new StringTokenizer(br.readLine()," ");
T[i]=Integer.parseInt(st1.nextToken());
K[i]=Integer.parseInt(st1.nextToken());
}
int[][] dp=new int[n+1][l+1];
for(int i=1;i<=n;i++) {
for(int j=0;j<=l;j++) {
if(j<K[i]) {
dp[i][j]=dp[i-1][j];
}
else {
dp[i][j]=Math.max(dp[i-1][j-K[i]]+T[i], dp[i-1][j]);
}
}
}
sb.append("#").append(t).append(" ").append(dp[n][l]).append("\n");
}
System.out.print(sb);
}
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ
'์๊ณ ๋ฆฌ์ฆ > SWEA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[SWEA] 1953๋ฒ ํ์ฃผ๋ฒ ๊ฒ๊ฑฐ - ์๋ฐ(JAVA) / ์๋ฎฌ๋ ์ด์ / BFS (0) | 2021.09.30 |
---|