728x90
728x90

문제 링크 : https://www.acmicpc.net/problem/10816

 

10816번: 숫자 카드 2

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,

www.acmicpc.net

 

 

 

문제

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.

 

 


 

접근 방법

이번에도 nextInt()와 System.out.print() 로 입출력을 하니까 시간초과가 나서 버퍼입출력으로 시간초과를 해결했다.

 

HashMap과 containsKey(), get() 메소드만 이용하면 쉽게 해결할 수 있다.

import java.util.*;
import java.io.*;

public class Map_BOJ10816_숫자카드2 {
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer tokens;
	
	public static void main(String[] args) throws IOException {
		
		int N = Integer.parseInt(br.readLine());
		
		HashMap<Integer,Integer> map = new HashMap<>();
		
		tokens = new StringTokenizer(br.readLine());
		for(int i = 0; i<N; i++) {
			int num = Integer.parseInt(tokens.nextToken());
			if(!map.containsKey(num)) {
				map.put(num, 1);
			}
			else {
				int newValue = map.get(num) + 1;
				map.put(num, newValue);
			}
		}
		
		
		int M = Integer.parseInt(br.readLine());
		tokens = new StringTokenizer(br.readLine());
		for(int i = 0; i<M; i++) {
			int num = Integer.parseInt(tokens.nextToken());
			if(map.containsKey(num)) {
				bw.write(map.get(num) + " ");
			}
			else {
				bw.write("0 ");
			}
			
		}
		bw.flush();
		bw.close();
		br.close();
	}
}
728x90

'Algorithm(BOJ)' 카테고리의 다른 글

[C++] 백준 2775번 - 부녀회장이 될테야  (0) 2021.05.29
728x90

문제 링크 : https://programmers.co.kr/learn/courses/30/lessons/42747

 

코딩테스트 연습 - H-Index

H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과1에 따르면, H-Index는 다음과 같이 구합니다. 어떤 과학자가 발표

programmers.co.kr

 

 

접근 방법

문제 조건에 주어진대로 구현하면 된다.

citations중 최대값이 maxNum부터 검사를 해 나가는데, h번 이상 인용된 논문의 수인 cnt가 h편 이상이고, 나머지가(len-cnt)가 h번 이하로 인용되면 answer에 값을 저장하고 검사를 중단한다.

h의 max를 찾는 것이므로 더 작은 값은 검사할 필요가 없다.

 

import java.util.*;
class Solution {
    public int solution(int[] citations) {
        int answer = 0;
        Arrays.sort(citations);
        int len = citations.length;
        int maxNum = citations[len-1];
        
        for(int i = maxNum; i>=0; i--){	//h의 max를 찾는 것이므로
            int cnt = 0;
            for(int j = 0; j<len; j++){
                if(citations[j]>=i) cnt+=1;
            }
            if(cnt>=i && (len-cnt)<=i) {
                answer = i;
                break;
            }
        }
        return answer;
    }
}
728x90
728x90

문제 링크 : https://programmers.co.kr/learn/courses/30/lessons/43238?language=java# 

 

코딩테스트 연습 - 입국심사

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다. 처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한

programmers.co.kr

 

 

 

 

접근 방법

이분탐색으로 푸는 문제인데 형변환에 주의해야 한다.

처음에는 아래와 같이 우선순위 큐로 풀었는데 시간초과가 떴다.

import java.util.*;

class Solution {
    public long solution(int n, int[] times) {
        long answer = 0;
        int len = times.length;
        
        PriorityQueue<Long> pq = new PriorityQueue<Long>();
        
        for(int i = 0; i<len; i++){
            for(int j = 1; j<=n; j++){
                pq.add((long)times[i]*j);
            }
        }
        long cnt = 0;
        while(!pq.isEmpty()){
           cnt += 1;
            long num = pq.poll();
            //System.out.println(num);
            if(cnt==n){
                answer = num;
                break;
            }
        }
        
        return answer;
    }
}

 

 

그래서 이분 탐색으로 해결하였다.

import java.util.*;

class Solution {
    public long solution(int n, int[] times) {
        
        int len = times.length;
        Arrays.sort(times);
        
        long maxi = (long) times[len-1] * n;		//여기서 형변환 안 하면 틀림.
        long answer = maxi;
        
        long left = 1;
        long right = maxi;
        while(left<=right){
            long mid = (left+right)/2;
            
            long sum = 0;					//sum 도 long 으로!
            for(int i = 0; i<len; i++){
                sum += mid/times[i];
            }

            if(sum>=n){
                if(mid < answer){
                    answer = mid;
                }
                right = mid - 1;
            } 
            else left = mid + 1;
            
        }

        return answer;
    }
}

 

728x90
728x90

문제 링크 : https://www.acmicpc.net/problem/10815

 

10815번: 숫자 카드

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,

www.acmicpc.net

 

 

문제

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 가지고 있는지 아닌지를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다. 두 숫자 카드에 같은 수가 적혀있는 경우는 없다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 가지고 있는 숫자 카드인지 아닌지를 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다

출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 가지고 있으면 1을, 아니면 0을 공백으로 구분해 출력한다.

 

 


 

접근 방법

로직은 간단하다. 상근이가 가지고 있는 N개의 카드를 오름차순으로 정렬한 뒤, M개의 정수를 하나씩 따져가면서 이분탐색을 진행하면 된다. 

 

@ 주의할 점

자바로 문제를 푸는 경우에 Scanner로 입력을 받으면 시간초과가 뜨는 것이다. BufferedReader, BufferedWriter로 시간을 단축하도록 하자!

 

import java.util.*;
import java.io.*;
public class BinarySearch_BOJ10815_숫자카드 {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		int N = Integer.parseInt(br.readLine());
		int[] arrN = new int[N];
		StringTokenizer st = new StringTokenizer(br.readLine());
		

		for(int i = 0; i<N; i++) {
			arrN[i] = Integer.parseInt(st.nextToken());
			//arrN[i] = sc.nextInt();
		}
		Arrays.sort(arrN);
		
		
		int M = Integer.parseInt(br.readLine());
		st = new StringTokenizer(br.readLine());		//여기서 다시 초기화 해줘야 함.
		for(int i = 0; i<M; i++) {
			
			int m = Integer.parseInt(st.nextToken());
			
			int first= 0;
			int last = N-1;
			boolean flag = false;
			while(first<=last) {

				int mid = (first+last)/2;
				int targetN = arrN[mid];
				 
				if(targetN==m) {
					flag = true;
					break;
				}
				
				if(targetN > m) {
					last = mid - 1;
				}
				else {
					first = mid + 1;
				}
				
			}
			if(flag) bw.write(1 + " ");
			else bw.write(0 + " ");
			
		}
	bw.flush();
	bw.close();
	br.close();
	}
}

728x90
728x90

문제 링크 : https://www.acmicpc.net/problem/16234

 

16234번: 인구 이동

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모

www.acmicpc.net

 

 

문제

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모든 나라는 1×1 크기이기 때문에, 모든 국경선은 정사각형 형태이다.

오늘부터 인구 이동이 시작되는 날이다.

인구 이동은 다음과 같이 진행되고, 더 이상 아래 방법에 의해 인구 이동이 없을 때까지 지속된다.

  • 국경선을 공유하는 두 나라의 인구 차이가 L명 이상, R명 이하라면, 두 나라가 공유하는 국경선을 오늘 하루동안 연다.
  • 위의 조건에 의해 열어야하는 국경선이 모두 열렸다면, 인구 이동을 시작한다.
  • 국경선이 열려있어 인접한 칸만을 이용해 이동할 수 있으면, 그 나라를 오늘 하루 동안은 연합이라고 한다.
  • 연합을 이루고 있는 각 칸의 인구수는 (연합의 인구수) / (연합을 이루고 있는 칸의 개수)가 된다. 편의상 소수점은 버린다.
  • 연합을 해체하고, 모든 국경선을 닫는다.

각 나라의 인구수가 주어졌을 때, 인구 이동이 몇 번 발생하는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N, L, R이 주어진다. (1 ≤ N ≤ 50, 1 ≤ L ≤ R ≤ 100)

둘째 줄부터 N개의 줄에 각 나라의 인구수가 주어진다. r행 c열에 주어지는 정수는 A[r][c]의 값이다. (0 ≤ A[r][c] ≤ 100)

인구 이동이 발생하는 횟수가 2,000번 보다 작거나 같은 입력만 주어진다.

출력

인구 이동이 몇 번 발생하는지 첫째 줄에 출력한다.

 

 


 

 

접근 방법

 

각 땅 (r,c) 에 대해 무한루프를 돌면서 

     - BFS를 이용해 국경선을 서로 열 수 있는 땅을 Queue에 다 넣고, BFS 탐색이 끝나면 인구이동을 해준다. 

     - 모든 칸에 대해 인구이동 여부를 탐색 했으면 다시 처음으로 돌아가서 visited를 초기화 시킨 후 재 탐색한다. (만약 이 단계에서 탐색이 끝났을 때 인구이동이 한 번도 발생하지 않았다면 무한루프를 종료시킨다.)

 

import java.util.*;

class Pair16234{
	Integer r, c;
	public Pair16234(Integer _r, Integer _c) {
		this.r = _r;
		this.c = _c;
	}
	public int getRow() {
		return this.r;
	}
	public int getCol() {
		return this.c;
	}
	
}
public class SM_BOJ16234_인구이동 {

	static int N, L, R, answer;
	static int[][] map, visited; 
	static int[] dr,dc;

	static boolean chk(int a, int b) {
		int sub = Math.abs(a-b);
		if(L <= sub && sub <=R) return true;
		else return false;
	}
	
	static boolean BFS(int r, int c) {
		
		Queue<Pair16234> que = new LinkedList<Pair16234>();
		ArrayList<Pair16234> vec = new ArrayList<Pair16234>();
		int sum = 0;
		
		Pair16234 p = new Pair16234(r,c);
		que.add(p);
		vec.add(p);
		sum = map[r][c];
		
		while(!que.isEmpty()) {
			Pair16234 pair = que.poll();
			int cr = pair.getRow();
			int cc = pair.getCol();
			
			visited[cr][cc] = 1;
			
			for(int i = 0; i<4; i++) {
				int nr = cr + dr[i];
				int nc = cc + dc[i];
				if(nr<1 || nr>N || nc<1 || nc>N || visited[nr][nc]==1) continue;
				
				if(chk(map[cr][cc], map[nr][nc])) {
					visited[nr][nc] = 1;
					Pair16234 p_next = new Pair16234(nr,nc);
					que.add(p_next);
					vec.add(p_next);
					sum += map[nr][nc];
				}
			}
		}
		
		if(vec.size()==1) {
			visited[vec.get(0).getRow()][vec.get(0).getCol()] = 0;
			return false;
		}
		else {
			int avg = sum / vec.size();
			for(int i = 0; i<vec.size(); i++) {
				int row = vec.get(i).getRow();
				int col = vec.get(i).getCol();
				map[row][col] = avg;
			}
			return true;
		}
		
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc = new Scanner(System.in);
		dr = new int[4];
		dc = new int[4];
		dr[0] = -1; dr[1] = 0; dr[2] = 1; dr[3] = 0;
		dc[0] = 0; dc[1] = 1; dc[2] = 0; dc[3] = -1;

		N = sc.nextInt();
		L = sc.nextInt();
		R = sc.nextInt();
		
		map = new int[51][51];
		visited = new int[51][51];
		for(int i = 1; i<=N; i++) {
			for(int j = 1; j<=N; j++) {
				map[i][j] = sc.nextInt();
				visited[i][j] = 0;
			}
		}
		
		answer = 0;

		int cnt = 0;	
		while(true) {
			
			if(cnt==N*N) break;
			cnt = 0;
			
			boolean flag = false;
			
            //인구 이동 끝나고 초기화 
			for(int r = 1; r<=N; r++) {
				for(int c = 1; c<=N; c++) {
					visited[r][c] = 0;
				}
			}
			
			for(int i = 1; i<=N; i++) {
				for(int j = 1; j<=N; j++) {

					if(visited[i][j]==0) {
						boolean res = BFS(i,j);		//국경선 열렸으면 true 
						if(res) {
							flag = true;
						}					
						else cnt++;
					}
				}
			}
			
			if(flag) answer++;
		}
		System.out.println(answer);
	}

}

728x90
728x90

문제 링크 : https://www.acmicpc.net/problem/10989

 

10989번: 수 정렬하기 3

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

www.acmicpc.net

 

 

문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

 

 


 

접근 방법

수 정렬하기 1번과 2번은 vector의 sort()로 쉽게 풀었는데 이번 문제는 N의 범위가 커서 메모리 초과가 난다.

우선순위 큐를 써도 똑같이 메모리 초과가 난다.

그래서 수의 범위가 10,000을 넘지 않는 점을 고려해서 아래와 같이 코드를 작성했다.

 

* 참고

   ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

를 쓰지 않으면 시간초과가 뜬다. 

 

 

#include <iostream>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    
    int N; cin >> N;
    int arr[10001] = {0,};
    int num =0;
    for(int i = 0; i<N; i++){
        cin >> num;
        arr[num] += 1;
    }
    for(int i = 1; i<=10000; i++){
        for(int j = 0; j<arr[i]; j++){
            cout << i << "\n";
        }
    }
    
    return 0;
}

 

728x90
728x90

[AWS 를 이용한 자유로운 규모 확장과 축소]

 

Step 1) Scalability

- Scalability 에 두가지 전략이 있다. (Scale Up/Down)

 

- EC2의 큰 특징

 : 가상화 / 종량제 (이 두 특성은 EC2에 국한되지 않고 클라우드 컴퓨팅의 핵심 아이디어이다.)

 

- 가상머신이란?

 : 물리적 기계(컴퓨터)가 아니라 물리적 컴퓨터의 위에서 돌아가는 SW적인 컴퓨터

 

- 개인용 시장에서의 가상머신

 : VMWare, VirtualBox, Parallels

 

- 클라우드 시장에서는 기업이 타겟임.

 

