java 实现排列组合Permutation and Combination和链式不相邻排列组合和环形不相邻排列

常用的排列组合公式:
P (n,m)=n!/(n-m)!
C(n,m)=n!/(m!(n-m)!)
C(n,m)=C(n,n-m)
P(n,m)=P(m,m)*C(n,m)

import java.util.ArrayList;
import java.util.List;
public class PermutationCombination
{
public static void main(String[] args)
{
PermutationCombination perm = new PermutationCombination();
List<Character> data = new ArrayList<Character>();
data.add('a');
data.add('b');
data.add('c');
data.add('d');
List<List<Character>>result=new ArrayList<List<Character>>();
for(int i = 1; i <= data.size(); i++)
{
perm.permutation(data,new ArrayList<Character>(),i,result);
}
for(int i=0;i<result.size();i++)
{
for(int j=0;j<result.get(i).size();j++)
{
System.out.print(result.get(i).get(j));
}
System.out.println();
}
System.out.println("################the split line of the permutation and combination ##########################");
PermutationCombination comb=new PermutationCombination();
List<Character>data2=new ArrayList<Character>();
data2.add('a');
data2.add('b');
data2.add('c');
data2.add('d');
List<List<Character>>result2=new ArrayList<List<Character>>();
for(int i=1;i<=data.size();i++)
{
comb.combination(data2, new ArrayList<Character>(), data2.size(), i, result2);
}
for(int i=0;i<result2.size();i++)
{
for(int j=0;j<result2.get(i).size();j++)
{
System.out.print(result2.get(i).get(j));
}
System.out.println();
}
}

/**
* the function is used to get permutation according to the formula P(n,m)=n!/(n-m)! note that(m<=n)
* @param data the source data
* @param workspace Customize a temporary space to store each qualified value
* @param k the number need permutation p(n,k)
*/
public <E> void permutation(List<E> data,List<E> workspace, int k,List<List<E>>result)
{
List<E> copyData;
List<E> copyTarget;
if(workspace.size() == k)
{
result.add(workspace); /*we need a return in order to deal with data after permutation*/
// for(E i : workspace) /*instead just print the result*/
// {
// System.out.print(i);
// }
// System.out.println();
}
for(int i=0; i<data.size(); i++)
{
copyData = new ArrayList<E>(data);
copyTarget = new ArrayList<E>(workspace);
copyTarget.add(copyData.get(i));
copyData.remove(i);
permutation(copyData, copyTarget,k,result);
}
}

/**
* according the formula C(n,m)=n!/(m!(n-m)!) and C(n,m)=C(n,n-m) note that (m<=n)
* 把数据的第一个元素添加到工作空间中，判断工作空间的大小，如果小于k,则需要继续递归，但此时，传入递归函数的
* 参数需要注意：假设当前插入的节点的下标是i,因为是顺序插入的,所以i之前的所有数据都应该舍去，只传入i之后的未使用过的数据。
* 因此在传参之前，应该对copyData作以处理
* (when the first element is added to the data in the working space, determine the size of the space,
* if less than k, you need to continue recursion, but this time, parameter recursive function to note:
* assuming the insertion of the subscript node is i, because it is the order of insertion,
* so all data before I should give up. Only after the incoming i unused data.
* Therefore, copyData should be handled before passing arguments)
* @param data the source data
* @param workSpace Customize a temporary space to store each qualified value
* @param k k in C(n,k)
*/
public <E> void combination(List<E> data, List<E> workSpace, int n, int k, List<List<E>>result)
{
List<E> copyData;
List<E> copyWorkSpace;
if(workSpace.size() == k)
{
result.add(workSpace); /*we need a return in order to deal with data after combination*/
// for(Object c : workSpace) /*instead just print the result*/
// {
// System.out.print(c);
// }
// System.out.println();
}
for(int i = 0; i < data.size(); i++)
{
copyData = new ArrayList<E>(data);
copyWorkSpace = new ArrayList<E>(workSpace);
copyWorkSpace.add(copyData.get(i));
for(int j = i; j >= 0; j--)
{
copyData.remove(j);
}
combination(copyData, copyWorkSpace, n, k,result);
}
}
}
链式不相邻组合:是指从A={1,2,3,…,n}中选取m个不相邻的组合个数

例如，n=4,m=2，有组合{1,3},{2,4},{1,4}
定理：从A={1,2,3,…,n}中取m个不相邻组合，其组合数为C(n−m+1,m)

链式不相邻排列:P(m,m)*C(n-m+1,m)

环形不相邻排列:A={1,2,3,…,n}围成一圈,选取m个不相邻的组合个数

例如,n=4,m=2,有组合{2,4}{1,3}{4,1}{3,1}

假设n=6,m=3, A={1,2,3,4,5,6},第一次选择，有6个位置，可以分为两种情况：

第一种 剩下的数中不同时包含两个端点，假设选择2，则1，3不能选，只剩下{4，5，6}， 这个一个大小为3的链式不相邻问题。

第二种 剩下的数中同时包含两个端点，假设选择3，则剩下{1，5，6}，其中1和5可以相邻，1和6不可相邻。所以可以等价于{5，6，1}的链式不相邻的问题。
对于n个元素，先随便选择一个，有n中可能,则剩下的问题是 从(n-3)个元素中选择(m-1)个不相邻的组合问题，即A(n-m-1, m-1)

package com.copycat.acmcoder;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
scanner.close();
if(m>(n/2))
{
System.out.println(0);
}
else
{
long sum=n;
for(int j=m+1;j<=2*m-1;j++)
{
sum=sum*(n-j);
}
System.out.println(sum);
}
}
}