[donghyeon95] Week2

climbing-stairs/donghyeon95.java

@@ -0,0 +1,64 @@
+
+/*
+* 처음 풀이
+* n개 중 2를 선택하는 조합 문제로 해결
+* 21부터 overflow 발생 => 너무 큰 숫자
+* 이대로 푸려면 1과 2의 갯수가 정확하게 같아지는 경우 * 2를 하면 f(1갯수, 2갯수) 할 때, f(x, y) = f(y,x)는 같다는 점을 착안하면 42까지는 풀 수 있을 듯 하다.
+* 하지만 45라서 안되는 거 같다.
+* */
+
+// public int climbStairs(int n) {
+// 	// N개의 1중에서 묶이는 경우의 수가 몇개인지
+// 	// 5 => 1 1 1 1 1
+// 	// 2의 갯수가 0개 2/n 까지 있는 경우의 수를 구하면 될 듯
+// 	long result = 0;
+// 	int max2Cnt = n/2;
+// 	for (int i=0; i<max2Cnt+1; i++) {
+// 		int cnt = n-2*i + i; // 조합을 구해야 하는 숫자의 갯수는 2의 개수 + 1의 갯수
+// 		result += factorial(cnt) / (factorial(i) * factorial(cnt-i));
+// 	}
+//
+// 	for (long k: nFact) {
+// 		System.out.println(k);
+// 	}
+//
+// 	return (int)result;
+// }
+//
+// public long factorial(int i) {
+// 	if (nFact[i] != 0) return nFact[i];
+// 	if (i == 0 || i == 1) {
+// 		nFact[i] = 1;
+// 		return 1;
+// 	}
+//
+// 	long result = i * factorial(i - 1);
+// 	nFact[i] = result;
+// 	return result;
+// }
+
+/*
+* 두번째 풀이
+* 나의 계단을 오르는 경우 = 이전에 1칸 오른 경우의 수 + 이전에 2칸 오른 경우의 수
+* 시간 복잡도 O(N)에 해결 가능하다.
+* */
+
+class Solution {
+	public int climbStairs(int n) {
+		// k번째의 계단을 오르는 경우의 수는
+		// k-1 번째 계단을 오르는 경우의 수 + K-2번째 계단을 오르는 경우의 수
+		if (n <= 2) return n;
+
+		int first = 1;
+		int second = 2;
+
+		for (int i = 3; i <= n; i++) {
+			int third = first + second;
+			first = second;
+			second = third;
+		}
+
+		return second;
+	}
+}
+

construct-binary-tree-from-preorder-and-inorder-traversal/donghyeon95.java

@@ -0,0 +1,116 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+
+class TreeNode {
+	int val;
+	TreeNode left;
+	TreeNode right;
+
+	TreeNode() {
+	}
+
+	TreeNode(int val) {
+		this.val = val;
+	}
+
+	TreeNode(int val, TreeNode left, TreeNode right) {
+		this.val = val;
+		this.left = left;
+		this.right = right;
+	}
+
+	public void setVal(int val) {
+		this.val = val;
+	}
+
+	public void setLeft(TreeNode left) {
+		this.left = left;
+	}
+
+	public void setRight(TreeNode right) {
+		this.right = right;
+	}
+
+	public int getVal() {
+		return val;
+	}
+
+	public TreeNode getLeft() {
+		return left;
+	}
+
+	public TreeNode getRight() {
+		return right;
+	}
+}
+
+class Solution {
+	int[] preList;
+	List<Integer> inList;
+	HashMap<Integer, TreeNode> treeNodes = new HashMap<>();
+
+	public TreeNode buildTree(int[] preorder, int[] inorder) {
+		preList = preorder;
+		inList = Arrays.asList(Arrays.stream(inorder).boxed().toArray(Integer[]::new));
+		List<Integer> preL = Arrays.asList(Arrays.stream(preorder).boxed().toArray(Integer[]::new));
+
+		int preIndex = 0;
+		int rootVal = preorder[0];
+		TreeNode root = new TreeNode(rootVal);
+		treeNodes.put(rootVal, root);
+
+		while (preIndex < preList.length - 1) {
+			System.out.println(preIndex);
+			int inIndex = inList.indexOf(preList[preIndex]);
+			int inNextIndex = inList.indexOf(preList[preIndex + 1]);
+
+			TreeNode node = new TreeNode(preList[preIndex + 1]);
+			treeNodes.put(preList[preIndex + 1], node);
+
+			if (inIndex > inNextIndex) {
+				// 현재 node의 왼쪽 자식으로
+				TreeNode nowNode = treeNodes.get(preList[preIndex]);
+				nowNode.setLeft(node);
+			} else {
+				// inorder의 앞 중에서 가장 처음 inList에서 앞인게
+				int value = 0;
+				int ii = inNextIndex;
+				while (ii >= 0) {
+					value = inorder[ii - 1];
+					int i = preL.indexOf(value);
+					if (i < preIndex + 1) {
+						treeNodes.get(preList[i]).setRight(node);
+						break;
+					}
+					ii--;
+				}
+
+			}
+
+			preIndex++;
+		}
+
+		return treeNodes.get(rootVal);
+	}
+
+}
+
+

valid-anagram/donghyeon95.java

@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+/*
+	map에 넣고 빼는 시간이 O(n)이라고는 하나, 시간이 걸린다.
+	반복문으로 처리할 수 있는 방법이 없을까?
+*/
+
+class Solution {
+	public boolean isAnagram(String s, String t) {
+		boolean result = false;
+
+		char[] chars = s.toCharArray();
+		Map<Character, Integer> counter = new HashMap<>();
+		for (char c: chars) {
+			counter.put(c, counter.getOrDefault(c, 0)+1);
+		}
+
+		char[] tChars = t.toCharArray();
+		for (char c: tChars) {
+			if (!counter.containsKey(c)) return false;
+			counter.put(c, counter.get(c)-1);
+
+			if (counter.get(c) == 0)
+				counter.remove(c);
+		}
+
+		return counter.isEmpty();
+	}
+}
+