๐ฉโ๐ป BOJ_1026_๋ณด๋ฌผ
๐ฌ ์ฒ์์ ์กฐํฉ์ ํตํด ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ ๋ค ์ต์๊ฐ์ ๊ณ์ฐํ๋ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ผ๋, ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ์ต๋๋ค.
์ต์๊ฐ๋ง ๊ตฌํ๋ ๋ฌธ์ ์ด๋ ๋ ๋ฐฐ์ด์ ์ค๋ฆ/๋ด๋ฆผ์ฐจ์ ์ผ๋ก ์ ๋ ฌํ์ฌ ์์ ์ ์ฉ์ํค๋ ๋ฐฉ์์ผ๋ก ๋ณ๊ฒฝํ์ฌ ํด๊ฒฐํ์ต๋๋ค.
๋น๋ก ํ๋ ธ์ง๋ง ์์ด์ ๋ํด ๊ณต๋ถํ๋ ์๊ฐ ์ ๊ฐ์ง ์ ์์ด ์๋ฏธ์์์ต๋๋ค.
๐ ๋ฌธ์
์๋ ์์ ์ ์ํ์ด ํญ์ ํฐ ๊ณจ์นซ๊ฑฐ๋ฆฌ์๋ ๋๋ผ๊ฐ ์์๋ค. ์ด ๋๋ผ์ ๊ตญ์ ๊น์ง๋ฏผ์ ๋ค์๊ณผ ๊ฐ์ ๋ฌธ์ ๋ฅผ ๋ด๊ณ ํฐ ์๊ธ์ ๊ฑธ์๋ค.
๊ธธ์ด๊ฐ N์ธ ์ ์ ๋ฐฐ์ด A์ B๊ฐ ์๋ค. ๋ค์๊ณผ ๊ฐ์ด ํจ์ S๋ฅผ ์ ์ํ์.
S = A[0] ร B[0] + ... + A[N-1] ร B[N-1]
๐ก ํ์ด ๋ฐฉ๋ฒ
- A, B ๋ฐฐ์ด์ ์ ์ฅํฉ๋๋ค.
- A, B ๋ฐฐ์ด์ ์ ๋ ฌํฉ๋๋ค.
- ์ ์ผ ์์ ์ * ์ ์ผ ํฐ ์ + ... + (์ ์ผ ์์ ์ + 1) * (์ ์ผ ํฐ ์ -1) ๋ก ๊ณ์ฐํฉ๋๋ค.
- ๊ณ์ฐ๋ ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
๐ฅ ์ฝ๋
import java.util.Arrays;
import java.util.Scanner;
public class ์ ๋ฌผ {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
// ์ ์ฅ์ ์ ์ธ
int a[] = new int[N];
int b[] = new int[N];
// ๋ฐฐ์ด์ ์ ์ฅ
for(int n = 0; n < N; n++) {
a[n] = sc.nextInt();
}
for(int n = 0; n < N; n++) {
b[n] = sc.nextInt();
}
// a ์ ๋ ฌ
Arrays.sort(a);
// b ์ ๋ ฌ
Arrays.sort(b);
// ์ ์ผ ์์ ๊ฐ ๊ณ์ฐ
int result = 0;
for(int i = 0; i < N; i++) {
result += a[i] * b[N-i-1];
}
// ์ ๋ต ํ์
System.out.println(result);
}
}
// ์์ด๋ก ํ ๊ฒฝ์ฐ, ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค.
/*
public class ์ ๋ฌผ {
static int min = Integer.MAX_VALUE;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
// ์ ์ฅ์ ์ ์ธ
int a[] = new int[N];
int b[] = new int[N];
// ๋ฐฐ์ด์ ์ ์ฅ
for(int n = 0; n < N; n++) {
a[n] = sc.nextInt();
}
for(int n = 0; n < N; n++) {
b[n] = sc.nextInt();
}
// a ์์ ๋ฐ๊ฟ ์ ์๋ ๊ฒฝ์ฐ ์ ์ฅ (์์๊ฐ ์๊ด ์์ผ๋ ์กฐํฉ)
per(a, b, 0, N, N);
// ์ ์ผ ์์ ๊ฐ ์ถ์ถ (์ถ์ถ)
System.out.println(min);
}
static void per(int[] a, int[] b, int depth, int n, int r) {
if(depth == r) {
// ๊ฒฝ์ฐ์ ์์ ๋ง๊ฒ ๊ณ์ฐ
int result = 0;
for(int i = 0; i < n; i++) {
result += a[i] * b[i];
}
// ๊ฐ ์ ์ฅ
if(result < min) {
min = result;
}
return;
}
for(int i = depth; i < n; i++) {
swap(a, depth, i);
per(a, b, depth + 1, n, r);
swap(a, depth, i);
}
}
// ์์๋ฅผ ๋ฐ๊ฟ์ฃผ๋ ํจ์
static void swap(int[] a, int depth, int i) {
int tmp = a[depth];
a[depth] = a[i];
a[i] = tmp;
}
}
*/
โญ๏ธ ์ค๋์ ํ์ต
์์ด in Java : swap ์ด์ฉํ๊ธฐ
- ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ๋ค์ ๊ฐ๊ณผ ์์๋ฅผ ๋ฐ๊พธ๋ฉด์ ์๋ก์ด ์กฐํฉ์ ๋ง๋ ๋ค.
- ๊ธฐ์ค ์ธ๋ฑ์ค๋ฅผ ์ค์ ํ๊ณ ๊ธฐ์ค ๋ณด๋ค ์์ ๊ฐ๋ค์ ๊ณ ์ ํ๊ณ ํฐ ๊ฐ๋ค์ ์์๋ฅผ ๋ณ๊ฒฝํ๋ค.
Author And Source
์ด ๋ฌธ์ ์ ๊ดํ์ฌ(๐ฉโ๐ป BOJ_1026_๋ณด๋ฌผ), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://velog.io/@hyemz/BOJ1026์ ์ ๊ท์: ์์์ ์ ๋ณด๊ฐ ์์์ URL์ ํฌํจ๋์ด ์์ผ๋ฉฐ ์ ์๊ถ์ ์์์ ์์ ์ ๋๋ค.
์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ ์ธ ๋ฐ๊ฒฌ์ ์ ๋ (Collection and Share based on the CC Protocol.)
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค