2조 박도아 / 11월 1주차 / 목

doa/BOJ1202.java

@@ -0,0 +1,80 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+public class BOJ1202 {
+
+	static class jewl implements Comparable<jewl>{
+		int W, V;
+
+		public jewl(int W, int V) {
+			super();
+			this.W = W;
+			this.V = V;
+		}
+
+
+		@Override
+		public int compareTo(jewl o) {
+			// TODO Auto-generated method stub
+			return this.W - o.W;
+		}
+
+
+	}
+
+
+	public static void main(String[] args) {
+
+		Scanner sc = new Scanner(System.in);
+
+		int N = sc.nextInt();
+		int K = sc.nextInt();
+
+		List<jewl> jewls= new ArrayList<>();
+
+		PriorityQueue<Integer> bags= new PriorityQueue<Integer>();
+		PriorityQueue<Integer> bestV= new PriorityQueue<Integer>(Collections.reverseOrder());
+
+		for (int i = 0; i < N; i++) {
+			jewls.add(new jewl(sc.nextInt(),sc.nextInt()));
+		}
+
+		Collections.sort(jewls);
+
+		for (int i = 0; i < K; i++) {
+			bags.add(sc.nextInt());
+		}
+
+
+		long answer=0;
+		//value 순으로 정렬, 하고,
+		//bag는 낮은 순으로 정렬,
+		//낮은 순서대로 value를 뽑을 때 bag 기준만 충족하면 뽑아
+
+		int idx=0;
+		for(int i=0 ;i< K ; i++ ) {
+
+			int nowB = bags.poll();
+
+			while(idx<N && jewls.get(idx).W <=nowB) {
+
+				bestV.add(jewls.get(idx).V);
+				idx++;
+			}
+
+			if(!bestV.isEmpty()) answer += bestV.poll();
+
+			}
+
+
+
+		System.out.println(answer);
+
+	}
+
+
+
+}

doa/BOJ21939.java

@@ -0,0 +1,99 @@
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+public class BOJ21939 {
+
+	static class prob implements Comparable<prob> {
+		int problem, difficulty, count;
+
+		public prob(int problem, int difficulty) {
+			super();
+			this.problem = problem;
+			this.difficulty = difficulty;
+		}
+
+		 @Override
+	        public int compareTo(prob o) {
+	            // 난이도가 높은 것부터 먼저 오도록
+	            if (this.difficulty != o.difficulty) {
+	                return Integer.compare(this.difficulty, o.difficulty);
+	            }
+	            // 난이도가 같을 경우 문제 번호가 큰 것 우선
+	            return this.problem - o.problem;
+	        }
+
+	}
+
+	public static void main(String[] args) {
+
+		Scanner sc = new Scanner(System.in);
+
+		int N = sc.nextInt();
+
+		PriorityQueue<prob> low = new PriorityQueue<prob>();
+		PriorityQueue<prob> high = new PriorityQueue<prob>(Collections.reverseOrder());
+		Map<Integer, Integer> map = new HashMap<>();
+
+		for (int i = 0; i < N; i++) {
+			int P = sc.nextInt();
+			int L = sc.nextInt();
+			low.add(new prob(P, L));
+			high.add(new prob(P, L));
+			map.put(P,L);
+		}
+
+		N = sc.nextInt();
+
+		for (int i = 0; i < N; i++) {
+			String commend = sc.next();
+
+			if (commend.equals("recommend")) {
+				int num = sc.nextInt();
+				if (num == 1) {
+					while(!high.isEmpty()) {
+						prob top = high.peek();
+						 if (map.containsKey(top.problem) && map.get(top.problem) == top.difficulty) {
+	                            System.out.println(top.problem);
+	                            break;
+	                        }
+						 high.poll();
+					}
+
+
+				} else {
+
+					while(!low.isEmpty()) {
+						prob top = low.peek();
+						 if (map.containsKey(top.problem) && map.get(top.problem) == top.difficulty) {
+	                            System.out.println(top.problem);
+	                            break;
+	                        }
+						low.poll();
+					}
+
+
+
+				}
+			} else if (commend.equals("solved")) {
+				int num = sc.nextInt();
+				map.remove(num);
+
+			}
+			//추가할 경우
+			else {
+				int P = sc.nextInt();
+				int L = sc.nextInt();
+				low.add(new prob(P, L));
+				high.add(new prob(P, L));
+				map.put(P,L);
+			}
+
+		}
+
+	}
+
+
+}

doa/BOJ5639.java

@@ -0,0 +1,69 @@
+package 알고리즘;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.List;
+
+public class BOJ5639 {
+
+	  static class Node {
+	        int key;
+	        Node left, right;
+
+	        Node(int key) {
+	            this.key = key;
+	            left = right = null;
+	        }
+	    }
+
+	  static Node insertNode(Node node, int num) {
+
+		  if(node == null)
+			  return new Node(num);
+
+		  if(num < node.key) {
+			  node.left = insertNode(node.left, num);
+		  }else {
+
+			  node.right = insertNode(node.right, num);
+		  }
+
+		  return node;
+
+	  }
+
+	  static void postOrder(Node num) {
+
+		  if(num!=null) {
+			  postOrder(num.left);
+			  postOrder(num.right);
+			  System.out.println(num.key);
+		  }
+
+	  }
+
+	public static void main(String args[]) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		String input;
+
+
+		//루트 값 입력
+		Node now = null;
+
+		while((input = br.readLine()) != null && !input.isEmpty()) {
+			int num = Integer.parseInt(input);
+
+			now = insertNode(now,num);
+
+		}
+
+
+		postOrder(now);
+
+	}
+
+}
+
+
+

doa/boj1043.java

@@ -0,0 +1,92 @@
+package 알고리즘;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Scanner;
+import java.util.Set;
+
+public class boj1043 {
+
+	static int M;
+	static int N;
+	static Set<Integer> cantLie;
+	static List<Set<Integer>> party;
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        party = new ArrayList<>();
+
+        N = sc.nextInt();
+        M = sc.nextInt();
+
+        int N1 = sc.nextInt();
+        cantLie = new HashSet<>();
+
+        for(int i=0;i<N1 ; i++) {
+        	cantLie.add(sc.nextInt());
+        }
+
+
+        for(int i=0;i<M ; i++) {
+        	int N2= sc.nextInt();
+        	Set<Integer> parties = new HashSet<>();
+        	 for(int j=0;j<N2 ; j++) {
+        	parties.add(sc.nextInt());
+
+        }
+        	 party.add(parties);
+
+        }
+
+
+        System.out.println(M-bfs());
+
+    }
+   public static int bfs() {
+
+	   int count=0;
+    	Queue<Integer> queue = new LinkedList<>();
+
+    	//특정 수만큼
+    	boolean[] visitedPeople = new boolean[N+1];
+    	boolean[] visitedParty = new boolean[M+1];
+
+    	for(int a : cantLie) {
+    		visitedPeople[a]=true;
+    	}
+
+    	queue.addAll(cantLie);
+
+    	while(!queue.isEmpty()) {
+
+    		int now = queue.poll();
+    		int idx =0;
+
+    		for(Set<Integer> a : party) {
+    			idx++;
+
+    			if(visitedParty[idx]) continue;
+
+    			if(a.contains(now)) {
+    				count++;
+    				visitedParty[idx]=true;
+    				cantLie.addAll(a);    	
+
+    				for(int c : a) {
+    					if(!visitedPeople[c]) {
+    						queue.add(c);
+    						visitedPeople[c]=true;
+    					}
+    				}
+    			}
+    		}
+
+    	}
+
+    	return count;
+    }
+
+    }
+