[namuuCY] WEEK 03 Solutions

combination-sum/namuuCY.java

@@ -0,0 +1,41 @@
+// 문제풀이 흐름
+// 하나를 집어넣고, 모자라면 이전과 동일한걸 집어넣거나 더 큰걸 집어넣는 방식으로 계속 확인
+// -> 백트래킹 방식
+
+// n = candidates.length / m = candidates[0] 라 할때,
+// 시간복잡도 :
+//      이론상 O(n ^ (target / m))
+//      150 조합 이내로 뽑히게끔 만들어뒀으므로 알아서 잘되지 않았을까...
+// 공간복잡도 :
+//      O(target / m) - 재귀 깊이만큼
+
+
+class Solution {
+
+	List<List<Integer>> answer = new ArrayList<>();
+	int[] candidates;
+	int target;
+
+	public List<List<Integer>> combinationSum(int[] candidates, int target) {
+		this.candidates = candidates;
+		this.target = target;
+
+		backtracking(new ArrayList<>(), 0, target);
+		return answer;
+	}
+
+	public void backtracking(List<Integer> combination, int currentIdx, int remainder) {
+		if (remainder == 0) {
+			answer.add(new ArrayList<>(combination));
+			return;
+		} else if (remainder < 0) {
+			return;
+		}
+
+		for (int i = currentIdx ; i < candidates.length ; i++) {
+			combination.add(candidates[i]);
+			backtracking(combination, i, remainder - candidates[i]);
+			combination.remove(combination.size() - 1);
+		}
+	}
+}

decode-ways/namuuCY.java

@@ -0,0 +1,60 @@
+// 문제 풀이 흐름
+// DP[i] = i - 1 번째 인덱스 char를 끝으로 하는 조합
+// 문제는 case를 다 분리할 수 밖에 없는건가?
+// 7~9 이면 앞자리가 1인지 확인 -> 있으면 두가지 합해야함 / 아니면 한가지만
+// 0이면 앞자리가 반드시 1,2 이어야함 -> 무조건 한가지
+// 1~6이면 앞자리가 1,2인지 확인 -> 있으면 두가지 합해야함 / 아니면 한가지만
+// 이러면 너무 더러운 느낌?
+//      if () {
+//           if ()
+//       } else if () {
+//           if ()
+//       } else {
+//       }
+
+// 추가적으로 고려하지 못한 사항 : 01, 001 과 같은 경우
+
+// n = s의 길이
+// 시간복잡도 : O(n)
+// 공간복잡도 : O(n)
+
+
+class Solution {
+
+	String s;
+	int length;
+	int[] DP;
+
+	public int numDecodings(String s) {
+
+		this.s = s;
+		this.length = s.length();
+		this.DP = new int[this.length + 1];
+
+		DP[0] = 1;
+
+		for (int i = 1 ; i < this.length + 1; i ++) {
+
+			if (canDecodeSingle(i)) {
+				DP[i] += DP[i - 1];
+			}
+
+			if (i >= 2 && canDecodePair(i)) {
+				DP[i] += DP[i - 2];
+			}
+		}
+
+		return DP[this.length];
+	}
+
+	private boolean canDecodeSingle(int currentIdx) {
+		return s.charAt(currentIdx - 1) != '0';
+	}
+
+	private boolean canDecodePair(int currentIdx) {
+		char currentChar = s.charAt(currentIdx - 1);
+		char prevChar = s.charAt(currentIdx - 2);
+		return prevChar == '1'
+				|| (prevChar == '2' && currentChar <= '6');
+	}
+}

maximum-subarray/namuuCY.java

