小红的字符串构造

Python版本

c = list(input())

cnt = list(set(c))

vis = [0] * len(cnt)

if len(cnt) < 2:
    print(-1)
else:
    t = []
    for x in c:
        ok = False
        for i in range(len(vis)):
            if vis[i] == 0 and cnt[i] != x:
                t.append(cnt[i])
                vis[i] = 1
                ok = True
                break
        if sum(vis) == len(vis) and not ok:
            if cnt[0] != x:
                t.append(cnt[0])
            else:
                t.append(cnt[1])

    print("".join(t))

# 将输入字符串转换为字符列表
s = list(input())

# 初始化用于存储转换后字符的列表
t = []

# 初始化用于跟踪输入字符串中唯一字符的列表
char_set = []

# 初始化用于存储字符到字符映射的字典
char_map = {}

# 遍历输入字符串中的每个字符
for i in s:
    # 如果字符不在char_set中，则将其添加进去
    if i not in char_set:
        char_set.append(i)

# 检查char_set中的字符数量
# 如果少于2个字符，则无法进行有效的映射，输出-1
if len(char_set) < 2:
    print(-1)
else:
    # 创建字符到字符的映射
    for i in range(len(char_set)):
        # 如果是最后一个字符，则将其映射回第一个字符，形成循环
        if i == (len(char_set) - 1):
            char_map[char_set[i]] = char_set[0]
        else:
            # 否则，将字符映射到下一个字符
            char_map[char_set[i]] = char_set[i + 1]

    # 应用映射到输入字符串中的每个字符
    for i in s:
        # 使用char_map将字符转换为其映射字符，并添加到结果列表t中
        t.append(char_map[i])

    # 将结果列表t中的字符连接成一个字符串并打印
    print("".join(t))

#include <iostream>
#include <iterator>
#include <queue>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
struct node{
    node(char c, int count): c(c), count(count){}
    char c;
    int count{0};
};
int main() {
    std::string s;
    std::cin >> s;
    std::unordered_set<char> set;
    for(auto c : s)
    {
        set.emplace(c);
    }
    if(set.size() == 1)
    {
        std::cout << -1;
        return 0;
    }
    auto Compare = [](const node& a, const node& b){
        return a.count >= b.count;
    };
    std::priority_queue<node, std::vector<node>, decltype(Compare)> list(Compare);
    for(auto c : set)
    {
        node nod(c, 0);
        list.emplace(nod);
    }
    std::vector<node> vec;
    for(int i = 0; i < s.size();)
    {
        node now = list.top();
        list.pop();
        if(now.c != s[i])
        {
            s[i] = now.c;
            now.count++;
            list.push(now);
            i++;
            while(vec.size() > 0)
            {
                list.push(vec.back());
                vec.pop_back();
            }
        }
        else {
            vec.push_back(now);
        }
    }
    std::cout << s;
}

蛋疼，java 2001ms，c++ 7ms

#include <bits/stdc++.h>
using namespace std;

string s;

int main() {
    cin >> s;
    vector<int> chars(26, 0);
    for (char &c: s) {
        chars[c - 'a']++;
    }
    int base = -1, base2;
    int i = 0;
    while (i < 26) {
        if (chars[i] > 0) {
            base = i;
            ++i;
            break;
        }
        ++i;
    }
    base2 = base;
    while (i < 26) {
        if (chars[i] > 0) {
            chars[base] = i;
            base = i;
        }              
        ++i;  
    }
    if (base == base2) {
        cout << -1 << endl;
        return 0;
    } else {
        chars[base] = base2;
    }

    string res = "";

    for (char &c: s) {
        res += (char)('a' + chars[c - 'a']);
    }
    cout << res << endl;
    return 0;
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        HashSet<Character>set = new HashSet<>();
        int len = s.length();
        HashMap<Character,Boolean>map = new HashMap<>();
        for(int i = 0;i < len;i++)
        {
            char c = s.charAt(i);
            set.add(c);
            if(!map.isEmpty() && map.containsKey(c))
            {
                continue;
            }
            else
            {
                map.put(c,true);
            }
        }
        StringBuilder ans = new StringBuilder(len);
        for(int i = 0;i < len;i++)
        {
            char cur = s.charAt(i);
            int judge = 0;
            for(Character c : set)
            {
                if(!c.equals(cur))
                {
                    boolean f = map.get(c);
                    if(f)
                    {
                        ans.append(c);
                        judge = 1;
                        map.replace(c,false);
                        break;
                    }
                }
            }
            if(judge == 0)
            {
                for(Character c : set)
                {
                    if(!c.equals(cur))
                    {
                        ans.append(c);
                        break;
                    }
                }
            }
        }
        if(ans.length() < 1)
        {
            System.out.print(-1);
        }
        else
        {
            System.out.print(ans.toString());
        }
    }
}

#include <iostream>
#include<cstring>
#include<unordered_set>
#include <vector>

using namespace std;

int main() {
    string s;
    cin >> s;
    int n = s.size();
    unordered_set<char> st;
    for (char ch : s) {
        st.insert(ch);
    }
    string t;
    vector<char> vec(st.begin(), st.end());
    int sz = vec.size();
    if (sz == 1) {
        cout << -1 << endl;
        return 0;
    }
    int idx = 0;
    for (int i = 0; i < n; i++) {
        if (vec[(idx) % sz] == s[i])
            idx++;
        t += vec[(idx++) % sz];
    }
    cout << t << endl;
    return 0;
}
// 64 位输出请用 printf("%lld")