题解 | 解密

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

class Solution {
public:
    vector<string> getAllPermutations(string s) {
        vector<string> result;
        
        // 先排序得到字典序最小的排列
        sort(s.begin(), s.end());
        
        // 不断生成下一个排列
        do {
            result.push_back(s);
        } while (next_permutation(s.begin(), s.end()));
        
        return result;
    }
};

int main() {
    string s;
    cin >> s;
    
    Solution solution;
    vector<string> result = solution.getAllPermutations(s);
    
    // 输出所有排列
    for (const string& perm : result) {
        cout << perm << endl;
    }
    
    return 0;
}

import java.util.*;

public class Main {
    static class Solution {
        public List<String> getAllPermutations(String s) {
            List<String> result = new ArrayList<>();
            char[] chars = s.toCharArray();
            
            // 先排序得到字典序最小的排列
            Arrays.sort(chars);
            
            // 不断生成下一个排列
            do {
                result.add(new String(chars));
            } while (nextPermutation(chars));
            
            return result;
        }
        
        private boolean nextPermutation(char[] arr) {
            // 1. 找到最后一个升序位置
            int i = arr.length - 2;
            while (i >= 0 && arr[i] >= arr[i + 1]) {
                i--;
            }
            if (i < 0) return false;
            
            // 2. 找到第一个大于arr[i]的位置
            int j = arr.length - 1;
            while (arr[j] <= arr[i]) {
                j--;
            }
            
            // 3. 交换并反转
            swap(arr, i, j);
            reverse(arr, i + 1, arr.length - 1);
            return true;
        }
        
        private void swap(char[] arr, int i, int j) {
            char temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
        private void reverse(char[] arr, int left, int right) {
            while (left < right) {
                swap(arr, left++, right--);
            }
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine().trim();
        
        Solution solution = new Solution();
        List<String> result = solution.getAllPermutations(s);
        
        // 输出所有排列
        for (String perm : result) {
            System.out.println(perm);
        }
        
        sc.close();
    }
}

class Solution:
    def get_all_permutations(self, s: str) -> list:
        def next_permutation(arr):
            # 1. 找到最后一个升序位置
            i = len(arr) - 2
            while i >= 0 and arr[i] >= arr[i + 1]:
                i -= 1
            if i < 0:
                return False
            
            # 2. 找到第一个大于arr[i]的位置
            j = len(arr) - 1
            while arr[j] <= arr[i]:
                j -= 1
            
            # 3. 交换并反转
            arr[i], arr[j] = arr[j], arr[i]
            left = i + 1
            right = len(arr) - 1
            while left < right:
                arr[left], arr[right] = arr[right], arr[left]
                left += 1
                right -= 1
            return True
        
        # 转换为列表并排序
        chars = list(s)
        chars.sort()
        result = []
        
        # 生成所有排列
        while True:
            result.append(''.join(chars))
            if not next_permutation(chars):
                break
        
        return result

if __name__ == "__main__":
    s = input().strip()
    
    solution = Solution()
    result = solution.get_all_permutations(s)
    
    # 输出所有排列
    for perm in result:
        print(perm)