leetcode-month2-week8

Path Sum

package ygy.test.week8;

import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by guoyao on 2017/10/20.
 */
public class PathSum {

    public static void main(String[] args) {
        TreeNode treeNode1=new TreeNode(1);
        TreeNode treeNode2=new TreeNode(-2);
        TreeNode treeNode3=new TreeNode(-3);
        TreeNode treeNode4=new TreeNode(1);
        TreeNode treeNode5=new TreeNode(3);
        TreeNode treeNode6=new TreeNode(-2);
        TreeNode treeNode7=new TreeNode(-1);
        treeNode1.left=treeNode2;
        treeNode1.right=treeNode3;
        treeNode2.left= treeNode4;
        treeNode2.right=treeNode5;
        treeNode3.left=treeNode6;
        treeNode4.left=treeNode7;
        System.out.println(hasPathSum(treeNode1,2));
    }

    /**
     * Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

     For example:
     Given the below binary tree and sum = 22,
              5
            / \
           4   8
         /    / \
      11    13   4
      /  \       \
     7    2       1
     return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
     */

    public static boolean hasPathSum(TreeNode root, int sum) {

        if(root == null ) return false;
        Queue<TreeNode> knowQueue=new LinkedList<>();

        knowQueue.add(root);
        while (!knowQueue.isEmpty()) {
            TreeNode existNode=knowQueue.poll();
            int path = existNode.val;
            if (existNode.left != null) {
                existNode.left.val+=path;
                knowQueue.add(existNode.left);
            }
            if (existNode.right != null) {
                existNode.right.val+=path;
                knowQueue.add(existNode.right);
            }

            if (existNode.left == null && existNode.right == null && existNode.val == sum ) {
                return true ;
            }
        }
        return false;
    }
}

Minimum Depth of Binary Tree

package ygy.test.week8;

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;

/**
 * Created by guoyao on 2017/10/20.
 */
public class MinimumDepthofBinaryTree {

    public static void main(String[] args) {


    }


    /**
     * Given a binary tree, find its minimum depth.
     * <p>
     * The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
     */
    //bfs
    public static int minDepth(TreeNode root) {

        if (root == null) {
            return 0;
        }

        PriorityQueue<TreeNode> minPriority=new PriorityQueue<>(
                (x, y) -> x.val > y.val ? 1 : -1
        );
        Queue<TreeNode> knowQueue=new LinkedList<>();

        root.val=1;
        knowQueue.add(root);
        while (!knowQueue.isEmpty()) {
            TreeNode existNode=knowQueue.poll();
            int deep=existNode.val;
            if (existNode.left != null) {
                existNode.left.val=deep + 1;
                knowQueue.add(existNode.left);
            }

            if (existNode.right != null) {
                existNode.right.val=deep + 1;
                knowQueue.add(existNode.right);
            }

            if (existNode.left == null && existNode.right == null) {
                minPriority.add(existNode);
            }
        }
        return minPriority.poll().val;
    }

}

/**
 * Definition for a binary tree node.
 */


class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val=x;
    }
}

Best Time to Buy and Sell Stock

package ygy.test.week8;

/**
 * Created by guoyao on 2017/10/22.
 */
public class BestTimetoBuyandSellStock {

    public static void main(String[] args) {

    }

    /**
     * Say you have an array for which the ith element is the price of a given stock on day i.

     If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
     Input: [7, 1, 5, 3, 6, 4]
     Output: 5

     max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)

     Input: [7, 6, 4, 3, 1]
     Output: 0

     In this case, no transaction is done, i.e. max profit = 0.
     */


    public static int maxProfit(int[] prices) {
        if(prices == null || prices.length == 0 ) return  0 ;

        int maxProfit = 0 ;
        int sellPrice=prices[0];
        for(int i = 1 ; i < prices.length ; i++) {
            if (prices[i] > sellPrice) maxProfit=Math.max(maxProfit, prices[i] - sellPrice);
            else sellPrice=prices[i];
        }

        return maxProfit;
    }
}

Pascal Triangle

package ygy.test.week8;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by guoyao on 2017/10/22.
 */
public class PascalTriangle {


    public static void main(String[] args) {

        System.out.println(generate(3));

    }


    /**
     * Given numRows, generate the first numRows of Pascal's triangle.
     For example, given numRows = 5,
     Return
     [
            [1],
           [1,1],
          [1,2,1],
         [1,3,3,1],
        [1,4,6,4,1]
     ]
     */

    public static List<List<Integer>> generate(int numRows) {

        List<List<Integer>> resultList=new ArrayList<>();
        if( numRows <0) return resultList;
        List<Integer> rows=null ;
        for(int i = 0 ; i <numRows ; i ++) {
            rows=new ArrayList<>();
            for(int j =0 ; j <=i ;j ++) {
                if (j == 0 || j == i)
                    rows.add(1);
                else
                    rows.add(resultList.get(i - 1).get(j - 1) + resultList.get(i - 1).get(j));
            }
            resultList.add(rows);
        }
        return resultList;
    }
}