!/(n-m)!*n!

lo que podemos interpretar que ser:

factorial de n(nmero de elementos) sobre el factorial de n por el factorial de la resta del
nmero de elementos totales(n) menos el nmero de elementos por grupo.
<br />
double a[]=new double[tam];//declaramos nuestro arreglo y tamao o<br />
//tam en este caso ser 4.<br />
for(int m=1;m&lt;=tam;m++){// por lo tanto haremos 4 veces<br
/>
double n=1;<br />
double r=1;<br />
double aux1=1;<br />
for(int i=1;i&lt;=tam;n*=i,i++);//factorial de n que ser
el nmero de elementos.<br />
int aux=(tam-m);//restamos el tamao menos el numero de
elementos en el grupo<br />
for(int i=1;i&lt;=aux;aux1*=i,i++);//factorial de aux1,
que es la resta anterior<br />
for(int i=1;i&lt;=m;r*=i,i++);//factorial del nmero de
elementos por grupo<br />
a[m-1]=n/(aux1*r);//formula para obtener nmero de
combinaciones posibles y lo guardamos en un arreglo.<br />
}<br />

El algoritmo Para realizar permutaciones en java es:

import java.math.BigInteger;
class permutaciones {
private int[] a;
private BigInteger numLeft;
private BigInteger total;
public permutaciones(int n) {
if (n < 1) {
throw new IllegalArgumentException("Min 1");
}
a = new int[n];
total = getFactorial(n);
reset();
}
public void reset() {

for (int i = 0; i < a.length; i++) {

a[i] = i;
}
numLeft = new BigInteger(total.toString());
}
public BigInteger getNumLeft() {
return numLeft;
}
public BigInteger getTotal() {
return total;
}
public boolean hasMore() {
return numLeft.compareTo(BigInteger.ZERO) == 1;
}
private static BigInteger getFactorial(int n) {
BigInteger fact = BigInteger.ONE;
for (int i = n; i > 1; i--) {
fact = fact.multiply(new BigInteger(Integer.toString(i)));
}
return fact;
}
public int[] getNext() {
if (numLeft.equals(total)) {
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
int temp;
// Find largest index j with a[j] < a[j+1]
int j = a.length - 2;
while (a[j] > a[j + 1]) {
j--;
}
// Find index k such that a[k] is smallest integer
// greater than a[j] to the right of a[j]

int k = a.length - 1;
while (a[j] > a[k]) {
k--;
}
// Interchange a[j] and a[k]
temp = a[k];
a[k] = a[j];
a[j] = temp;
// Put tail end of permutation after jth position in increasing order
int r = a.length - 1;
int s = j + 1;
while (r > s) {
temp = a[s];
a[s] = a[r];
a[r] = temp;
r--;
s++;
}
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
public static void main(String[] args) {
int[] indices;
String[] elements = { "a", "b", "c", "d" };
permutaciones x = new permutaciones(elements.length);
StringBuffer permutation;
while (x.hasMore()) {
permutation = new StringBuffer();
indices = x.getNext();
for (int i = 0; i < indices.length; i++) {
permutation.append(elements[indices[i]]);
}
System.out.println(permutation.toString());
}

}
}

La salida de las permutaciones del vector es:

abcd
abdc
acbd
acdb
adbc
adcb
bacd
badc
bcad
bcda
bdac
bdca
cabd
cadb
cbad
cbda
cdab
cdba
dabc
dacb
dbac
dbca
dcab
dcba