leetCode解题报告5道题(七)
题目一：Interleaving String
Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.
For example,
Given:
s1 = "aabcc",
s2 = "dbbca",
When s3 = "aadbbcbcac", return true.
When s3 = "aadbbbaccc", return false.
这道题是一道明显的DP题目，因为在这之前DP类型做得比較少，所以这道题目可能分析得不是那么好，网友们见谅哈！
竟然题目是一个DP动态规划的题目。那么必然有一个状态转移方程式。
假设我们用一个boolean flags[][] 二维数组来存储状态信息
flags[i][j] 表示取S1中的前i个数和取S2中的前j个数
flags[i][j] == true : 表示S3的前(i+j)长度的子串还是满足S1和S2交叉结合的
flags[i][j] == false: 表示不满足
首先我们来讲下直到S3前面(i+j)长度的子串还满足能够由S1和S2交叉构成的
条件是(flags[i][j-1] == true && S2[j-1] == S3[i+j-1] ) || (flags[i-1][j] == true && S1[i-1] == S3[i+j-1] )
最后我们所要的结果就是当S1取S1.length长度，而S2取S2.length长度时。看是否满足。即flags[S1.length][S2.length]是否为true
AC代码：
public class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
int len1 = s1.length();
int len2 = s2.length();
int len3 = s3.length();
//长度不等直接干掉
if (len3 != (len2+len1)){
return false;
}
//状态存储的二维数组
boolean flags[][] = new boolean[len1+1][len2+1];
flags[0][0] = true;
for (int i=1; i<=len1; ++i){
flags[i][0] = flags[i-1][0] && (s1.charAt(i-1) == s3.charAt(i-1));
}
for (int j=1; j<=len2; ++j){
flags[0][j] = flags[0][j-1] && (s2.charAt(j-1) == s3.charAt(j-1));
}
for (int i=1; i<=len1; ++i){
for (int j=1; j<=len2; ++j){
flags[i][j] = ((flags[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1))
|| (flags[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1)));
}
}
return flags[len1][len2];
}
}题目二：Validate Binary Search Tree
Given a binary tree, determine if it is a valid binary search tree (BST).
Assume a BST is defined as follows:
- The left subtree of a node contains only nodes with keys less than the node's key.
- The right subtree of a node contains only nodes with keys greater than the node's key.
- Both the left and right subtrees must also be binary search trees.
confused what "{1,#,2,3}" means? >
read more on how binary tree is serialized on OJ.
分析：
题目要求我们推断一下一棵树，是否满足搜索二叉树的性质:
1、树的左边的全部结点都不能大于根的值
2、树的右边的全部结点都不能小于根的值
这题还是比較简单的递归问题哈。
仅仅是要注意的情况例如以下
10
5 15
null null 6 20
这样的情况是不满足二叉搜索树的性质的。由于数值6在数值10的右側，但6<10这样是不符合定义的。
因此当我们要推断左子树的时候，必须把
左子树中全部结点与root结点的值做比較，假设当中有一个大于root结点的值，那么就不满足题意
右子树中全部结点与root结点的值做比較。假设当中一个小于root结点的值，那么也不满足题意。
AC代码：
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public boolean isValidBST(TreeNode root) {
if (root == null){
return true;
}
if (root.left == null && root.right == null){
return true;
}
return solveValidBST(root.left, true, root.val) && solveValidBST(root.right, false, root.val);
}
/**
* root: 当前结点
* isLeft: 属于根节点的左边还是右边
* compareValue: 根结点的值
*/
public boolean solveValidBST(TreeNode root, boolean isLeft, int compareValue){
if (root == null){
return true;
}
//1: 推断是否满足 左<中<右
boolean flag = true;
if (root.left != null && root.left.val >= root.val){
flag = false;
}
if (root.right != null && root.right.val <= root.val){
flag = false;
}
//2: 推断是否满足全部的左<根 和 全部的右>根
if (isLeft){
if (compareValue <= root.val){
flag = false;
}
}else{
if (compareValue >= root.val){
flag = false;
}
}
boolean leftSubTre = solveValidBST(root.left, isLeft, compareValue);
boolean rightSubTre = solveValidBST(root.right, isLeft, compareValue);
return flag && leftSubTre && rightSubTre;
}
}题目三：
Sqrt(x)
Implement int sqrt(int x).
Compute and return the square root of x.
分析：
题目要求我们计算出一个int类型的数值的开平方的结果(注意：要的结果也是int型。而并不是是double哦。)
我们先来分析下一种错误的解法TLE:
//假设数值x够大，所需的循环次数太多了
for (int i=0; i<=x; ++i){
if (i * i == x){
return i;
}
if (i * i > x){
return i-1;
}
}
因此我们必须想出一种更快的方法,我们将这些数和相应的开方的数写下来,观察一下规律！
这样我们能够发现。数字1所能涵盖x数有3个，数字2能涵盖的x数有5个，数字3能涵盖的x数有7个.........
这样子我们要求一个数x的平方根的int值。仅仅须要用x循环减去3,5,7,9......，并用num记录下当前是数字几了，直到x的值小于等于0，这时候这个num就是我们要得到的结果了。
AC代码：
public class Solution {
public int sqrt(int x) {
if (x == 0)
return 0;
int step = 3;
int num = 1;
x = x - step;
while (x > 0){
num++;
step += 2;
x -= step;
}
return num;
}
}
不能由于做题而做题哈，我们顺便看一下返回double类型的sqrt怎么写。
一个採用牛顿迭代法的函数
double sqrt(double number)
{
if(number<=0)return 0;
//设置初始值i，i值越接近sqrt(number)，所需循环次数越少
double i = 1; //一个高速算法是：int exp;double i=ldexp(frexp(number,&exp),(exp>>1));
double j = number/i;
while((i<j?j-i:i-j)>1e-9)//随着循环次数的添加，i与j将很接近
{
i = (i+j)/2;
j = number/i ;
}
return i;
}
原理见：
泰勒级数展开法：f(x)=sqrt(x)在x=1处展开，得：
f(x) = 1+(1/2)×(x-1)+(0.5)×(-0.5)/2!×(x-1)²+(0.5)×(-0.5)×(-1.5)/3!×(x-1)³……
很不建议使用级数展开，由于当数字比較大时收敛实在慢
题目四：
Recover Binary Search Tree
Two elements of a binary search tree (BST) are swapped by mistake.
Recover the tree without changing its structure.
Note:A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?
confused what "{1,#,2,3}" means? >
read more on how binary tree is serialized on OJ.
分析：
题目给我们一棵树，这棵树中有两个结点的位置出现了错误（将它们两个的值交换之后就行得到正确的二叉搜索树）。让我们把这两个结点找出来，之后把它们交换得到正确的BST。要求不可以改变树原来的结构。
这道题目，我们分析下二叉搜索树的性质。能够知道，当我们用树的"中序遍历"遍历这棵树的时候。我们应该要得到一个呈增长的一个数列，可是假设这棵树有两个结点的值的位置不正确的话，必然就会破坏这个增长数列。
举个样例
2
1 4
我们得到的中序遍历结果是: 1 -> 2 -> 4 （增长的趋势）
而假设是
2
4 1
我们得到的中序遍历结果是: 4 -> 2 -> 1 (没有呈增长趋势)
这样子我们须要调换的两个位置是哪两个呢，非常明显应该是 4 和 1的位置。
依据这样分析，我们用一个stack来存储中序遍历的结果。最后依次从栈顶往下扫。当遇到值大于栈顶的。表示不满足增长的规律，然后再一直往下直到找到这些大于栈顶的这些数中。最大的一个。
即为我们要交换的数，详细看代码
AC代码：
/**
* 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 HashMap<Integer, TreeNode> map = new HashMap<Integer, TreeNode>();
//栈：存放中序遍历的结果
private Stack<Integer> stack = new Stack<Integer>();
public void recoverTree(TreeNode root) {
if (root == null || ((root.left == null) && (root.right == null))){
return ;
}
MiddleOrderTralTree(root);
int popNum = 0;
if (!stack.empty()){
popNum = stack.pop();
}
while (!stack.empty()){
int nowNum = stack.pop();
//存在了违反“增长趋势"的情况了.
if (nowNum > popNum){
//栈的元素一直往下找，直到找到违反“增长趋势”的元素中最大的那一个
while (!stack.empty()){
int temp = stack.pop();
if (temp > popNum){
nowNum = temp;
}else{
break;
}
}
TreeNode mistakeOne = (TreeNode)map.get(nowNum);
TreeNode mistakeTwo = (TreeNode)map.get(popNum);
int temp = mistakeOne.val;
mistakeOne.val = mistakeTwo.val;
mistakeTwo.val = temp;
return ;
}
popNum = nowNum;
}
}
//中序遍历
public void MiddleOrderTralTree(TreeNode root){
if (root.left != null){
MiddleOrderTralTree(root.left);
}
//值放入栈中，并把 值。Object 存放到map中
stack.push(root.val);
map.put(root.val, root);
if (root.right != null){
MiddleOrderTralTree(root.right);
}
}
}
题目五：
Climbing Stairs
You are climbing a stair case. It takes n steps to reach to the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
分析:
这个题目是非常早的一个题目了，考察的事实上就是斐波拉切数列的变形哈.
我们知道斐波那契数列的话是
f(0) = 0;
f(1) = 1;
f(n) = f(n-1) + f(n-2) (n >= 2)
我们分析下我们这道题目：
假设N=0时，自然为0种
假设N=1时，这个家伙仅仅有一种爬楼梯的方法
假设N=2时，他的选择有：1.一步步的爬 2.两步的 这样就有两种
但N=3时，他的选择能够是 1、先爬1步(然后剩下的处理跟两个台阶的一样咯) 2、先爬2步(剩下的处理跟一个台阶的一样咯)
.......
我们能够推导出这种式子
f(0) = 0;
f(1) = 1;
f(2) = 2;
f(n) = f(n-1) + f(n-2); (n>=3)
AC代码： （千万别想着用递归的方法。会TLE）
public class Solution {
private int nums[];
public int climbStairs(int n) {
if (n == 0 || n == 1 || n == 2){
return n;
}
nums = new int[n+1];
nums[0] = 0;
nums[1] = 1;
nums[2] = 2;
for (int i=3; i<=n; ++i){
nums[i] = nums[i-1] + nums[i-2];
}
return nums[n];
}
}posted on 2017-07-16 11:59 yjbjingcha 阅读(119) 评论(0) 编辑 收藏 举报
