1. Use o método de estado binário para encontrar permutações e combinações. Este método é relativamente fácil de entender, mas sua eficiência operacional não é alta.
Copie o código do código da seguinte forma:
importar java.util.Arrays;
//Use algoritmo binário para realizar o arranjo completo
//contagem1:170187
//contagem2:291656
teste de classe pública {
public static void main(String[] args) {
início longo=System.currentTimeMillis();
contagem2();
final longo=System.currentTimeMillis();
System.out.println(fim-início);
}
contagem de void estática privada2(){
int[] num=novo int []{1,2,3,4,5,6,7,8,9};
for(int i=1;i<Math.pow(9, 9);i++){
String str=Integer.toString(i,9);
int sz=str.comprimento();
for(int j=0;j<9-sz;j++){
str="0"+str;
}
char[] temp=str.toCharArray();
Matrizes.sort(temp);
String gl=nova String(temp);
if(!gl.equals("012345678")){
continuar;
}
String resultado="";
for(int m=0;m<str.comprimento();m++){
resultado+=num[Integer.parseInt(str.charAt(m)+"")];
}
System.out.println(resultado);
}
}
contagem de vazios estáticos públicos1(){
int[] num=novo int []{1,2,3,4,5,6,7,8,9};
int[] ss=novo int []{0,1,2,3,4,5,6,7,8};
int[] temp=new int[9];
enquanto(temp[0]<9){
temp[temp.comprimento-1]++;
for(int i=temp.length-1;i>0;i--){
if(temp[i]==9){
temperatura[i]=0;
temperatura[i-1]++;
}
}
int []tt=temp.clone();
Matrizes.sort(tt);
if(!Arrays.equals(tt,ss)){
continuar;
}
String resultado="";
for(int i=0;i<num.comprimento;i++){
resultado+=num[temp[i]];
}
System.out.println(resultado);
}
}
}
2. Use o pensamento recursivo para encontrar permutações e combinações, o que requer uma grande quantidade de código.
Copie o código do código da seguinte forma:
prática de pacote;
importar java.util.ArrayList;
importar java.util.List;
classe pública Teste1 {
/**
* @param argumentos
*/
public static void main(String[] args) {
// TODO stub de método gerado automaticamente
Objeto[] tmp={1,2,3,4,5,6};
//ArrayList<Object[]> rs=RandomC(tmp);
ArrayList<Object[]> rs=cmn(tmp,3);
for(int i=0;i<rs.size();i++)
{
//System.out.print(i+"=");
for(int j=0;j<rs.get(i).length;j++)
{
System.out.print(rs.get(i)[j]+",");
}
System.out.println();
}
}
//Encontre qualquer combinação de um array
static ArrayList<Object[]> RandomC(Object[] fonte)
{
ArrayList<Object[]> resultado=new ArrayList<Object[]>();
if(fonte.comprimento==1)
{
resultado.add(fonte);
}
outro
{
Object[] psource=new Object[source.length-1];
for(int i=0;i<psource.length;i++)
{
fonte[i]=fonte[i];
}
resultado=RandomC(psource);
int len=result.size();//O comprimento da combinação fn
resultado.add((novo Objeto[]{fonte[fonte.comprimento-1]}));
for(int i=0;i<len;i++)
{
Object[] tmp=new Object[result.get(i).length+1];
for(int j=0;j<tmp.length-1;j++)
{
tmp[j]=resultado.get(i)[j];
}
tmp[tmp.length-1]=fonte[source.length-1];
resultado.add(tmp);
}
}
resultado de retorno;
}
static ArrayList<Object[]> cmn(Object[] fonte,int n)
{
ArrayList<Object[]> resultado=new ArrayList<Object[]>();
se(n==1)
{
for(int i=0;i<fonte.comprimento;i++)
{
resultado.add(novo Objeto[]{fonte[i]});
}
}
senão if(fonte.comprimento==n)
{
resultado.add(fonte);
}
outro
{
Object[] psource=new Object[source.length-1];
for(int i=0;i<psource.length;i++)
{
fonte[i]=fonte[i];
}
resultado=cmn(pfonte,n);
ArrayList<Object[]> tmp=cmn(psource,n-1);
for(int i=0;i<tmp.size();i++)
{
Objeto[] rs=novo Objeto[n];
para(int j=0;j<n-1;j++)
{
rs[j]=tmp.get(i)[j];
}
rs[n-1]=fonte[fonte.comprimento-1];
resultado.add(rs);
}
}
resultado de retorno;
}
}
3. Utilize a ideia de programação dinâmica para buscar permutações e combinações
Copie o código do código da seguinte forma:
pacote Acm;
//Pesquisa poderosa por números de combinação
classe pública MainApp {
public static void main(String[] args) {
int[] num=novo int[]{1,2,3,4,5};
Stringstr="";
//Encontre o número de combinações de 3 números
// contagem(0,str,num,3);
// Encontre o número de combinações de números 1-n
contagem1(0,str,num);
}
private static void contagem1(int i, String str, int[] num) {
if(i==num.comprimento){
System.out.println(str);
retornar;
}
contagem1(i+1,str,num);
contagem1(i+1,str+num[i]+",",num);
}
contagem de vazios estáticos privados (int i, String str, int[] num,int n) {
se(n==0){
System.out.println(str);
retornar;
}
if(i==num.comprimento){
retornar;
}
contagem(i+1,str+num[i]+",",num,n-1);
contar(i+1,str,num,n);
}
}
O seguinte é o arranjo
Copie o código do código da seguinte forma:
pacote ACM;
//Encontre o arranjo, encontre o arranjo após várias permutações ou combinações
importar java.util.Arrays;
importar java.util.Scanner;
classe pública Demo19 {
booleano estático privado f[];
public static void main(String[] args) {
Scanner sc=novo Scanner(System.in);
int sz=sc.nextInt();
for(int i=0;i<sz;i++){
int soma=sc.nextInt();
f=novo booleano[soma];
Arrays.fill(f, verdadeiro);
int[] num=novo int[soma];
for(int j=0;j<soma;j++){
num[j]=j+1;
}
int nn=sc.nextInt();
Stringstr="";
contagem(num,str,nn);
}
}
/**
*
* @param num representa o array a ser organizado
* @param str String organizada
* @param nn O número de itens restantes que precisam ser organizados. Se a organização completa for necessária, nn é o comprimento da matriz.
*/
contagem de void estática privada(int[] num, String str, int nn) {
se(nn==0){
System.out.println(str);
retornar;
}
for(int i=0;i<num.comprimento;i++){
se(!f[i]){
continuar;
}
f[i]=falso;
contagem(num,str+num[i],nn-1);
f[i]=verdadeiro;
}
}
}