leetCode解题报告5道题(五)

题目一：

Path Sum

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.
分析：题意为给你一个数sum，求是否有从root结点到某个叶子结点的和等于数sum的路径，如果有的话，返回true,否则返回false;
AC代码：

/**
* Definition for binary tree
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
/*如果root == null直接返回false*/
if (root == null){
return false;
}
/*sum 减去当前root的值*/
sum -= root.val;
/*如果已经到了叶子结点，判断sum是否已经减到了0*/
if (root.left == null && root.right == null && sum == 0){
return true;
}
/*flag的话，要判断左右子树是否有路径可以满足，即为

*/
boolean flag = hasPathSum(root.left, sum) || hasPathSum(root.right, sum);
return flag;
}
}

Path Sum II

 （姐妹题）

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
For example:
Given the below binary tree and 

sum
= 22

,

5
/ \
4   8
/   / \
11  13  4
/  \    / \
7    2  5   1

return

[
[5,4,11,2],
[5,8,4,5]
]

分析：无情递归就OK了，递归结束的条件：当是叶子结点并且sum的值已经变成了0，这时候的List为一组有效的解，加入到结果集合result中。

/**
* Definition for binary tree
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
/**
* CSDN: 胖虎 http://blog.csdn.net/ljphhj */
public class Solution {
private ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();

public ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int sum) {
if (root == null){
return result;
}

calPath(root, sum, new ArrayList<Integer>());
return result;
}

public void calPath(TreeNode root, int sum, ArrayList<Integer> list){
sum -= root.val;
list.add(root.val); //当前值加入“可能的解”集合list中
/*如果为叶子结点了，那么就判断是否sum已经等于0了，如果等于0则为一个有效解*/
if (root.left == null && root.right == null && sum == 0){
result.add(list);
return ;
}
/*如果不是叶子结点，则继续往左右子树找*/
if (root.left != null){
calPath(root.left, sum, new ArrayList<Integer>(list));
}
if (root.right != null){
calPath(root.right, sum, new ArrayList<Integer>(list));
}
}
}

题目二：

Merge Sorted Array

Given two sorted integer arrays A and B, merge B into A as one sorted array.

Note:

You may assume that A has enough space (size that is greater or equal to m + n) to hold additional elements from B. The number of elements initialized in A and B are m andn respectively.
分析：给我们A数组（长度：m）和B数组(长度: n)，A数组足够大，有m+n的空间，那么我们采用从尾向前的方法往A数组中添加值，这样复杂度O(m+n)
AC代码：

public class Solution {
public void merge(int A[], int m, int B[], int n) {
if (m == 0){
for (int i=0; i<n; ++i){
A[i] = B[i];
}
return ;
}
if (n == 0){
return ;
}

int pA = m-1;
int pB = n-1;
int pIndex = m+n-1;
/*从尾向前添加数字*/
while (pA >= 0 && pB >= 0){
if (B[pB] > A[pA]){
A[pIndex--] = B[pB--];
}else{
A[pIndex--] = A[pA--];
}
}
/*pA>=0不处理，因为本来就在A数组中*/
/*如果循环结束了，pB>=0则表示B数组还有值没加入到A数组中*/
while (pB >= 0){
A[pIndex--] = B[pB--];
}
}
}

题目三：

Symmetric Tree(对称树)

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree is symmetric:

1
/ \
2   2
/ \ / \
3  4 4  3

But the following is not:

1
/ \
2   2
\   \
3    3

分析：题目给我们一个二叉树的结构，让我们去判断这个二叉树是否是对称的。这道题目可以有两种做法，递归(424ms)或者用层次遍历树(524ms)的方法

这个题目的递归很容易就看出来了，我就不详细讲，具体看代码里面的注释理解！

（递归）AC代码（424ms）：

/**
* Definition for binary tree
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
/*判断左右子树是否对称*/
public boolean checkSymmetric(TreeNode lsubTree,TreeNode rsubTree){
/*几种基本情况的排除*/
if(lsubTree==null && rsubTree==null)
return true;
else if(lsubTree!=null && rsubTree==null)
return false;
else if(lsubTree==null && rsubTree!=null)
return false;
else if(lsubTree.val != rsubTree.val)
return false;

/*再递归看下子树是否对称，只有子树也对称了才可以*/
boolean lt=checkSymmetric(lsubTree.left, rsubTree.right);
boolean rt=checkSymmetric(lsubTree.right, rsubTree.left);
return lt && rt;
}
/*只要左右子树对称那么整个二叉树就对称了*/
public boolean isSymmetric(TreeNode root) {
if(root==null)
return true;
return checkSymmetric(root.left,root.right);
}
}

