/**
 * 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 Solution {
    
    TreeNode result = null;
    
    public TreeNode searchBST(TreeNode root, int val) {        
        inorder(root, val);
        return result;
    }  
    
    public void inorder(TreeNode node, int target) {
		if(node != null) {
			inorder(node.left, target);
			if(node.val == target) {
                		result = node;
            		}
			inorder(node.right, target);
		}
	}
}

 

 

/**
 * 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 Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        TreeNode result = null;
        
        if(root.val == val) {
            return root;
        }
        
        if(root.val > val && root.left != null) {
            result = searchBST(root.left, val);
        }else if (root.val < val && root.right != null){
            result = searchBST(root.right, val);
        }
        return result;
    }
}

 

1) 주어진 BST를 inorder로 순회하여 ArrayList에 넣는다.

2) next()는 ArrayList의 인덱스 0 에 있는 데이터를 반환하고 삭제한다.

3) hasNext()는 ArrayList가 비어있다면 전부 next()해서 가져간 것이므로, false를 반환한다.

/**
 * 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 BSTIterator {
    
    List<Integer> list = new ArrayList<Integer>();	

    public BSTIterator(TreeNode root) {
		inorder(root);        
    }
    	
	public void inorder(TreeNode node) {
		if(node != null) {
			inorder(node.left);
			list.add(node.val);
			inorder(node.right);
		}
	}
    
    public int next() {
    	int nextVal = list.get(0);
    	list.remove(0);
        return nextVal;
    }
    
    public boolean hasNext() {
    	if(!list.isEmpty())
    		return true;
    	else
    		return false;
    }
}

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator obj = new BSTIterator(root);
 * int param_1 = obj.next();
 * boolean param_2 = obj.hasNext();
 */