@@ -0,0 +1,30 @@
+// 문제 풀이 흐름
+// 맨처음에 생각한 풀이는
+// 누적합을 기준으로,
+// 누적합의 오른쪽 최대 - 왼쪽 최소 의 값이 제일 큰걸 구하면 된다고 생각했음.
+// 예를 들어서 nums = [-2,1,-3,4,-1,2,1,-5,4] 라면
+// 누적합은 [-2 -1 -4 0 -1 1 2 -3] 이 되는데, 값의 최대는 2에서 -4를 뺸 6이 최대라고 생각했음.
+// 그래서 어느 한 좌표(왼쪽)를 순회하면서
+// 이 인덱스의 오른쪽(왼쪽 인덱스 +1 부터 끝까지)의 누적합의 최소를 구하면 된다고 생각했음.
+//      이 위를 구하기 위해서 누적합에 대해 세그먼트 트리를 구축해두려고 했음.
+// 그러면 세그먼트 트리 만드는데 nlogn + 1중 for 문 * log n 조회니까 최대 nlogn의 시간복잡도로 문제를 풀수있음 / 공간복잡도는 O(n log n)이 될것.
+
+// 근데 제시된 풀이를 보니까 1차원 DP로 푸는것을 봤음.
+// DP[i] = Math.max(nums[i], DP[i - 1] + nums[i]);
+// 혹은 = nums[i] + (DP[i - 1] > 0) ? DP[i - 1] : 0; 이 되겠지.
+// 이렇게 하면 시간복잡도 O(n) 공간복잡도 O(n)이라 내 풀이보다 훨씬좋다
+
+class Solution {
+
+	public int maxSubArray(int[] nums) {
+		int[] DP = new int[nums.length + 1];
+		int maxSum = - 200000;
+
+		for (int i = 0 ; i < nums.length; i ++) {
+			DP[i + 1] = nums[i] + (DP[i] > 0 ? DP[i] : 0);
+			maxSum = Math.max(maxSum, DP[i + 1]);
+		}
+
+		return maxSum;
+	}
+}

number-of-1-bits/namuuCY.java

@@ -0,0 +1,20 @@
+// 문제풀이 흐름
+// 어떤 숫자를 2진수로 나타냈을때, 1의 개수를 구하는 것이므로
+// 2진수 변환과정에서 나오는 모든 1의 갯수만 세면 된다.
+
+// 숫자 n에 대하여
+// 시간복잡도 : O(logn)
+// 공간복잡도 : O(1)
+
+class Solution {
+	public int hammingWeight(int n) {
+		int answer = 0;
+
+		while (n > 0) {
+			if (n % 2 == 1) answer ++;
+			n /= 2;
+		}
+
+		return answer;
+	}
+}

valid-palindrome/namuuCY.java

@@ -0,0 +1,51 @@
+// 문제 풀이 흐름 1
+// 먼저, 알파벳이 아닌 글자는 다 쳐내는 작업이 필요
+// 그 다음 알파벳으로만 만들어진 문자열에 대해 팰린드롬 확인
+// 길이 확인 후
+// 맨처음에서부터 중간까지, 대칭 값이 맞는지 확인
+
+// n = s의 길이라 할때
+// 시간복잡도 : O(n)
+// 공간복잡도 : O(n) - 어쩔수없이 trimming한 문자열은 저장해야하므로
+
+// 문제 풀이 흐름 2
+
+// 문자열 그대로 팰린드롬 확인 스타트
+// 맨 앞과 뒤의 인덱스에서 시작해서
+//  알파벳이 아닌 다른 문자라면 skip
+//  알파벳이라면 비교
+
+// n = s의 길이라 할때
+// 시간복잡도 : O(n)
+// 공간복잡도 : O(1)
+
+
+class Solution {
+	public boolean isPalindrome(String s) {
+		int rightIdx = s.length() - 1;
+
+		for (int leftIdx = 0 ; leftIdx <= rightIdx ; leftIdx ++) {
+			if (!isValid(s.charAt(leftIdx))) continue;
+
+			// rightIdx 조절
+			while (leftIdx <= rightIdx && !isValid(s.charAt(rightIdx))) {
+				rightIdx--;
+			}
+
+			if (!isSameChar(s.charAt(leftIdx), s.charAt(rightIdx))) {
+				return false;
+			}
+			rightIdx-- ;
+		}
+
+		return true;
+	}
+
+	private boolean isValid(char c) {
+		return 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9';
+	}
+
+	private boolean isSameChar(char a, char b) {
+		return Character.toLowerCase(a) == Character.toLowerCase(b);
+	}
+}