（层次遍历）AC代码(524ms):

/**
* Definition for binary tree
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public boolean isSymmetric(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<TreeNode>();
if (root == null)
return true;
/*加入根结点的左右子结点*/
queue.add(root.left);
queue.add(root.right);
/*层次遍历*/
while (queue.size() != 0){
String s = new String("");
ArrayList<TreeNode> list = new ArrayList<TreeNode>();
/*把一层的结点都取出来之后放入list集合*/
while (queue.size() != 0){
TreeNode node = queue.remove();
list.add(node);
}
/*把这一层的结点对应的值转换成字符串*/
for (int i=0;i<list.size(); ++i){
TreeNode node = (TreeNode)list.get(i);
if (!s.equals("")){
s += " ";
}
if (node != null)
s += node.val;
else
s += "Null";
if (node != null){
queue.add(node.left);
queue.add(node.right);
}
}
/*判断这一层的结点转换成的字符串是否满足条件，不满足直接return*/
if (!isManZu(s))
return false;
}

return true;
}
/*检测字符串是否满足条件*/
public boolean isManZu(String s){
String[] arrays = s.trim().split(" ");
int len = arrays.length;
if (len % 2 == 1)
return false;
for(int i=0; i<len/2; ++i){
if (!arrays[i].equals(arrays[len-1-i]))
return false;
}
return true;
}
}

题目四：

Flatten Binary Tree to Linked List

 

Given a binary tree, flatten it to a linked list in-place.

For example,

Given

1
/ \
2   5
/ \   \
3   4   6

The flattened tree should look like:

1
\
2
\
3
\
4
\
5
\
6

分析：仔细观察题目给出的例子，不难发现其实这个可以用递归来做，求root结点的flatten tree相当于先求出左子树，再求出右子树，然后将左子树的最后一个结点连接到右子树的第一个结点，将root的右子树连接到左子树的第一个结点上，总而言之这题还是比较简单的，建议做这题的时候可以在纸上画一下图，帮助理解！

情况：

1、root只有左子树

2、root只有右子树

3、root左右子树都有

AC代码：

/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public void flatten(TreeNode root) {
transform(root);
return ;
}
public TreeNode transform(TreeNode root){
if (root == null)
return null;
if (root.left == null && root.right == null)
return root;
TreeNode leftChild = null;
TreeNode rightChild = null;
if (root.left != null){
leftChild = transform(root.left);
}
if (root.right != null){
rightChild = transform(root.right);
}
if (leftChild != null){
leftChild.right = root.right;
root.right = root.left;
root.left = null;
}
if (rightChild != null)
return rightChild;
if (leftChild != null)
return leftChild;
return root;
}
}

题目五：

Distinct Subsequences

 

Given a string S and a string T, count the number of distinct subsequences of T in S.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, 

"ACE"

 is
a subsequence of 

"ABCDE"

 while 

"AEC"

 is
not).

Here is an example:
S = 

"rabbbit"

, T = 

"rabbit"

Return 

3

.
题意：求出字符串T在字符串S中出现的次数，

S字符串:

0 1  2  3  4  5  6

r  a  b  b  b  i   t

T字符串:

0 1  2  3  4   5 

r  a  b  b  i   t

出现的最大次数是3，三种情况分别为：

S: 0 1 2 3 5 6

S: 0 1 2 4 5 6

S: 0 1 3 4 5 6

这样子，我们很容易知道这其实是一个DP的问题

对应的状态转移方程式

AC代码：

public class Solution {
public int numDistinct(String S, String T) {
int n = S.length();
int m = T.length();
if (m > n)
return 0;
int[][] results = new int[n+1][m+1];
for (int i=0; i<n+1; ++i){
results[i][0] = 0;
}
for (int i=0; i<m+1; ++i){
results[0][i] = 0;
}

for (int i=1; i<n+1; ++i){
for (int j=1; j<m+1; ++j){
results[i][j] = results[i-1][j];
if (S.charAt(i-1) == T.charAt(j-1)){
if (j == 1)
results[i][j] += 1;//j == 1的话表示第一个字符，直接加1
else
results[i][j] += results[i-1][j-1];
}
}
}
return results
[m];
}
}