leetCode解题报告5道题(九)

题目一：Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,

If n = 4 and k = 2, a solution is:

[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

分析：

题意给我们一个数字n, 和一个数字k,让我们求出从 1~~n中取出k个数所能得到的组合数

所以这个题目给我们的第一感觉就是用递归是最方便的了，咱试试递归的方法哈。假设读者对递归方法有疑问，能够看看我之前总结的一个递归算法的集合。

本文专注于<递归算法和分治思想>

AC代码：

public class Solution {
//终于结果
private ArrayList<ArrayList<Integer>> arrays = new ArrayList<ArrayList<Integer>>();

public ArrayList<ArrayList<Integer>> combine(int n, int k) {
//把组合设想成仅仅能升序的话，能做开头的数字仅仅有 1 ~ n-k+1
for (int i=1; i<=n-k+1; ++i){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(i);
cal(list, i+1, n, k-1); //递归
}
return arrays;
}
public void cal(ArrayList<Integer> list, int start, int end, int k){
//k==0表示这次list组合满足条件了
if (k == 0){
//copy
ArrayList<Integer> result = new ArrayList<Integer>(list);
arrays.add(result);
}
//循环递归调用
for (int i=start; i<=end; ++i){
list.add(i);
cal(list, i+1, end, k-1);
list.remove(list.size()-1);
}
}
}

题目二：Search a 2D Matrix

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.

For example,

Consider the following matrix:

[
[1,   3,  5,  7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]

Given target =

3

, return

true

.

分析：这道题目是剑指Offer上的老题目咯，可是解题的思路挺巧妙。本来不想把这题写在博文里的，后来想想或许有些同学没看过剑指Offer, 后续由于这题而去看下这本挺不错的书哈，于是把这题写在博文里了。并附上剑指offer的下载地址（http://download.csdn.net/detail/u011133213/7268315），这题便不做具体介绍。

AC代码：（复杂度O（m+n））

public class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length;
int n = matrix[0].length;
int row = 0;
int col = n - 1;
while (m > row && col >= 0){
if (target == matrix[row][col]){
return true;
}
if (target > matrix[row][col]){
row++;//往下一行搜索
}else if (target < matrix[row][col]){
col--;//往左一列搜索
}
}
return false;
}
}

题目三：Scramble String

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 =

"great"

:

great
/    \
gr    eat
/ \    /  \
g   r  e   at
/ \
a   t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node

"gr"

and swap its two children, it
produces a scrambled string

"rgeat"

.

rgeat
/    \
rg    eat
/ \    /  \
r   g  e   at
/ \
a   t

We say that

"rgeat"

is a scrambled string of

"great"

.

Similarly, if we continue to swap the children of nodes

"eat"

and

"at"

,
it produces a scrambled string

"rgtae"

.

rgtae
/    \
rg    tae
/ \    /  \
r   g  ta  e
/ \
t   a

We say that

"rgtae"

is a scrambled string of

"great"

.

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

分析：

这道题目的题意相信大家应该都看得懂，仅仅是做起来的话有些蛋疼.

我一開始用暴力法TLE，之后用DP才干够的.

详细看代码：

暴力法TLE：

public class Solution {
public boolean isScramble(String s1, String s2) {

if (s1 == null || s2 == null)
return false;
if (s1.equals(s2))
return true;
int len1 = s1.length();
int len2 = s2.length();
if (len1 != len2)
return false;
int[] hash = new int[26];
for (int i=0; i<len1; ++i){
hash[s1.charAt(i) - 'a']++;
}
for (int i=0; i<len2; ++i){
hash[s2.charAt(i) - 'a']--;
}
for (int i=0; i<26; ++i){
if (hash[i] != 0)
return false;
}

for (int i=1; i<len1; ++i){
boolean flags1 = (isScramble(s1.substring(0,i), s2.substring(0,i)) && isScramble(s1.substring(i,len1), s2.substring(i,len2)));
boolean flags2 = (isScramble(s1.substring(0,i), s2.substring(len2-i,len2)) && isScramble(s1.substring(i,len1), s2.substring(0,len2-i)));
if (flags1 && flags2){
return true;
}
}
return false;
}
}

DP动态规划:

设数组flags[len][len][len]来存储每个状态信息.

如flags[i][j][k] 表示s1字符串的第i个位置開始的k个字符和s2字符串的第j个位置開始的k个字符 是否满足scramble string

满足：flags[i][j][k] == true

不满足: flags[i][j][k] == false

那么题目所要的终于结果的值事实上就相当于是flags[0][0][len]的值了

那么状态转移方程是什么呢?

归纳总结法

假设k==1:

flags[i][j][1] 就相当于 s1的第i个位置起，取1个字符。s2的第j个位置起，取1个字符。那假设要使Scramble String成立的话，那么就仅仅能是这两个字符相等了, s1.charAt(i) == s2.charAt(j)

因此 flags[i][j][1] = s1.charAt(i) == s2.charAt(j);

假设k==2:

flags[i][j][2] 就相当于 s1的第i个位置起，取2个字符。s2的第j个位置起，取2个字符。那假设要使Scramble String成立的话，那么情况有下面两种

一种是flags[i][j][1] && flags[i+1][j+1][1] (就是两个位置的字符都相等 S1="TM" S2="TM")

一种是flags[i][j+1][1] && flags[i+1][j][1] (两个位置的字符刚好对调位置 S1="TM" S2="MT")

假设k==n:

设个变量为x

