1 2 3

1 2 3 
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

0 1

0 1
1 0

1

1

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    // 结果存储
    vector<vector<int>> result;

    // 回溯函数
    void backtrack(vector<int>& nums, vector<int>& current, vector<bool>& used) {
        // 如果当前排列的长度和nums的长度相同，表示已经得到一个排列
        if (current.size() == nums.size()) {
            result.push_back(current);
            return;
        }
        
        // 遍历数组nums
        for (int i = 0; i < nums.size(); ++i) {
            // 如果元素已使用，跳过
            if (used[i]) continue;
            // 标记当前元素为已使用
            used[i] = true;
            // 选择当前元素并递归
            current.push_back(nums[i]);
            backtrack(nums, current, used);
            // 回溯，撤销选择
            current.pop_back();
            used[i] = false;
        }
    }

    // 主函数，启动回溯过程
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        vector<int> current;
        backtrack(nums, current, used);
        return result;
    }
};

// 用于输入输出
int main() {
    Solution solution;
    vector<int> nums;
    int num;
    
    // 读入数据
    while (cin >> num) {
        nums.push_back(num);
        if (cin.get() == '\n') break;
    }
    
    // 获取全排列
    vector<vector<int>> res = solution.permute(nums);
    
    // 输出结果
    for (const auto& perm : res) {
        for (int i = 0; i < perm.size(); ++i) {
            if (i != 0) cout << " ";
            cout << perm[i];
        }
        cout << endl;
    }
    
    return 0;
}

class Solution:
    def permute(self, nums):
        result = []
        used = [False] * len(nums)
        current = []
        
        def backtrack():
            if len(current) == len(nums):
                result.append(current[:])
                return
            for i in range(len(nums)):
                if used[i]:
                    continue
                used[i] = True
                current.append(nums[i])
                backtrack()
                current.pop()
                used[i] = False
        
        backtrack()
        return result

# 输入输出部分
if __name__ == '__main__':
    nums = list(map(int, input().split()))
    solution = Solution()
    res = solution.permute(nums)
    for perm in res:
        print(" ".join(map(str, perm)))

import java.util.*;

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        List<Integer> current = new ArrayList<>();
        
        backtrack(nums, result, current, used);
        return result;
    }
    
    private void backtrack(int[] nums, List<List<Integer>> result, List<Integer> current, boolean[] used) {
        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current));
            return;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;
            used[i] = true;
            current.add(nums[i]);
            backtrack(nums, result, current, used);
            current.remove(current.size() - 1);
            used[i] = false;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(" ");
        int[] nums = new int[input.length];
        for (int i = 0; i < input.length; i++) {
            nums[i] = Integer.parseInt(input[i]);
        }

        Solution solution = new Solution();
        List<List<Integer>> res = solution.permute(nums);

        for (List<Integer> perm : res) {
            for (int i = 0; i < perm.size(); i++) {
                if (i != 0) System.out.print(" ");
                System.out.print(perm.get(i));
            }
            System.out.println();
        }
    }
}