[8/9] M19/M22/M24/M31/M33/M34/M36

[8/9] M19/M22/M24/M31/M34

M19. Remove Nth Node From End of List

用时：20 mins

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy =  new ListNode();
        dummy.next = head;
        ListNode first = dummy, second = dummy;
        int firstCount = 0, secondCount = 0;
        while(first.next != null) {
            first = first.next;
            firstCount++;
            if(firstCount >= n+1) {
                second = second.next;
                secondCount++;
            }
        }
        if(second.next != null) {
            ListNode toRemove = second.next;
            second.next = toRemove.next;
        }
        return dummy.next;
    }
}

M22. Generate Parentheses

用时：20 mins

class Solution {
    List<String> res = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        backTracking("", 0, 0, n);
        return res;
    }
    
    public void backTracking(String str, int open, int close, int max){
        if(str.length() == max*2) {
            res.add(str);
            return;
        } 
        if(open<max) {
            backTracking(str+"(", open+1, close, max);
        }
        if(close<open) {
            backTracking(str+")", open, close+1, max);
        }
    }
}

M24. Swap Nodes in Pairs

用时： 15 mins
24. Swap Nodes in Pairs

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null) return head;
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode previous = dummy, next = null;
        ListNode first = head, second = head.next;
        while(first != null && second != null) {
            next = second.next;
            previous.next = second;
            second.next = first;
            first.next = next;
            if (first.next == null || first.next.next == null) break;
            previous = first; 
            first = previous.next;
            second = first.next;
        }
        return dummy.next;
    }
}

M31. Next Permutation

class Solution {
    public void nextPermutation(int[] nums) {
        for (int i = nums.length -2; i>=0; i--) {
            if(nums[i+1] > nums[i]) {
                for(int j = nums.length -1; j>i; j--) {
                    if (nums[j] > nums[i]) {
                        swap(nums, i, j);
                        reverse(nums, i+1);
                        return;
                    }
                }
            }
        }
        reverse(nums, 0);
    }
    
    public void swap(int[] nums, int i, int j) {
        int toSwap = nums[i];
        nums[i] = nums[j];
        nums[j] = toSwap;
    }
    
    public void reverse(int[] nums, int start)
    {
        int i = start, j = nums.length-1;
        while(i<j) {
            swap(nums, i, j);
            i++;
            j--;
        }
    }
}

M33. Search in Rotated Sorted Array

class Solution {
    public int search(int[] nums, int target) {
        int start = 0, end = nums.length -1, mid = 0;
        while (start<=end) {
            mid = start + (end - start)/2;
            if(nums[mid] == target) return mid;
            if (nums[start] <= nums[mid]) {
                if( target <= nums[mid] && target >= nums[start]) {
                    end = mid-1;
                } else {
                    start = mid+1;
                }
            } else {
                if(target <= nums[end] && target >= nums[mid]) {
                    start = mid+1;
                } else {
                    end = mid -1; 
                }
            }
        }
        return -1;
    }
}

M34. Find First and Last Position of Element in Sorted Array

class Solution {
    int[] res = new int[2];
    int rangeStart = -1, rangeEnd = -1;
    public int[] searchRange(int[] nums, int target) {
        int start = 0, end = nums.length -1, mid = 0; 
        recurse(nums, target, start, end);
        res[0] = rangeStart;
        res[1] = rangeEnd;
        return res;
    }
    
    public void recurse(int[] nums, int target, int start, int end) {
        if (start<end) {
            int mid = start + (end -start)/2;
            if(nums[mid] == target) {
                recurse(nums, target, start, mid-1);
                recurse(nums, target, mid + 1, end);
                setValue(mid);
            } else if (target < nums[mid]){
                recurse(nums, target, start, mid-1);
            } else if (target > nums[mid]){
                recurse(nums, target, mid + 1, end);
            }
        } else if(start==end && nums[start] == target) {
            setValue(start);
        }
    }
    
    private void setValue(int val) {
        if(rangeStart != -1) {
            rangeStart = Math.min(val, rangeStart);
        } else {
            rangeStart = val;
        }
        rangeEnd = Math.max(val, rangeEnd);
    }
}

M36. Valid Sudoku

public class Solution {
    public boolean isValidSudoku(char[][] board) {
        HashMap<Integer, Integer> [] rows = new HashMap[9];
        HashMap<Integer, Integer> [] columns = new HashMap[9];
        HashMap<Integer, Integer> [] boxes = new HashMap[9];
        
        for(int i = 0; i<9; i++) {
            rows[i] = new HashMap<Integer, Integer>();
            columns[i] = new HashMap<Integer, Integer>();
            boxes[i] = new HashMap<Integer, Integer>();
        }
        
        for(int i = 0; i<9; i++) {
            for(int j = 0; j<9; j++) {
                char num = board[i][j];
                if (num == '.') continue;
                System.out.println("num:"+num + ":");
                int n = (int)num;
                rows[i].put(n, rows[i].getOrDefault(n, 0) + 1);
                columns[j].put(n, columns[j].getOrDefault(n, 0) + 1);
                System.out.println(":"+n + ":");
                System.out.println(columns[j].get(n));
                
                int boxIndex = (i/3) * 3 + (j/3);
                boxes[boxIndex].put(n, boxes[boxIndex].getOrDefault(n, 0) + 1);
                
                if(rows[i].get(n) >1 || columns[j].get(n) > 1 || boxes[boxIndex].get(n) >1) 
                    return false;
                
            }
        }
        return true;
    }
}