diff --git a/3sum/jinvicky.java b/3sum/jinvicky.java
new file mode 100644
index 000000000..84d17d9b4
--- /dev/null
+++ b/3sum/jinvicky.java
@@ -0,0 +1,38 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+// https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/ 문제를 풀고 다시 풀었습니다.
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] == nums[i-1]) {
+                continue;
+            }
+
+            int j = i + 1;
+            int k = nums.length - 1;
+
+            while (j < k) {
+                int total = nums[i] + nums[j] + nums[k];
+
+                if (total > 0) {
+                    k--;
+                } else if (total < 0) {
+                    j++;
+                } else {
+                    res.add(Arrays.asList(nums[i], nums[j], nums[k]));
+                    j++;
+
+                    while (nums[j] == nums[j-1] && j < k) {
+                        j++;
+                    }
+                }
+            }
+        }
+        return res;
+    }
+}
diff --git a/climbing-stairs/jinvicky.java b/climbing-stairs/jinvicky.java
new file mode 100644
index 000000000..6187b97e3
--- /dev/null
+++ b/climbing-stairs/jinvicky.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int climbStairs(int n) {
+        // n=1일때 방법은 1가지다.
+        // n=2일때 방법은 2가지다.
+        // n=3일때 방법은 3가지다.
+        // n=4일때 방법은 5가지다.
+        // 1,1,1,1
+        // 1,1,2
+        // 1,2,1
+        // 2,1,1
+        // 2,2
+        // dp 알고리즘으로 4는 2와 3의 방법 개수를 재활용해서 dp[n] = dp[n-2] + dp[n-1] 을 도출할 수 있다.
+        // 단 n이 1,2,3일 때의 값을 먼저 셋팅한다.
+
+        if (n <= 3)
+            return n;
+
+        int[] dp = new int[n];
+        dp[0] = 1;
+        dp[1] = 2;
+        dp[2] = 3;
+
+        for (int i = 3; i < n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+
+        return dp[n - 1];
+    }
+}
diff --git a/product-of-array-except-self/jinvicky.java b/product-of-array-except-self/jinvicky.java
new file mode 100644
index 000000000..9bdedee2a
--- /dev/null
+++ b/product-of-array-except-self/jinvicky.java
@@ -0,0 +1,25 @@
+// prefix sum 패턴을 사용한다.
+// nums.length 길이의 정답 배열을 만들고 left, right 변수를 선언한다.
+// 처음부터 for문으로 nums만 누적합 배열을 만들고 해결하려고 했던 게 실패 원인이었다. 변수 사용 및 계산식을 고려하지 못함.
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int[] output = new int[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            output[i] = 1;
+        }
+
+        // 정답에 값을 적용하고 left, right을 업데이트한다는 점이 중요했다. -> 선적용 후업데이트를 잘못 이해해서 헤맸다.
+        int left = 1;
+        for (int i = 0; i < nums.length; i++) {
+            output[i] *= left; // 1,2,2,6
+            left *= nums[i]; // 1,2,6,24 (output 적용이 끝났으므로 24는 사실상 적용되지 않는다)
+        }
+
+        int right = 1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            output[i] *= right; // 6,8,12,24 -> 배열 인덱스가 역순이기 때문에 결과적으로 [24, 12, 8, 6] 이 된다.
+            right *= nums[i]; //
+        }
+        return output;
+    }
+}
diff --git a/valid-anagram/jinvicky.java b/valid-anagram/jinvicky.java
new file mode 100644
index 000000000..d25f9dba7
--- /dev/null
+++ b/valid-anagram/jinvicky.java
@@ -0,0 +1,45 @@
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    //유효한 애너그램의 조건이 무엇일까?
+    //1. a와 b의 알파벳별 빈도수가 정확히 동일해야 한다.
+    //2. 단 a와 b의 알파벳 구성 순서는 다를 수 있다.
+
+    // map 자료구조를 활용해서 s의 알파벳 빈도수를 저장하고 이후 t를 순회하면서 map에 존재하는 알파벳일 경우
+    // 1. 빈도수를 깎는다. 2. 빈도수가 0일 경우 map에서 삭제한다.
+    public boolean isAnagramByHashMap(String s, String t) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+
+        for (char c : t.toCharArray()) {
+            Integer v = map.get(c);
+
+            if (v == null)
+                return false;
+
+            if (v - 1 == 0) {
+                map.remove(c);
+            } else
+                map.put(c, v - 1);
+        }
+        return map.size() < 1;
+    }
+
+    // 또 다른 방법으로는 단순히 두 문자열을 정렬하고 문자열 내용 일치 비교를 수행하는 방법이 있다.
+    // 이 방법을 사용할 때 처음에는 무조건 정렬을 수행했으나,
+    // 문자열의 개수가 다르다면 1번 조건을 만족하지 못하므로 길이 비교 로직을 정렬 전에 추가함으로서 시간 성능을 높였다.
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) return false;
+        char[] sChars = s.toCharArray();
+        char[] tChars = t.toCharArray();
+
+        Arrays.sort(sChars);
+        Arrays.sort(tChars);
+
+        return new String(sChars).equals(new String(tChars));
+    }
+}
diff --git a/validate-binary-search-tree/jinvicky.java b/validate-binary-search-tree/jinvicky.java
new file mode 100644
index 000000000..263159934
--- /dev/null
+++ b/validate-binary-search-tree/jinvicky.java
@@ -0,0 +1,15 @@
+
+// dfs 방식으로 풀이해야 합니다. tree 관련 easy 문제를 10문제 정도 풀고 접근했습니다.
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return check(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    private boolean check(TreeNode node, long min, long max) {
+        if (node == null) return true;
+
+        if (!(node.val > min && node.val < max)) return false;
+
+        return check(node.left, min, node.val) && check(node.right, node.val, max);
+    }
+}