swapLexOrder

最新推荐文章于 2022-02-11 16:20:03 发布

恒友成

最新推荐文章于 2022-02-11 16:20:03 发布

阅读量446

点赞数

分类专栏：数据结构与算法文章标签： codefights

本文链接：https://blog.csdn.net/lx_ros/article/details/80555192

版权

数据结构与算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

给定一个字符串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;
}