8์ 11์ผ์ ์ํํฐ์ด ์ญ๋ ์ง๋จ ์ํ์ ์์ํ๋ค. ์ด๋ฒ์ด ๋ ๋ฒ์งธ ์์์๋๋ฐ, ์ง๋ 6์ฐจ ์ํ๋ณด๋ค ๋์ด๋๊ฐ ์ฌ์์ง ๊ฒ ๊ฐ์๋ค. 1์๊ฐ ์ ๋ ์ฌ์ ์๊ฐ์ด ์๊ฒจ ์ ์ถ ์ ์ ์๊ฐ๋ณต์ก๋๋ฅผ ์๊ฐํด ๋ณด๊ฑฐ๋ ์ฃ์ง ์ผ์ด์ค ๋ฃ์ด๋ณด๋ฉฐ ์ฒดํฌํ๊ณ ์ ์ถํ ์ ์์๋ค.
์ผ๋จ Softeer ์ ๊ธฐ ์ญ๋ ์ง๋จ HSAT(Hyundai SW Aptitude Test)๋ ํ๋์ฐจ๊ทธ๋ฃน์ SW ํ๋ซํผ์ธ Softeer์์ ์ฃผ์ตํ๋ ์ํ์ผ๋ก, ์ด ์ํ์์ ์ธ์ฆ์๋ฅผ ์ทจ๋ํ๋ฉด "ํ๋์๋์ฐจ, ๊ธฐ์, ํ๋๋ชจ๋น์ค, ํ๋์คํ ์๋ฒ, ํ๋์ฐจ์ฆ๊ถ, ํ๋์์ง๋น" ๊ธฐ์ ์ SW ๋ถ์ผ ์ง์ ์ ์ฝ๋ฉํ ์คํธ ๋ฉด์ ํํ์ ๋ฐ์ ์ ์๋ค.
๐ก ์ง์์ ์ ์์ฌํญ
- ํ๋์๋์ฐจ : ์ฐ๋์ฌํญ์ด ๋ช ์๋ ๊ณต๊ณ ์ ์๊ฒฉ์ฆ์ ์ ๋ ฅํ ๊ฒฝ์ฐ์ ํํ์ฌ ๋ฉด์ ๊ฐ๋ฅ
- ํ๋๋ชจ๋น์ค : ์ง์์ ์ด๋ ฅ์ ์์ฑ ์ Softeer ์ธ์ฆ์ ์ทจ๋๋ฒํธ ๊ธฐ์ ํ์
HSAT 1์ฐจ ์ํ์ ์ง์์๊ฐ 300๋ช ๋ ์ ๋๋๋ฐ ์ด๋ฒ 7์ฐจ ์ํ์ 1900๋ช ์ด ๋๋ ์ฌ๋๋ค์ด ์ง์ํ ๊ฑธ ๋ณด๋ฉด ํ๋์ฐจ๊ทธ๋ฃน์ ์ฝ๋ฉํ ์คํธ ๋ฉด์ ํํ์ด ๊ฝค๋ ๋งค๋ ฅ์ ์ธ ๊ฒ ๊ฐ๋ค.
Softeer HSAT ์ ๋ณด
๐น์ฐธ๊ฐ ์๊ฒฉ: Softeer ํ์ ๋๊ตฌ๋ (Talent pool์ ๊ธฐ์ด์ ๋ณด, ํ๋ ฅ ์ ๋ณด๋ฅผ ์
๋ ฅํด์ผ ํจ)
๐น์ผ์ : 1๋
์ 2-3๋ฒ ์ ๋ ์ด๋ฆฌ๋ ๊ฒ ๊ฐ๊ณ , ์ํ์ผ ๊ธฐ์ค 2-3์ฃผ ์ ๋ถํฐ ์จ๋ผ์ธ ํตํด ์ ์๋ฐ์
๐น๊ฒฐ๊ณผ๋ฐํ: ์ํ์ผ ์ฝ 2์ฃผ ํ
๐น์ธ์ด: C, C++, Java, Python, Javascript ์ค ์์ ๋กญ๊ฒ ์ ํ
(ํ
์คํธ ์ง์์ธ์ด : C11, C++17, Java 11, Python 3.6, Node.js 12.18.3 → 7์ฐจ ๊ธฐ์ค)
๐น์ถ์ ๋ฌธํญ: 2๋ฌธํญ
๐น์๊ฒฉ ๋ถ์ฌ: 2๋ฌธํญ ๋ชจ๋ ๋ง์ถ ์ธ์์๊ฒ Lv.3 ์ธ์ฆ์ ๋ฐ๊ธ
๐น์ธ์ฆ์ ์ ํจ ๊ธฐ๊ฐ: ๋ฐ๊ธ์ผ๋ก๋ถํฐ 2๋
๐น์ํ ํ๊ฒฝ: ๋ชจ๋ฐ์ผ ์นด๋ฉ๋ผ & ์น ์บ & ํ๋ฉด๊ณต์
๐๏ธ 1์ฐจ ~ 7์ฐจ ์ํ ์ผ์
1์ฐจ: 2021๋ 6์ 26์ผ (ํ )
2์ฐจ: 2021๋ 8์ 28์ผ (ํ )
3์ฐจ: 2021๋ 12์ 21์ผ (ํ)
4์ฐจ: 2022๋ 9์ 6์ผ (ํ)
5์ฐจ: 2022๋ 12์ 6์ผ (ํ)
6์ฐจ: 2023๋ 3์ 7์ผ (ํ)
7์ฐจ: 2023๋ 8์ 11์ผ (๊ธ)
์ํํฐ์ด๋ ์ฐธ ์น์ ํ๊ฒ ๊ธฐ์ถ๋ฌธ์ ๊ฐ ์ํ ๊ฒฐ๊ณผ๋ ์ ํํ์ด์ง์ ๊ณต๊ฐ๋๊ณ ํด์ค ์์๊น์ง ์ ๋ก๋ํด์ค๋ค. ํํ์ด์ง์ ๋ฌธ์ ์ค๋ช ์ด ๋๋ฌด ์ ๋์ ์๊ธฐ ๋๋ฌธ์ ์ฌ๊ธฐ์ ๋ด ํ์ด์ ์ฝ๋๋ง ๊ธฐ๋กํ๊ฒ ๋ค.
#1. ์๋์ฐจ ํ ์คํธ
n
๋์ ์๋์ฐจ ์ฐ๋น ๊ฐ์ด ์ฃผ์ด์ก์ ๋ q
๊ฐ์ ์ฟผ๋ฆฌ์ ๋ํด ํน์ ์ฟผ๋ฆฌ(์ฐ๋น ๊ฐ) m
์ ๊ฐ์ด๋ฐ ๊ฐ(์ค์ ๊ฐ)์ผ๋ก ํ๋ 3๊ฐ์ ์ฐ๋น ์กฐํฉ์ด ๋ช ๊ฐ ์กด์ฌํ๋์ง ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค. ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด 7, 4, 3, 2, 6, 1
์ ์ฐ๋น ๊ฐ์ด ์ฃผ์ด์ก์ ๋ 2
๊ฐ ์ค์ ๊ฐ ๋ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ 4๊ฐ์ง์ด๋ค.
์ฐ์ , ํน์ ๊ฐ์ด ์ค์ ๊ฐ์ด ๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ๋จํ๋ ค๋ฉด ์ฐ๋น๋ฅผ ์ ๋ ฌํด์ผ ํ๋ค. ๋๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ ๊ฐ์ฅ ๋จผ์ ์ฟผ๋ฆฌ์ m๊ฐ์ด ์ฐ๋น ๋ฐฐ์ด์ ์๋์ง ์๋์ง ํ๋จํ๋ค. ์ ์ด์ ์ฟผ๋ฆฌ ๊ฐ m์ด ์ฐ๋น ๋ฐฐ์ด์ ์๋ค๋ฉด ์ค์๊ฐ์ด ๋ ๊ฐ๋ฅ์ฑ์กฐ์ฐจ ์๊ธฐ ๋๋ฌธ์ ๊ฒฝ์ฐ์ ์๊ฐ 0์ด๋ค.
์ฐ๋น ๋ฐฐ์ด์์ m
๊ฐ์ ์ฐพ์๋ค๋ฉด, ํด๋น ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์์ ๊ฐ์ ๊ฐ์ * ํฐ ๊ฐ์ ๊ฐ์
๊ฐ ๊ฒฝ์ฐ์ ์๊ฐ ๋๋ค. ์ด๋ฅผ ๋ฐฐ์ด์ ์ธ๋ฑ์ค์ ์ฐ๊ด์ง์ด ์๊ฐํด ๋ณด๋ฉด ์ฐพ์ ๊ฐ m
์ ์ธ๋ฑ์ค๊ฐ ์์ ๊ฐ์ ๊ฐ์
๊ฐ ๋๊ณ (์ธ๋ฑ์ค๊ฐ 0๋ถํฐ ์์ํด์), ์ฐ๋น ๊ฐ์์์ m์ ์ธ๋ฑ์ค๋ฅผ ๋บ ๊ฐ์ด ํฐ ๊ฐ์ ๊ฐ์
๊ฐ ๋๋ค.
ํ์ง๋ง, ๋ฌธ์ ์ ์กฐ๊ฑด์ ์ ์ดํด๋ณด๋ฉด ์ต๋ 5๋ง ๊ฐ์ ์ฐ๋น๊ฐ ์ ๋ ฅ์ผ๋ก ๋ค์ด์ฌ ์ ์์ผ๋ฉฐ, ์ต๋ 20๋ง ๊ฐ์ ์ฟผ๋ฆฌ๋ฅผ ์ฒ๋ฆฌํด์ผ ํ๋ค. ๋ฐ๋ผ์ ์ ํ ํ์์ผ๋ก ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๊ฒฝ์ฐ 50,000 * 200,000 = 10,000,000,000 (100์ต) ๋ฒ์ ์ฐ์ฐ์ผ๋ก ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ ์ ์๋ค.
๋๋ ์ด์ ๊ฐ์ ์ด์ ๋ก ์ ํ ํ์์ด ์๋ ์ด๋ถ ํ์์ผ๋ก ์ค์๊ฐ์ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ค. ์ด๋ถ ํ์์ ํ์์ O(logN)
์ ์ฐ์ฐ์ด ํ์ํ๋ฏ๋ก, ์ต๋ ์ฝ 15.6์ ์๊ฐ๋ฐ์ ๊ฑธ๋ฆฌ์ง ์๋๋ค. ์ ํ ํ์์ O(N)
์ผ๋ก 50,000์ ์๊ฐ์ด ๊ฑธ๋ ธ๋ ๊ฒ๊ณผ ๋น๊ตํ๋ฉด ๊ต์ฅํ ์๊ฐ์ ๋จ์ถ์ํฌ ์ ์๋ค. ๊ฒฐ๋ก ์ ์ผ๋ก ์ด๋ถ ํ์์ ์ฌ์ฉํ๋ฉด 20๋ง ๊ฐ์ ์ฟผ๋ฆฌ๋ฅผ ์ฒ๋ฆฌํด๋ ์ฝ 300๋ง ๋ฒ์ ์ฐ์ฐ์ผ๋ก ํด๊ฒฐํ ์ ์๋ค.
์ด๋ถ ํ์์ ์ง์ ๊ตฌํํด ์ฌ์ฉํด๋ ๋์ง๋ง, ์ฝ๋ฉํ
์คํธ์ ๊ฐ์ด ์๊ฐ ์ ํ์ด ์๋ ๊ฒฝ์ฐ Java์ Arrays ํด๋์ค์์ ์ ๊ณตํ๋binarySearch()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ํธ์ด๋ค. ํ์ํ๋ ค๋ ๊ฐ์ด ๋ฐฐ์ด์ ์๋ ๊ฒฝ์ฐ ํด๋น ์ธ๋ฑ์ค๋ฅผ ๋ฐํํด ์ฃผ๋ฉฐ, ๋ฐฐ์ด์ ์์ ์ (-(insertion point) - 1) ๊ฐ์ ๋ฐํํ๋ค. ์ฌ๊ธฐ์ insertion point๋ ํ์ํ๋ ค๋ ๊ฐ๋ณด๋ค ํฐ ์ต์ด์ ์์น๋ก ์ฐพ๋ ๊ฐ์ ๋ฐฐ์ด์ ๋ผ์ ๋ฃ๋๋ค๊ณ ์๊ฐํ์ ๋ ๋ฐ๋ก ๋ค์ ์์นํ๋ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋งํ๋ค. ํ์ง๋ง ์ด ๋ฌธ์ ์์๋ ๊ฐ์ด ์กด์ฌํ๋ ์๋๋๊ฐ ์ค์ํ๊ธฐ ๋๋ฌธ์ ์์๊ฐ ๋ฐํ๋๋ฉด ์๋ ๊ฒ์ผ๋ก ์๊ฐํ๋ฉด ๋๋ค.
๐java API ์ฐธ๊ณ
import java.util.*;
import java.io.*;
public class Main
{
public static void main(String args[]) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
String[] NQ = br.readLine().split(" ");
int N = Integer.parseInt(NQ[0]);
int Q = Integer.parseInt(NQ[1]);
// ์ฐ๋น
int[] arr = new int[N];
// ์ฐ๋น ์
๋ ฅ ๋ฐ ์ ๋ ฌ (์ค๋ฆ์ฐจ์)
String[] line = br.readLine().split(" ");
for(int i = 0 ; i < N ; i++){
arr[i] = Integer.parseInt(line[i]);
}
Arrays.sort(arr);
// ์ด๋ถ ํ์์ผ๋ก ์ค์๊ฐ ์กด์ฌ ์ฌ๋ถ ํ์
for(int i = 0 ; i < Q ; i++){
// ์ค์๊ฐ
int m = Integer.parseInt(br.readLine());
int idx = Arrays.binarySearch(arr, m);
if(idx >= 0){ // ์ค์๊ฐ ์กด์ฌ
sb.append(idx * ((N-1) - idx)).append("\n");
}else{ // ์ค์๊ฐ ์กด์ฌ X
sb.append(0).append("\n");
}
}
System.out.println(sb);
}
}
#2. ์์๋๋ก ๋ฐฉ๋ฌธํ๊ธฐ
๋ ๋ฒ์งธ ๋ฌธ์ ๋ ๋ฐฑํธ๋ํน์ ํ์ฉํด ๊ฐ์ง ์๋ฅผ ์ํ๋ ๋ฌธ์ ์๋ค. ์ฌ๊ธฐ์ ๊ฑฐ์ณ์ผ ํ๋ ์ง์ ์ด ์์๋๋ก ์ฃผ์ด์ง๊ธฐ ๋๋ฌธ์ ์ฌ๊ท๋ฅผ ํตํด ๋ฐฑํธ๋ํน์ ํ ๋ ์ง๋๋ ์์๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ๋ฐ๋ผ์ ๋ฌธ์ ์์ ์๋ ๊ทธ๋ฆผ์ ์ผ์ชฝ์ฒ๋ผ ์ฃผ์ด์ง ๊ฒฉ์๋ฅผ ์ค๋ฅธ์ชฝ์ฒ๋ผ ์์๋ก ๋ณ๊ฒฝํด ์ฃผ์๋ค. ๋ฒฝ์ ์์๊ฐ์ผ๋ก ํํํ๊ณ 0์ ๊ทธ๋๋ก ๋น ๊ณต๊ฐ์ ํํ, ์์๋ ์ง๋์ผ ํ๋ ์์๋ฅผ ์ ์ด์ฃผ์๋ค. ์ด ๊ฒฉ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ฌ๊ท๋ฅผ ํตํด ๋ฐฑํธ๋ํน์ ํ๋ค ์ง๊ธ ์ง๋์ผ ํ๋ ์ง์ ์ด ์๋๋ฉด ๋ฐฉ๋ฌธํ์ง ์๋๋ก ์กฐ๊ฑด์ ์ ๊ฑธ์ด์คฌ๋ค.
import java.util.*;
import java.io.*;
public class Main
{
static int N, M, total;
static int[] dr = {-1,1,0,0}; // ์ํ์ข์ฐ
static int[] dc = {0,0,-1,1}; // ์ํ์ข์ฐ
static int[][] arr;
static boolean[][] visited;
public static void main(String args[]) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] NM = br.readLine().split(" ");
N = Integer.parseInt(NM[0]);
M = Integer.parseInt(NM[1]);
arr = new int[N][N]; // ๊ฒฉ์
visited = new boolean[N][N]; // ๋ฐฉ๋ฌธ ๋ฐฐ์ด
// ๊ฒฉ์ ์
๋ ฅ
// 0: ๋น์นธ, -1: ๋ฒฝ
for(int i = 0 ; i < N ; i++){
String[] line = br.readLine().split(" ");
for(int j = 0 ; j < N ; j++){
arr[i][j] = Integer.parseInt(line[j]);
// ๋ฒฝ์ -1๋ก ๋ณํ
if(arr[i][j] == 1) {
arr[i][j] = -1;
}
}
}
int startR = 0, startC = 0;
for(int i = 1 ; i <= M ; i++){
String[] RC = br.readLine().split(" ");
int R = Integer.parseInt(RC[0]) - 1;
int C = Integer.parseInt(RC[1]) - 1;
// ๋ช ๋ฒ์งธ๋ก ๋ฐฉ๋ฌธํด์ผ์ง
arr[R][C] = i;
// ์ถ๋ฐ์ ์ ์ฅ
if(i == 1){
startR = R;
startC = C;
}
}
visited[startR][startC] = true;
dfs(startR, startC, 2);
System.out.println(total);
}
// ๋ฐฑํธ๋ํน
static void dfs(int row, int col, int next){
if(next == M+1){
total++;
return;
}
for(int dir = 0 ; dir < 4 ; dir++){
int nr = row + dr[dir];
int nc = col + dc[dir];
if(inRange(nr, nc) && arr[nr][nc] != -1 && !visited[nr][nc]){
if(arr[nr][nc] > 0 && arr[nr][nc] != next) continue;
visited[nr][nc] = true;
if(arr[nr][nc] == next){
dfs(nr, nc, next + 1);
}else{
dfs(nr, nc, next);
}
visited[nr][nc] = false;
}
}
}
// ๋ฒ์ ํ์ธ
static boolean inRange(int r, int c){
if(r >= 0 && r < N && c >= 0 && c < N) return true;
return false;
}
}
์ธ์ฆ ํ์ธ
์ํ 2์ฃผ ๋ค 8์ 25์ผ์ ๊ฒฐ๊ณผ๊ฐ ๋ฐํ๋๋๋ฐ, ์ํ ์ ์ฒญํ ํ์ด์ง์ ํ๊ฐ ์ด๋ ฅ ํญ์์ ํ์ธํ ์ ์๋ค. ์ฌ๊ธฐ์ ์ธ์ฆ์๋ฅผ ๋ค์ด๋ก๋ํ ์ ์๋๋ฐ, ์๋์ ๊ฐ์ ์ธ์ฆ์๊ฐ ๋ฐ๊ธ๋๋ค.
์ธ์ฆ์๋ฅผ ์ทจ๋ํ๋ฉด ๋ง์ดํ์ด์ง์ ์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ๋ฐฐ์ง๊ฐ ํ์๋๋๋ฐ, ๊ต์ฅํ ํ์ฐฎ๊ณ ๊ท์ฝ..
'๐ etc.' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] python ๋ค์ด๊ทธ๋ ์ด๋ / ๋ฒ์ ๋ณ๊ฒฝ (0) | 2021.07.01 |
---|---|
[OS] ์คํธ๋ฆผ๊ณผ ํ์ค์คํธ๋ฆผ (0) | 2021.04.09 |
[Linux] ๋ฆฌ๋ ์ค ํ์ผ ์์คํ ๊ตฌ์กฐ / ๋ฃจํธ ๋๋ ํ ๋ฆฌ, ํ ๋๋ ํ ๋ฆฌ (0) | 2021.04.06 |
[Linux] ๋ฆฌ๋ ์ค ๋ช ๋ น์ด ๋ชจ์ (0) | 2021.04.05 |
AirSim Python API ์ฌ์ฉ (2) | 2021.03.16 |