swapLexOrder

给定一个字符串str和字符串对应的可以交换位置的下表数组pairs，求交换之后字典顺序最大的字符串(facebook笔试题).
- 题目可能说的不是很明了，看个例子就很清楚要做什么了
- 给定一个字符串str="abcd"，可交换位置的下表数组为pairs=[[1,4],[3,4]],输出结果应该是swapLexOrder(str,pairs)="dbca"
- pairs=[[1,4],[3,4]]告诉我们可以交换的位置是1和4或者3和4之间，这样可以说1,3,，4之间是可以相互交换位置的，然后据此对字符串操作，"cbda","cbad","dbac","dbca"所以交换之后的指定位置按字典顺序排序后的字符串为”dbca".

• 验证代码(python)

  def swapLexOrder(string, pairs):
      elems = list(string)
      connected = []
      for pair in pairs:
          current_con_ind = -1
          to_delete_ind = []
          for j in range(len(connected)):
              if pair[0] in connected[j] or pair[1] in connected[j]:
                  if current_con_ind == -1:
                      connected[j].extend(pair)
                      connected[j] = sorted(list(set(connected[j])))
                      current_con_ind = j
                  else:
                      connected[current_con_ind].extend(connected[j])
                      to_delete_ind.append(j)
                      connected[current_con_ind].extend(pair)
                      connected[current_con_ind] = sorted(list(set(connected[current_con_ind])))
          for d in to_delete_ind:
              del connected[d]
          if current_con_ind == -1:
              connected.append(sorted(pair))
      print connected
      for indeces in connected:
          substring = []
          for index in indeces:
              substring.append(string[index-1])
          substring = sorted(substring, reverse=True)
          for i in range(len(indeces)):
              elems[indeces[i]-1] = substring[i]
      return ''.join(elems)

• 提交代码(C++)

  std::string swapLexOrder(std::string str, std::vector<std::vector<int>> pairs) {
      std::vector<int>del;
      std::vector<std::set<int>>indeies;
      for(size_t i=0;i<pairs.size();i++){
          int flag=-1;
          for(size_t j=0;j<indeies.size();j++){
              if(indeies[j].count(pairs[i][0])||indeies[j].count(pairs[i][1])){
                  if(flag==-1){
                      indeies[j].insert(pairs[i][0]);
                      indeies[j].insert(pairs[i][1]);
                      flag=j;
                  }
                  else{
                      for(std::set<int>::iterator it=indeies[j].begin();it!=indeies[j].end();it++){
                          indeies[flag].insert(*it);
                      }
                      del.push_back(j);
                  }
              }
          }
          for(size_t k=0;k<del.size();k++){
              indeies.erase(indeies.begin()+del[k]-k);
          }
          if(flag==-1){
              std::set<int>oIndex;
              oIndex.insert(pairs[i][0]);
              oIndex.insert(pairs[i][1]);
              indeies.push_back(oIndex);
          }
          del.clear();
      }
      for(size_t i=0;i<indeies.size();i++){
          std::vector<char>subStr;
          for(std::set<int>::iterator it=indeies[i].begin();it!=indeies[i].end();it++){
              subStr.push_back(str[*it-1]);
          }
          sort(subStr.begin(),subStr.end());
          int j=subStr.size()-1;
          for(std::set<int>::iterator it=indeies[i].begin();it!=indeies[i].end();it++){
              str[*it-1]=subStr[j--];
          }
      }
      return str;
  }

• refer

[1] https://codefights.com/interview-practice/task/5vXzdE9yzjsoMZ9sk