/**
 * 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 Solution {
    
    List<Integer> list = new ArrayList<Integer>();
    
    public boolean isValidBST(TreeNode root) {
        inorder(root);
        for (int i = 0; i < list.size() - 1; i++) {
			if(list.get(i) >= list.get(i+1))
				return false;
		}
        return true;
    }
    
    public void inorder(TreeNode node) {
		if(node != null) {
			inorder(node.left);			
			list.add(node.val);
			inorder(node.right);
		}
	}
    
}

 

- 처음에는 DFS로 하려고 했는데, val을 비교하는 과정이 복잡해져서, inorder 순회해서 list에 넣었음

- inorder로 순회하며 list에 val을 넣으면 valid한 B-Tree라면 list에 val이 오름차순으로 들어있을 것임 => 오름차순인지 검사해서 맞으면 true, 아니면 false

 

- inorder : 왼쪽 > 루트 > 오른쪽

- preorder : 루트 > 왼쪽 > 오른쪽

- postorder : 왼쪽 > 오른쪽 > 루트

 

B-Tree 순회방법 참고 => https://youtu.be/QN1rZYX6QaA

 

1. Two Pointer로 풀기

- 배열은 non-decreasing order임

if => 더한게 같으면 끝

else if => 제일 작은 수와 제일 큰 수를 더했는데 큼 => 다음 큰 수

else => 제일 작은 수와 제일 큰 수를 더했는데 작음 => 다음 작은 수

int[] result = new int[2];
        int i = 0;
        int j = numbers.length - 1;
        
        while(i < j) {            
            if(numbers[i] + numbers[j] == target){	// 같으면 끝
                result[0] = i + 1;
                result[1] = j + 1;
                break;
            } else if(numbers[i] + numbers[j] > target){
                j--;
            } else{
                i++;
            }
        }
        return result;

 

2. HashMap으로 풀기

- HashMap의 containsKey는 O(1)

- key는 중복 불가능

- 자기 자신은 제외시키기 => if(map.get(remain) != i)

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] result = new int[2];
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        
        for(int i = 0; i < numbers.length; i++) {
            map.put(numbers[i], i);
        }
        
        for(int i = 0; i < numbers.length; i++) {
            int remain = target - numbers[i];
            if(map.containsKey(remain)) {
                if(map.get(remain) != i){                    
                    result[0] = i + 1;
                    result[1] = map.get(remain) + 1;
                    break;
                }
            }
        }
        return result;
    }
}

 

배열을 오름차순으로 정렬하고, 2개씩 그룹을 만들면 각 그룹의 첫 번째 요소가 그룹에서 작은 값이 되므로, 2개씩 건너뛰면서 합계를 구하면 max합계임

6,2,6,5,1,2 => 1,2,2,5,6,6

class Solution {
    public int arrayPairSum(int[] nums) {
        Arrays.sort(nums);        
        int maxSum = 0;        
        
        for(int i = 0; i < nums.length; i+=2){            
            int sum = nums[i];            
            maxSum += sum;
        }
        return maxSum;
    }
}

'JAVA > leetcode' 카테고리의 다른 글

[LeetCode Medium] BST - Validate Binary Search Tree !!  (0) 2021.08.10
[LeetCode] Two Sum II - Two Pointer  (0) 2021.08.09
[LeetCode] Reverse String - Two-pointer  (0) 2021.08.09
[LeetCode] Pascal's Triangle  (0) 2021.08.08
[LeetCode] Two Sum  (0) 2021.08.07

class Solution {
    public void reverseString(char[] s) {
        int i = 0;
        int j = s.length - 1;        
        
        while(i < j) {
            char tmp = s[j];
            s[j] = s[i];
            s[i] = tmp;
            i++;
            j--;            
        }
    }
}

'JAVA > leetcode' 카테고리의 다른 글

[LeetCode] Two Sum II - Two Pointer  (0) 2021.08.09
[LeetCode] Array Partition I  (0) 2021.08.09
[LeetCode] Pascal's Triangle  (0) 2021.08.08
[LeetCode] Two Sum  (0) 2021.08.07
[LeetCode Medium] Spiral Matrix !! - BFS  (0) 2021.08.06

문제

1234 -> 4321

 

조건

String으로 변환하지 않고 해결

 

public static int solution(int num) {
        int input = num;
        int result = 0;
        
        while(input > 0) {
            int remain = input % 10;
            result = result * 10 + remain;
            input = input / 10;
        }
        return result;
    }

 


public static int solution(int num) {
	String s = String.valueOf(num);
    	StringBuilder sb = new StringBuilder(s);
	sb = sb.reverse();
	int result = Integer.parseInt(sb.toString());        
	return result;
}
public static int reverse(int num) {
        int input = num;
        StringBuilder sb = new StringBuilder();
        while(input > 0) {
            int remain = input % 10;
            sb.append(remain);
            input /= 10;
        }
        return Integer.parseInt(sb.toString());
   }

'JAVA > alg' 카테고리의 다른 글

[DFS] Flood Fill  (0) 2021.08.07
[BFS] 최단 경로 찾기  (0) 2021.08.07

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        
        for (int i = 0; i < numRows; i++) {
			List<Integer> rowList = new ArrayList<Integer>();	// 각 row용 List
			for (int j = 0; j <= i; j++) {
				if(j == 0 || j == i) {	// 양 끝이면 1
					rowList.add(1);
					continue;
				}else {	// 위에서 더한값 가져오기
					int num = list.get(i-1).get(j-1) + list.get(i-1).get(j);
					rowList.add(num);
				}
			}
			list.add(rowList);	// 결과에 추가
		}
        
        return list;
    }
}

'JAVA > leetcode' 카테고리의 다른 글

[LeetCode] Array Partition I  (0) 2021.08.09
[LeetCode] Reverse String - Two-pointer  (0) 2021.08.09
[LeetCode] Two Sum  (0) 2021.08.07
[LeetCode Medium] Spiral Matrix !! - BFS  (0) 2021.08.06
[LeetCode] Array - Plus One  (0) 2021.08.06

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
		 Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		 int[] result = new int[2];
		 int rest = 0;
		 
		 for (int i = 0; i < nums.length; i++) {
			map.put(nums[i], i);			
		 }		
			 		
		for (int i = 0; i < nums.length; i++) {
			rest = target - nums[i];	
			if(map.containsKey(rest)) {
				result[0] = i;
				if(map.get(rest) != i)
					result[1] = map.get(rest);
				else
					continue;
				
				break;
			}
		}		
		return result;
    }
}

가능한 영역에 3으로 색칠하기

 

 

 

 

 

 

 

import java.util.*;

public class Main {	
	
	// 이동방향
	static int[][] D = {
			{0,1},
			{0,-1},
			{1,0},
			{-1,0}
	};
	
	// MAP
	static int[][] matrix = {
		{0,0,0,0,0},
		{0,0,0,1,1},
		{0,0,0,1,0},
		{1,1,1,1,0},
		{0,0,0,0,0}
	};

	public static void main(String[] args) {				
		
		Scanner sc = new Scanner(System.in);
		// 출발지
		int sRow = sc.nextInt();
		int sCol = sc.nextInt();
		
		// 색칠할 숫자
		int c = sc.nextInt();
		
		dfs(sRow, sCol, c);
		
		// 출력
		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix.length; j++) {
				System.out.print(matrix[i][j] + " ");
			}
			System.out.println();
		}
	}
	
	public static void dfs(int sRow, int sCol, int c) {
		int m = matrix.length;
		int n = matrix[0].length;
		boolean[][] visit = new boolean[m][n];	// 방문 기록
		Stack<Node> stack = new Stack<Node>();	// DFS는 stack사용
		
		stack.add(new Node(sRow, sCol));		
		
		while(!stack.isEmpty()) {
			Node node = stack.pop();	// 꺼내서 확인
			int row = node.row;
			int col = node.col;			
			visit[row][col] = true;	// 방문 표시
			
            matrix[row][col] = c;	// 실제 작업 : 색칠하기
			
			for (int i = 0; i < 4; i++) {
				int nRow = row + D[i][0];
				int nCol = col + D[i][1];
				if(nRow < 0 || nRow >= m || nCol < 0 || nCol >= n)
					continue;
				if(visit[nRow][nCol])
					continue;
				if(matrix[nRow][nCol] == 1)
					continue;
				stack.push(new Node(nRow, nCol));
			}
			
		}
		
    }
	
	// Node 클래스
	static class Node {
		int row;
		int col;
		
		public Node(int row, int col) {
			this.row = row;
			this.col = col;		
		}
		
	}
		
}

 

 

결과

 

DFS 참고 = >https://youtu.be/0Njv04WiLV0

 

'JAVA > alg' 카테고리의 다른 글

숫자 뒤집기 (String 변환 X)  (0) 2021.08.09
[BFS] 최단 경로 찾기  (0) 2021.08.07