Remove Invalid Parentheses(javascript)

网上都是BFS DFS算法实现，未参考任何资料自己实现的，代码比较臃肿，不过效率还是可以的。

里面有实现从n个人中选出m个人 并打印出每一种选法的算法

/**
 * @param {string} s
 * @return {string[]} 
 * ())) ()))
 */
var removeInvalidParentheses = function(s) {
    var left=[];
    var right=[];
    var leftError=[];
    var rightError=[];

    var leftTemp=[];
    var rightTemp=[];

    for(var i=0;i<s.length;i++){
        if(s[i]=="("){
            leftTemp.push(i);
        }else if(s[i]==")"){
            if(leftTemp.length==0){
               rightError.push(i); 
            }else{
               leftTemp.pop(); 
            }
            right.push(i);
        }
    }

    for(var i=s.length-1;i>=0;i--){
        if(s[i]==")"){
            rightTemp.push(i);
        }else if(s[i]=="("){
            if(rightTemp.length==0){
                leftError.push(i);
            }else{
                rightTemp.pop();
            }
             left.push(i);
        }
    }
//多加一个判断函数
 function isPerfect(s){
     var flag=true;
     var leftTemp=[];
     var rightTemp=[]

   for(var i=0;i<s.length;i++){
        if(s[i]=="("){
            leftTemp.push(i);
        }else if(s[i]==")"){
            if(leftTemp.length==0){
               flag=false; 
               break;
            }else{
               leftTemp.pop(); 
            }
        }
    }

    if(flag==false) return flag;

    for(var i=s.length-1;i>=0;i--){
        if(s[i]==")"){
            rightTemp.push(i);
        }else if(s[i]=="("){
            if(rightTemp.length==0){
               flag=false; 
               break;
            }else{
                rightTemp.pop();
            }
        }
    }

     return flag;

 }

//可能性有  right中找到value= rightError[rightError.length-1] 的多少种任意取rightError.length个
//乘以    left中找到value= leftError[leftError.length-1] 的多少种任意取leftError.length个
//然后去重
//xAry 中取y个东西的方法

function getAll(xAry,y){
    if(xAry=="") return [""];
    var count=0;
    var ary=[];
    function get(x,y,tempAry){

        if(x.length<y) return;
        if(tempAry==undefined){
         var tempAry=[];
        }else{
            var tempAry=tempAry.slice(0);
        }

      if(y==1){
          for(var i=0;i<x.length;i++){
            tempAry.push(x[i]);
            ary.push(tempAry);
            count++;
            tempAry=tempAry.slice(0,tempAry.length-1);
           }
          return;
        }

     for(var i=0;i<x.length;i++){
        tempAry.push(x[i]);
        get(x.slice(i+1),y-1,tempAry);
        tempAry=tempAry.slice(0,tempAry.length-1);
       } 
     }
     get(xAry,y);
     return ary;
}

//继续流程 先截取left和right

   for(var i=0;i<left.length;i++){
       if(left[i]==leftError[leftError.length-1]){
           break;
       }
   }
   left=left.slice(0,i+1);

   for(var i=0;i<right.length;i++){
      if(right[i]==rightError[rightError.length-1]){
           break;
       }
   }
   right=right.slice(0,i+1);

//得到所有需要删除的情况(其中包含一些不合法的删除，最后再过滤一下)
 var aryLeft = getAll(left,leftError.length);
 var aryRight= getAll(right,rightError.length);

//融合 aryLeft和aryRight
 var aryLeftAndRight=[];
 if(aryLeft.length==0||aryRight.length==0){
     if(aryLeft.length==0){
         aryLeftAndRight=aryRight;
     }else{
         aryLeftAndRight=aryLeft;
     }
 }else{
    for(i=0;i<aryLeft.length;i++){
        for(j=0;j<aryRight.length;j++){
           aryLeftAndRight.push(aryLeft[i].concat(aryRight[j]));
       }
   }

  }

  //使用对象 省去去重这一步
  var obj={};
  var objName;
  var tempAry;
  if(aryLeftAndRight.length!=0){
    for(var i=0;i<aryLeftAndRight.length;i++){
      tempAry=s.split("");
      for(j=0;j<aryLeftAndRight[i].length;j++){
          tempAry[aryLeftAndRight[i][j]]=undefined;
      }
      objName=tempAry.filter(function(item){
          return item!=undefined;
      }).join("");
      obj[objName]=1;
    }
  }else{
      obj[s]=1;
  }
//最后一道过滤  过滤()))())) 变成  ())(  这种不合法的情况  
  var result=[];
  for(var name in obj){
      if(isPerfect(name)){
      result.push(name);
      }
  }

 //console.log(aryLeft,aryRight,aryLeftAndRight);
 //console.log(result);
 return result;

};