poj 1833 排列

总时间限制:
5000ms
内存限制:
65536kB

描述
题目描述：
大家知道，给出正整数n，则1到n这n个数可以构成n！种排列，把这些排列按照从小到大的顺序（字典顺序）列出，如n=3时，列出1 2 3，1 3 2，2 1 3，2 3 1，3 1 2，3 2 1六个排列。

任务描述：
给出某个排列，求出这个排列的下k个排列，如果遇到最后一个排列，则下1排列为第1个排列，即排列1 2 3…n。
比如：n = 3，k=2 给出排列2 3 1，则它的下1个排列为3 1 2，下2个排列为3 2 1，因此答案为3 2 1。
输入
第一行是一个正整数m，表示测试数据的个数，下面是m组测试数据，每组测试数据第一行是2个正整数n( 1 <= n < 1024 )和k(1<=k<=64)，第二行有n个正整数，是1，2 … n的一个排列。
输出
对于每组输入数据，输出一行，n个数，中间用空格隔开，表示输入排列的下k个排列。
样例输入

3
3 1
2 3 1
3 1
3 2 1
10 2    
1 2 3 4 5 6 7 8 9 10

样例输出

3 1 2
1 2 3
1 2 3 4 5 6 7 9 8 10

思路参照《算法基础与在线实践》一书

C++

#include <iostream>
#include <algorithm>
using namespace std;
int get_num(int i, vector<int> num_v, int t){
    // 从第i个位置的数开始，找到比 t 大的数中最小的数的下标
    vector<int>::iterator it =max_element(num_v.begin()+i, num_v.end());
    int min_x = *it, min_i=distance(num_v.begin(), it);
    for (int j = i; j < num_v.size(); ++j) {
        if(num_v[j]>t && num_v[j]<min_x){
            min_x = num_v[j];
            min_i = j;
        }
    }
    return min_i;
}
int main()
{
    int n, k, t, i, m, con_num;
    vector <int> num_v;
    cin>>m;
    while(m--)
    {
        cin>>n>>k;
        for (i = 0; i < n; i++) {
            cin >> t;
            num_v.push_back(t);
        }
        while(k--) {
            for (i = n - 1; i > 0; i--) {
                if (num_v[i] > num_v[i - 1]) {
                    //在i后面找到比num_[i-1]大的数中最小的数的下标

                    con_num = get_num(i, num_v, num_v[i - 1]);
                    //交换位置

                    int tt;
                    tt = num_v[i - 1];
                    num_v[i - 1] = num_v[con_num];
                    num_v[con_num] = tt;

                    sort(num_v.begin() + i, num_v.end());

                    break;
                }
            }
            if (i == 0) {
                //已经是降序，则升序排列
                sort(num_v.begin(), num_v.end());
            }
        }
        for(auto x : num_v){
            cout<<x<<" ";
        }
        cout<<endl;
        num_v.clear();
    }

    return 0;
}

java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static int get_num(int ii, ArrayList<Integer> num_v, int t){
        //从下标i的位置往后找，找到最小的比t大的那个数
        int i, mins=0, mins_i=0;
        boolean flag = false;
        for(i=ii;ii<num_v.size();ii++){
            if (num_v.get(ii)>t){
                if (!flag){
                    mins = num_v.get(ii);
                    mins_i = ii;
                    flag = true;
                }

                else if(mins>num_v.get(ii)){
                    mins = num_v.get(ii);
                    mins_i = ii;
                }
            }
        }

        return mins_i;
    }
    public static ArrayList<Integer> sort_list(int ii, ArrayList<Integer> num_v){
        for (int i=ii;i<num_v.size()-1;i++){
            for(int j=i+1;j<num_v.size();j++){
                if (num_v.get(i)>num_v.get(j)){
                    int x = num_v.set(i, num_v.get(j));
                    num_v.set(j, x);
                }
            }
        }
        return num_v;
    }
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        ArrayList<Integer> num_v = new ArrayList<Integer>();
        int n, i, m, t, k, con_m;
        m = s.nextInt();
        while(m-->0){
            n = s.nextInt();
            k = s.nextInt();
            for(i=0;i<n;i++){
                t = s.nextInt();
                num_v.add(t);
            }
            while(k-->0){
                for(i=num_v.size()-1;i>0;i--){
                    if(num_v.get(i) > num_v.get(i-1)){
                        //找到第一个正序的位置i-1
                        con_m = get_num(i, num_v, num_v.get(i-1));
                        //交换这个con_m和i位置的元素
                        int tt;
                        tt = num_v.set(con_m, num_v.get(i-1));
                        num_v.set(i-1, tt);
                        //对i-1之后的元素排序

                        num_v = sort_list(i, num_v);
                        break;
                    }
                }
                if(i == 0)
                    Collections.sort(num_v);
            }
            for(Integer x:num_v){
                System.out.print(x+" ");
            }
            System.out.println();
            num_v.clear();
        }

    }
}

/*
5 2
1 4 3 5 2
过程：
1 4 5 3 2
1 4 5 2 3
思路：把最小的往前换
*/