๐Ÿ‘ฉโ€๐Ÿ’ป 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 ์ด์šฉํ•˜๊ธฐ

  1. ๋ฐฐ์—ด์˜ ์ฒ˜์Œ๋ถ€ํ„ฐ ๋‹ค์Œ ๊ฐ’๊ณผ ์ˆœ์„œ๋ฅผ ๋ฐ”๊พธ๋ฉด์„œ ์ƒˆ๋กœ์šด ์กฐํ•ฉ์„ ๋งŒ๋“ ๋‹ค.
  2. ๊ธฐ์ค€ ์ธ๋ฑ์Šค๋ฅผ ์„ค์ •ํ•˜๊ณ  ๊ธฐ์ค€ ๋ณด๋‹ค ์ž‘์€ ๊ฐ’๋“ค์€ ๊ณ ์ •ํ•˜๊ณ  ํฐ ๊ฐ’๋“ค์€ ์ˆœ์„œ๋ฅผ ๋ณ€๊ฒฝํ•œ๋‹ค.

์ข‹์€ ์›นํŽ˜์ด์ง€ ์ฆ๊ฒจ์ฐพ๊ธฐ