1. Utilice el método del estado binario para encontrar permutaciones y combinaciones. Este método es relativamente fácil de entender, pero su eficiencia operativa no es alta. Se pueden utilizar pequeñas permutaciones y combinaciones.
Copie el código de código de la siguiente manera:
importar java.util.Arrays;
//Utiliza un algoritmo binario para realizar el arreglo completo
//cuenta1:170187
//cuenta2:291656
prueba de clase pública {
público estático vacío principal (String [] argumentos) {
inicio largo=System.currentTimeMillis();
contar2();
extremo largo=System.currentTimeMillis();
System.out.println(fin-inicio);
}
recuento de vacío estático privado2(){
int[] núm=nuevo int []{1,2,3,4,5,6,7,8,9};
for(int i=1;i<Math.pow(9, 9);i++){
Cadena cadena=Integer.toString(i,9);
int sz=cadena.length();
para(int j=0;j<9-sz;j++){
cadena="0"+cadena;
}
char[] temp=str.toCharArray();
Arrays.sort(temp);
Cadena gl=nueva cadena(temp);
si(!gl.equals("012345678")){
continuar;
}
Resultado de cadena="";
for(int m=0;m<str.length();m++){
resultado+=num[Integer.parseInt(str.charAt(m)+"")];
}
System.out.println(resultado);
}
}
recuento de vacíos estáticos públicos1(){
int[] núm=nuevo int []{1,2,3,4,5,6,7,8,9};
int[] ss=nuevo int []{0,1,2,3,4,5,6,7,8};
int[] temp=nuevo int[9];
mientras(temperatura[0]<9){
temperatura[temp.longitud-1]++;
for(int i=temp.length-1;i>0;i--){
si(temperatura[i]==9){
temperatura[i]=0;
temperatura[i-1]++;
}
}
int []tt=temp.clon();
Arrays.sort(tt);
if(!Arrays.equals(tt,ss)){
continuar;
}
Resultado de cadena="";
for(int i=0;i<num.length;i++){
resultado+=núm[temp[i]];
}
System.out.println(resultado);
}
}
}
2. Utilice el pensamiento recursivo para encontrar permutaciones y combinaciones, lo que requiere una gran cantidad de código.
Copie el código de código de la siguiente manera:
práctica de paquetes;
importar java.util.ArrayList;
importar java.util.List;
clase pública Prueba1 {
/**
* argumentos @param
*/
público estático vacío principal (String [] argumentos) {
// TODO Código auxiliar de método generado automáticamente
Objeto[] tmp={1,2,3,4,5,6};
// ArrayList<Objeto[]> rs=RandomC(tmp);
ArrayList<Objeto[]> rs=cmn(tmp,3);
para(int i=0;i<rs.size();i++)
{
// System.out.print(i+"=");
para(int j=0;j<rs.get(i).length;j++)
{
System.out.print(rs.get(i)[j]+",");
}
System.out.println();
}
}
// Encuentra cualquier combinación de una matriz
ArrayList estático<Objeto[]> RandomC(Objeto[] fuente)
{
ArrayList<Objeto[]> resultado=nuevo ArrayList<Objeto[]>();
si(fuente.longitud==1)
{
resultado.add(fuente);
}
demás
{
Objeto[] psource=nuevo Objeto[fuente.length-1];
para(int i=0;i<psource.length;i++)
{
pfuente[i]=fuente[i];
}
resultado=RandomC(psource);
int len=result.size();//La longitud de la combinación fn
resultado.add((nuevo Objeto[]{fuente[fuente.length-1]}));
para(int i=0;i<len;i++)
{
Objeto[] tmp=nuevo Objeto[resultado.get(i).length+1];
para(int j=0;j<tmp.length-1;j++)
{
tmp[j]=resultado.get(i)[j];
}
tmp[tmp.length-1]=fuente[fuente.length-1];
resultado.add(tmp);
}
}
resultado de devolución;
}
static ArrayList<Objeto[]> cmn(Objeto[] fuente,int n)
{
ArrayList<Objeto[]> resultado=nuevo ArrayList<Objeto[]>();
si(n==1)
{
para(int i=0;i<fuente.longitud;i++)
{
resultado.add(nuevo Objeto[]{fuente[i]});
}
}
de lo contrario si (fuente.longitud==n)
{
resultado.add(fuente);
}
demás
{
Objeto[] psource=nuevo Objeto[fuente.length-1];
para(int i=0;i<psource.length;i++)
{
pfuente[i]=fuente[i];
}
resultado=cmn(pfuente,n);
ArrayList<Objeto[]> tmp=cmn(psource,n-1);
para(int i=0;i<tmp.size();i++)
{
Objeto[] rs=nuevo Objeto[n];
para(int j=0;j<n-1;j++)
{
rs[j]=tmp.get(i)[j];
}
rs[n-1]=fuente[fuente.longitud-1];
resultado.add(rs);
}
}
resultado de devolución;
}
}
3. Utilice la idea de programación dinámica para buscar permutaciones y combinaciones.
Copie el código de código de la siguiente manera:
paquete Acm;
//Potente búsqueda de números combinados
Aplicación principal de clase pública {
público estático vacío principal (String [] argumentos) {
int[] núm=nuevo int[]{1,2,3,4,5};
Cadena cadena="";
//Encuentra el número de combinaciones de 3 números
// cuenta(0,cadena,núm,3);
// Encuentra el número de combinaciones de 1-n números
cuenta1(0,cadena,núm);
}
recuento de vacío estático privado1 (int i, cadena cadena, int [] num) {
si(i==núm.longitud){
System.out.println(cadena);
devolver;
}
cuenta1(i+1,cadena,núm);
cuenta1(i+1,cadena+núm[i]+",",núm);
}
recuento de vacíos estáticos privados (int i, String str, int[] num,int n) {
si(n==0){
System.out.println(cadena);
devolver;
}
si(i==núm.longitud){
devolver;
}
contar(i+1,cadena+núm[i]+",",núm,n-1);
contar(i+1,cadena,núm,n);
}
}
El siguiente es el arreglo
Copie el código de código de la siguiente manera:
paquete Acm;
//Encuentra el arreglo, encuentra el arreglo después de varias permutaciones o combinaciones
importar java.util.Arrays;
importar java.util.Scanner;
clase pública Demo19 {
booleano estático privado f[];
público estático vacío principal (String [] argumentos) {
Escáner sc=nuevo escáner(System.in);
int sz=sc.nextInt();
para(int i=0;i<sz;i++){
int suma=sc.nextInt();
f=nuevo booleano[suma];
Arrays.fill(f, verdadero);
int[] num=nuevo int[suma];
para(int j=0;j<suma;j++){
número[j]=j+1;
}
int nn=sc.nextInt();
Cadena cadena="";
contar(núm,cadena,nn);
}
}
/**
*
* @param num representa la matriz a organizar
* @param str Cadena arreglada
* @param nn El número de elementos restantes que deben organizarse. Si se requiere una disposición completa, nn es la longitud de la matriz.
*/
recuento de vacíos estáticos privados (int[] num, String str, int nn) {
si(nn==0){
System.out.println(cadena);
devolver;
}
for(int i=0;i<num.length;i++){
si(!f[i]){
continuar;
}
f[yo]=falso;
contar(núm,cadena+núm[i],nn-1);
f[i]=verdadero;
}
}
}