- 변화하는 수요에 얼마나 탄력적으로 공급을 변화시킬 수 있는가가 관건이며 이는 클라우딩 시스템을 기반으로 공급의 질적 변화를 이룰 수 있다.

 

 

Step 2) Scale Up (전략 1) 

=> 인스턴스를 이미지화 시키고 더 좋은 인스턴스 타입으로 업그레이드 

 

 

- 인프라 수요에 따라 계속 컴퓨터 자원을 업그레이드 하는 것. 

- 실천하기 비교적 쉬움. 

- 이 전략을 EC2 인스턴스에서 실현해보자.  -> 각각 공격과 수비를 하는 컴퓨터 두 대가 필요함. (한대의 컴퓨터가 나머지 컴퓨터 웹서버에 계속 접근하면서 늘어나는 사용자 환경을 시뮬레이션 함)

 

- 웹서비스를 제공하는 수비쪽 인스턴스에 wordpress 를 설치하고 공격쪽 인스턴스도 생성한다. 수비쪽 인스턴스에서 Scale Up을 해나갈 것이다.

- 유저 인스턴스에서 부하(Load) 발생기(아파치에서 만든 ab 프로그램)를 이용해 사용자들이 많이 발생하는 상황을 시뮬레이션 해 보자.

 

*ab 프로그램 사용 방법 

$sudo apt-get install apache2-utils

$ab

<옵션>

-n : Number of requests to perform -> 웹 서버에 몇번의 접속을 시도하겠는가

-c : Number of multiple requests to make at a time -> 동시에 몇번의 접속을 시도하겠는가 

(c = 1, n = 100이면 순차적으로 100번 접속하는 것이고

 c = 100, n = 1이면 한 번에 100명이 접속하는 것임)

 

옵션 값을 조정해가며 요청을 완료하기까지 소요되는 시간과 초당 처리 속도 및 개별 처리 속도를 비교해보자.

 

 

Step 3) Elastic IPs

- 인스턴스를 Stop 후 재시작하면 IP가 달라진다. Stop하는 동안 자원(IP)을 회수하기 때문이다. 

- Scale Up을 위해 기존 인스턴스를 이미지화 후 인스턴스 성능 업그레이드를 하려 할 때, 기존 IP가 바뀌어버리는 문제가 있다. 이때 사용하는 것이 Elastic Ip이다. (유료 서비스)

- Elastic Ip는 고정 ip를 의미하며 ip 주소를 아마존으로부터 받아 소유하는 것이다. -> 사용자는 동일한 ip로 접속할 수 있음 

 

 

Step 4) 인스턴스 교체

- 성능이 업그레이드 된 인스턴스를 새로 만든 후 기존 인스턴스에서 부여받은 Elastic Ip를 새 인스턴스에 부여한다.

 

 

Step 5) Scale Out (전략 2)

- 여러대의 컴퓨터를 사용해서 협력하는 것

- 계속 Scale Up 하다 보면 단일 컴퓨터의 한계 발생하는 문제에 대한 방안

728x90
728x90

강의 : 인프런 - AWS 가입부터 활용까지

 

 

- AMIs는 Amazon Machine Images의 약자이다. 

- Machine은 가상머신으로 컴퓨터를 의미하며 Images는 컴퓨터가 가진 상태를 그대로 얼려서 나중에 똑같이 복원할 수 있는 형태의 데이터를 뜻한다. 즉, 운영체제/SW/설정들/실행된 프로그램 등을 그대로 얼려 만든것이 Image 이다.

 

- 해당 기능은 서버에 중요 작업을 할 때, 이미지로 상태를 백업해 놓고 문제가 발생했을 때 문제가 발생한 인스턴스는 삭제하고 다시 원본 이미지를 이용해 새로운 인스턴스를 만드는데에 이용된다.

 

 

 

AWS Marketplace에서 Wordpress 설치하기

 

아마존 머신 이미지를 이용해서 다른 사람이 만든 인스턴스를 사용해서 빠르게 서비스를 만들어 보는 단계이다.

만들어놓은 윈도우 인스턴스에 다른 사람이 만들어 놓은 WordPress AMI를 설치해보자. 

https://aws.amazon.com/marketplace/search/results?x=0&y=0&searchTerms=wordpress 

 

AWS Marketplace: Search Results

Version 6.2 Sold by DigitalCube Co. Ltd Starting from $0.01/hr or from $40.00/yr (up to 30% savings) for software + AWS usage fees WordPress powered by AMIMOTO is the ready-to-run WordPress solution for Amazon EC2. This 1-Click AMI was developed by our exp

aws.amazon.com

 

 

 

강의에서 HVM(하드웨어 가상 머신) 버전을 선택하는 것이 좋다고 했는데 현재 시점으로는 없으므로 가장 위에 있는 WordPress를 선택한다.

 

 

728x90

+ Recent posts