单词搜索
描述：
给定一个二维网格和一个单词，找出该单词是否存在于网格中。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
代码：
/**
* @param {character[][]} board
* @param {string} word
* @return {boolean}
*/
var exist = function(board, word) {
let l = board.length,
rL = board[0].length,
col = 0,
row = 0,
isUsed={},
start = [],
first = true;
/**
* 以 board[r][c]为中心查找 target
*/
function findIndex( r , c,target,index){
if( first ){
for( let i = r; i < l ; i++){
for( let j = c; j < rL; j++){
if( board[i][j] == target ){
// isUsed[i+'$'+j] =1;
start.push({
row: i,
col:j,
})
}
}
}
first = false;
if( start.length !== 0)
return true
return false;
}
else {
let result = [];
if( c + 1 < rL){
if( !isUsed[ r + '$' + ( c + 1 )] )
if( board[r][c +1] == target ){
result.push({
row: r,
col: c +1
})
}
}
if( c - 1 >= 0 ){
if( !isUsed[ r + '$' + ( c - 1 )] )
if( board[r][c - 1] == target ){
result.push({
row: r,
col: c - 1
})
}
}
if( r + 1 < l){
if( !isUsed[ ( r + 1) + '$' + ( c )] )
if( board[r+1][c] == target ){
result.push({
row: r + 1,
col: c
})
}
}
if( r - 1 >= 0){
if( !isUsed[ ( r - 1) + '$' + ( c )] )
if( board[r-1][c] == target ){
result.push({
row: r - 1,
col: c
})
}
}
if( result.length == 0 )
return false
if( index == (word.length - 1 ) )
return true;
for( let i = 0,l = result.length; i < l; i++){
let row = result[i].row,
col = result[i].col;
isUsed[ row + '$' + col ] = 1;
if( findIndex(row,col,word[++index],index )){
return true
}else{// 查找下一个可能的路径时 原来没用的使用过的格子就是没用过的了，得清除一下。
isUsed[ row + '$' + col ] = 0;
index--;
}
}
}
return false;
}
if( !findIndex( 0 ,0,word[0] ) )// 找入口，结果保存在start里
return false
if( (word.length == 1) && (start.length !== 0 ))// word只有一个字符时的特殊处理
return true;
for( let j = 0; j < start.length; j++ ){
isUsed = {};
isUsed[ start[j]['row'] +'$'+ start[j]['col'] ] = true;
row = start[j]['row'],col = start[j]['col'];
if(findIndex( row ,col,word[1],1 )){
return true;
}
}
return false;
};思路： 就是老实人的算法啦，老老实实找到入口，遍历入口，然后通过递归查找每一条可能的路径，当开始找word里最后一个元素时，如果此时路径集合 result不为空，则证明存在路径，值的一提的是，由于题目描述，一个元素的路径可以在其元素的上下左右四个方位出现，所以需要探索四个方位的路径，由于不能重复使用，所以需要有个标记标记一下，采用递归最好。
2. 水果成篮
在一排树中，第 i 棵树产生 tree[i] 型的水果。
你可以从你选择的任何树开始，然后重复执行以下步骤：把这棵树上的水果放进你的篮子里。如果你做不到，就停下来。
移动到当前树右侧的下一棵树。如果右边没有树，就停下来。
请注意，在选择一颗树后，你没有任何选择：你必须执行步骤 1，然后执行步骤 2，然后返回步骤 1，然后执行步骤 2，依此类推，直至停止。
你有两个篮子，每个篮子可以携带任何数量的水果，但你希望每个篮子只携带一种类型的水果。
用这个程序你能收集的水果总量是多少？
代码：
/**
* @param {number[]} tree
* @return {number}
*/
var totalFruit = function(tree) {
let start= leftBasket = 0, result = [],
l = tree.length,
rightBasket;
for( let i = 1 ; i < l; i++ ){
if( tree[i] !== tree[0] ){
rightBasket = i;
break;
}
}
for( let i = 1 ; i < l; i++ ){
if( (tree[i] !== tree[leftBasket]) && ( tree[i] == tree[rightBasket] ) ){
rightBasket = i;
continue;
}
if( (tree[i] == tree[leftBasket]) && ( tree[i] !== tree[rightBasket] ) ){
leftBasket = i;
continue;
}
if( (tree[i] !== tree[leftBasket]) && ( tree[i] !== tree[rightBasket] ) ){// 结构发生变化时
result.push( start + '$' + ( i - 1) )
for( let j = i -1 ; j >= 0; j--){
if( tree[i-1] == tree[j] ){
leftBasket = j;
}else{
break;
}
}
start = leftBasket;
for( let j = i; j < l; j++){
if( tree[j] !== tree[leftBasket]){
rightBasket = j;
break;
}
}
continue;
}
}
result.push( start + "$" + (l-1) );
let max = -Infinity;
result.forEach( (item) => {
let temp = item.split('$');
if( temp[1] - temp[0] > max ){
max = temp[1] - temp[0];
}
} )
console.log( result )
return max + 1;
};老实说这道题拿到手的时候，我花了好长时间理解题意，最终改题目可以抽象为，寻找此数组中连续的并且只有两个元素类型的最长子数组，所以我采用了 三个指针 start，leftBasket，rightBasket ,然后遍历整个数组，当数组的元素既不和leftBasket相等，也不和rightBasket相等时就更新start，leftBasket，rightBasket 的位置，然后在这个时候计算一下当前子序列的长度就好了，我是采用了把结果保存下来的方法，其实也可以不用保存的。
