Leetcode: Container With Most Water

Given n non-negative integers a1, a2, …, an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

Note: You may not slant the container.

    public int maxArea(int[] height) {
        int maxArea = 0;
        int left = 0;
        int right = height.length - 1;
        while (left < right) {
            maxArea = Math.max(maxArea, calculateArea(height, left, right));
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }
        return maxArea;
    }

    public int calculateArea(int[] height, int left, int right) {
        return Math.abs(right - left) * Math.min(height[left], height[right]);
    }

Note:

For any container, its volume depends on the shortest board.

Two-pointer scan. And always move with shorter board index.

FacebookTwitterGoogle+Share

Leetcode: Rotate Image

You are given an n x n 2D matrix representing an image.

Rotate the image by 90 degrees (clockwise).

Follow up:
Could you do this in-place?

public class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        if (n <= 1 || matrix.length <= 1 || n != matrix.length) {
            return;
        }
        int mid = (n - 1) / 2;
        int offset = 0;
        while (offset <= mid) {
            for (int i = offset; i < n - 1 - offset; i++) {
                int tmp = matrix[offset][i];
                matrix[offset][i] = matrix[n - 1 - i][offset];
                matrix[n - 1 - i][offset] = matrix[n - 1 - offset][n - 1 - i];
                matrix[n - 1 - offset][n - 1 - i] = matrix[i][n - 1 - offset];
                matrix[i][n - 1 - offset] = tmp;
            }
            offset++;
        }

    }
}

Leetcode: Generate Parentheses

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

"((()))", "(()())", "(())()", "()(())", "()()()"

public class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> result = new ArrayList<String>();
        if(n>0){
            generateParenthesis("", n, n, result);
        }
        return result;
    }
   
    public void generateParenthesis(String prefix, int left, int right, List<String> result){
        if(left>right){
            return;
        }
        if(left==0){
             for(int i=0;i<right;i++){
                 prefix+=")";
             }
             result.add(prefix);
             return;
        }
        if(left<right){
            generateParenthesis(prefix+")", left, right-1, result);
        }
        generateParenthesis(prefix+"(", left-1, right, result);    
    }
}

Note: The key point of this problem is when generating parentheses, the number of left parentheses being used so far is always larger than the number of right parentheses. In the algorithm. left and right means # of parentheses not being used so far.