flags[i][j]
=( (flags[i][j][x] && flags[i+x][j+x][k-x]) [第一种情况]

|| (flags[i][j+k-x][x] && flags[i+x][j][k-x]) ); [另外一种情况]

AC代码：

public class Solution {
public boolean isScramble(String s1, String s2) {

if (s1 == null || s2 == null)
return false;
if (s1.equals(s2))
return true;
int len1 = s1.length();
int len2 = s2.length();
if (len1 != len2)
return false;
int len = len1;
boolean[][][] flags= new boolean[len+1][len+1][len+1];
for (int t=1; t<=len; ++t){
for (int i=0; i<=len-t; ++i){
for (int j=0; j<=len-t; ++j){
if (t == 1){
flags[i][j][t] = (s1.charAt(i) == s2.charAt(j));
}else{
for (int k=1; k<t; ++k){
if (flags[i][j][t] == true){
break;
}else{
if ((flags[i][j][k] && flags[i+k][j+k][t-k])
|| (flags[i][j+t-k][k] && flags[i+k][j][t-k])){
flags[i][j][t] = true;
}
}
}
}
}
}
}
return flags[0][0][len];
}
}

题目四：

Rotate List

Given a list, rotate the list to the right by k places, where k is non-negative.

For example:

Given

1->2->3->4->5->NULL

and k =

2

,

return

4->5->1->2->3->NULL

.

分析：

题意要求我们依据所给出的k值，把从最后一个非空结点向前的k个结点移动到链表的开头，又一次组成一个新的链表之后返回。

这道题目有点像经典的面试题“仅仅遍历一次，怎样找到链表倒数的第K个结点”，採用的是两个指针不一样的起始位置，一个指针从head開始出发，还有一个指针先让它走K步，当第2个指针为Null的时候，则第一个指针所指向的就是倒数第K个的值。

同理：

这里我们用两个指针就能够方便地搞定这个题目了，可是须要注意的是，这道题目

假设K大于了链表长度，比方K=3，Len=2的话，假设K步我们还没走完就碰到了Null结点，那么再从head開始走剩下的。直到K==0；

AC代码：

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) {
*         val = x;
*         next = null;
*     }
* }
*/
public class Solution {
public ListNode rotateRight(ListNode head, int n) {
ListNode firstNode = head;//新链表的第一个结点
ListNode kstepNode = head;//走了k步的指针
ListNode preFirstNode = new ListNode(-1);//新链表第一个结点的前一个结点
ListNode preKstepNode = new ListNode(-1);//k步指针的前一个结点

if (head == null || n == 0){
return head;
}
int k = n;

//先走K步
while (k != 0){
//假设走到链表结束了k还不为0，那么再回到head头结点来继续
if (kstepNode == null){
kstepNode = head;
}
kstepNode = kstepNode.next;
k--;
}
//假设刚好走到链表结束，那么就不用再处理了,当前的链表就满足题意了
if (kstepNode == null){
return firstNode;
}
//处理两个结点同一时候走，知道第二个指针走到Null,则第一个指针是倒数第K个结点
while (kstepNode != null){
preFirstNode = firstNode;
firstNode = firstNode.next;

preKstepNode = kstepNode;
kstepNode = kstepNode.next;
}
preKstepNode.next = head;
preFirstNode.next = null;

return firstNode;
}
}

题目五：Partition List

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,

Given

1->4->3->2->5->2

and x = 3,

return

1->2->2->4->3->5

.

分析：

妈蛋，英文题目看着就是蛋疼，看了好久才理解它的题意：

题目要求我们说给出一个X的值，你要把全部的 小于X的值的结点放在全部大于或等于X的值的前面，关键这里X又等于3，跟题目里面给出的链表中当中一个结点的值一样，迷惑了。

一旦题意明确了，剩下的就好办了，竟然这种话，那我们仅仅须要先找出第一个 “大于或等于X值”的结点，并记录下它的位置。

然后剩下的仅仅要遍历一次链表，把小于X的插入到它的前面，大于或等于X 不变位置（由于我们这里找到的是第一个“大于或等于X值”的结点）。

AC代码：

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) {
*         val = x;
*         next = null;
*     }
* }
*/
public class Solution {
public ListNode partition(ListNode head, int x) {
ListNode firstNode = head;
ListNode preFirstNode = new ListNode(-1);
preFirstNode.next = firstNode;
ListNode tempNode = head;
ListNode pretempNode = new ListNode(-1);
pretempNode.next = tempNode;
ListNode preHead = new ListNode(-1);
preHead.next = head;

int index = 0;
//find the first (>= x)'s node
while (firstNode != null){
if (firstNode.val >= x){
break;
}else{
preFirstNode = firstNode;
firstNode = firstNode.next;
index++;//记录位置
}
}
//假设第一个满足条件的结点是头结点
if (firstNode == head){
preHead = preFirstNode;
}
//取得当前下标,假设在第一个满足条件的结点之前则不处理
int p = 0;
while (tempNode != null){
if (tempNode != firstNode){
//值小于x,而且在第一个满足条件结点之后。
if (tempNode.val < x && p > index){
/*做移动*/
pretempNode.next = tempNode.next;
tempNode.next = preFirstNode.next;
preFirstNode.next = tempNode;
preFirstNode = tempNode;
tempNode = pretempNode.next;
index++;
p++;
continue;
}
}
pretempNode = tempNode;
tempNode = tempNode.next;
p++;
}

return preHead.next;

}
}