全排列(java)

洛谷题目：P1088 [NOIP2004 普及组] 火星人

题目描述:

人类终于登上了火星的土地并且见到了神秘的火星人。人类和火星人都无法理解对方的语言，但是我们的科学家发明了一种用数字交流的方法。这种交流方法是这样的，首先，火星人把一个非常大的数字告诉人类科学家，科学家破解这个数字的含义后，再把一个很小的数字加到这个大数上面，把结果告诉火星人，作为人类的回答。

火星人用一种非常简单的方式来表示数字――掰手指。火星人只有一只手，但这只手上有成千上万的手指，这些手指排成一列，分别编号为 1,2,3,\cdots1,2,3,⋯。火星人的任意两根手指都能随意交换位置，他们就是通过这方法计数的。

一个火星人用一个人类的手演示了如何用手指计数。如果把五根手指――拇指、食指、中指、无名指和小指分别编号为 1,2,3,41,2,3,4 和 55，当它们按正常顺序排列时，形成了 55 位数 1234512345，当你交换无名指和小指的位置时，会形成 55 位数 1235412354，当你把五个手指的顺序完全颠倒时，会形成 5432154321，在所有能够形成的 120120 个 55 位数中，1234512345 最小，它表示 11；1235412354 第二小，它表示 22；5432154321 最大，它表示 120120。下表展示了只有 33 根手指时能够形成的 66 个 33 位数和它们代表的数字：

三进制数	代表的数字
	123123	11
	132132	22
	213213	33
	231231	44
	312312	55
	321321	66
现在你有幸成为了第一个和火星人交流的地球人。一个火星人会让你看他的手指，科学家会告诉你要加上去的很小的数。你的任务是，把火星人用手指表示的数与科学家告诉你的数相加，并根据相加的结果改变火星人手指的排列顺序。输入数据保证这个结果不会超出火星人手指能表示的范围。

输入格式
共三行。
第一行一个正整数 NN，表示火星人手指的数目（1 \le N \le 100001≤N≤10000）。
第二行是一个正整数 MM，表示要加上去的小整数（1 \le M \le 1001≤M≤100）。
下一行是 11 到 NN 这 NN 个整数的一个排列，用空格隔开，表示火星人手指的排列顺序。

输出格式
NN 个整数，表示改变后的火星人手指的排列顺序。每两个相邻的数中间用一个空格分开，不能有多余的空格。

输入输出样例
输入 
	5
	3
	1 2 3 4 5
输出 
	1 2 4 5 3
说明/提示
对于 30\%30% 的数据，N \le 15N≤15。

对于 60\%60% 的数据，N \le 50N≤50。

对于 $$100% 的数据，N \le 10000N≤10000。

noip2004 普及组第 4 题

AC:

package 暴力枚举;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class P1088_火星人 {
	public static void main(String[] args) throws IOException {
		StringBuilder str=new StringBuilder();
		StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int n=(int) in.nval;
		in.nextToken();
		int m=(int) in.nval;
		int[] ints=new int[n];
		for(int i=0;i<ints.length;i++) {
			in.nextToken();
			ints[i]=(int) in.nval;
		}
		int j,k;
		for(;m>=1;m--) {
			for(j=n-1;j>=0;j--) {
				if(ints[j]>ints[j-1]) {
					break;
				}
			}
			j--;
			for(k=n-1;k>j;k--) {
				if(ints[k]>ints[j]) {
					break;
				}
			}
			ints[j] ^= ints[k];
			ints[k] ^= ints[j];
			ints[j] ^= ints[k];
			j++;
			k=n-1;
			while(j<k) {
				ints[j]=ints[j]^ints[k];
				ints[k]=ints[j]^ints[k];
				ints[j]=ints[j]^ints[k];
				j++;
				k--;
			}
		}
		for(int i=0;i<ints.length;i++) {
			str.append(ints[i]+" ");
		}
		out.print(str);
		out.close();
	}
}

全排列中找排序

code:90

package 全排列;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class 全排列7 {
	static StringBuilder str=new StringBuilder();
	static int n;
	static int m;
	static boolean bool=true;
	static int[] cc;
	static boolean[] pd;
	static int ct=0;
	static int[] ints;
	static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
	public static void main(String[] args) throws IOException{
		in.nextToken();
		n=(int) in.nval;
		in.nextToken();
		m=(int) in.nval;
		ints=new int[n+1];
		pd=new boolean[n+1];
		cc=new int[n];
		for(int i=1;i<ints.length;i++) {
			in.nextToken();
			ints[i]=(int) in.nval;
		}
		dfs(1);
	}

	private static void dfs(int t) {
		if(t>n) {
			bool=false;
			if(m==0) {
				for(int i=0;i<cc.length;i++) {
					str.append(cc[i]+" ");
				}
				str.append("\n");
				out.print(str);
				out.close();
				System.exit(0);
			}
			m--;
		}
		for(int i=1;i<=n;i++) {
			if(bool) {
				i=ints[t];
			}
			if(!pd[i]) {
				pd[i]=true;
				cc[ct]=i;
				ct++;
				dfs(t+1);
				pd[i]=false;
			}
		}
		ct--;
	}
}

全排列其他写法(时间复杂度高,不建议用):

Hash去重

package 全排列;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;

public class 全排列6 {
	public static void main(String[] args) {
		String str="ABC";
		ArrayList list=Permutation(str);
		for(int i=0;i<list.size();i++) {
			System.out.print(list.get(i)+" ");
		}
		System.out.println();
		System.out.println(list.size());
	}
	private static String change(char[] a) {
		StringBuilder res=new StringBuilder();
		for(char value:a) {
			res.append(value);
		}
		return res.toString();
	}
	private static void solve(ArrayList<String> ans,char[] a,int index,int length) {
		if(index==length-1) {
			String res=change(a);
			ans.add(res);
		}else {
			//就说明现在要去确定index位置的字符
			for(int i=index;i<length;i++) {
				swap(a,i,index);
				//当前index位置的字符已经通过交换找到了,那么就递归去找下一个字符	
				solve(ans, a, index+1, length);
			//其实就是去为了消除当前层去递归的时候的进行交换字符的影响,如果不消除的话,那么就会造成原index位置的字符发生变化
				swap(a,i,index);
			}
		}
	}
	private static void swap(char[] arr,int i,int index) {
		char temp=arr[i];
		arr[i]=arr[index];
		arr[index]=temp;
	}
	public static ArrayList<String> Permutation(String str){
		char[] a=str.toCharArray();
		ArrayList<String> ans=new ArrayList<>();
		solve(ans, a, 0, str.length());
		ans=new ArrayList<String>(new HashSet<String>(ans));//去重操作
		Collections.sort(ans);//字典排序 -> ans.sort(null);相当于
		return ans;
	}
}

dfs经典全排列

package dfs;

import java.util.Scanner;

public class dfs全排列 {
	static int n;
	static int count; 
	static boolean[] vis=new boolean[20];
	static int[] arr=new int[20];
	private static void dfs(int x) {
		if(x>n) {
			count++;
			pr();
		}
		for(int i=1;i<=n;i++) {
			if(!vis[i]) { 
				arr[x]=i;
				vis[i]=true;
				dfs(x+1);
				vis[i]=false;
			}
		}
	}
	
	private static void pr() {
		for(int i=1;i<=n;i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();
		dfs(1);
		System.out.println(count);
	}
}