圆排列（去除全排列重复、全排列镜像）

以下代码思路一样，第一个处理手段比较容易想到，只在最后一位比较与第一位的大小；第二个空间换时间，第三个在递归过程中进行处理筛选。算法解法容易想到，难点在于处理全排列镜像方面，当然做出来也不难，难的是如何全排列出需要的一半并降低一半的时间复杂度 。主要的思路就是让第一位小于等于最后一位，这个可以在递归中制定规则来筛选，如第三种方法；也可以在开始时就筛选出来，确定第一位和最后一位，那么是需要对2~n-1进行全排列就可以了，时间复杂度自然就下去了。三种方法的不同之处在于对于全排列去除镜像的处理上。方法二速度较快，但没有很好的去除重复。方法一去除了镜像和重复但速度较慢。方法三同时去除了镜像和重复，速度较方法一快了些。

第一种方法

#include <iostream>
#include <math.h>
#define LENGTH 10

using namespace std;

class Circle
{
	friend float CirclePerm(int,float *);
private:
	float Center(int t);	//计算当前序列中圆心得坐标 
	void Compute(void);		//计算距离 
	void Backtrack(int t);	//递归，全排列 
	float min,				//最优解
	      *x,				//记录院系坐标 
	      *r;				//记录全排列过程中的圆序列（用半径表示） 
	int n;					//序列中圆的个数 
};

float Circle::Center(int t)
{	
	float temp = 0;
	for(int j = 1;j<t;j++)
	{
		float valuex = x[j] + 2.0 * sqrt(r[t]*r[j]);
		if(valuex>temp)
			temp = valuex;
	}
	return temp;
}

void Circle::Compute(void)
{
	float low = 0,high = 0;		//low表示左边第一个圆的最左边坐标，肯定为负值（因为左边第一个圆圆心为0），high记录右边第一个圆最右边坐标，右边第一个圆的坐标多一个半径 
	for(int i=1;i<=n;i++)
	{
		if(x[i]-r[i]<low)	
		{
			low = x[i]-r[i];
		}
		if(x[i]+r[i]>high)
		{
			high = x[i]+r[i];
		}
	}
	if(high>low&&high-low<min)
	{
		min = high-low;		//high-low的值为当前序列圆的总长度 
	}
}
/*
全排列去重条件
每一位置的元素，只可以与其之后的相同的元素交换一次。比如之后又两个2，那么只与第一个2交换。 
*/
int isSwap(float *r,int start,int end)
{
	for(int i=start;i<end;i++)
	{
		if(fabs(r[i]-r[end])<1e-6)
		{
			return 0;
		}
	}
	return 1;
}

/*
 *递归求全排列 
 * */
void Circle::Backtrack(int t)
{
	if(t>n)			
	{
		Compute();
	}else
	{
		for(int j = t;j<=n;j++)	
		{
			
			if(t==n&&r[1]>r[n]) break;
			
			if(isSwap(r,t,j))
			{
				swap(r[t],r[j]);
				float centerx = Center(t);
				if(centerx+r[t]+r[1]<min)	//剪枝条件：如果现在长度已经超过之前求得的最小值，显然不会再出现最优解；所以只有当小于之前求的最小值的时候，才继续递归下去 
				{
					x[t] = centerx;
					Backtrack(t+1);
				}
				swap(r[t],r[j]);
			}
		}
	}
}

float CirclePerm(int n,float *a)
{
	Circle X;
	X.n = n;
	X.r = a;
	X.min = 999999;
	float *x = new float[n+1];
	X.x = x;
	X.Backtrack(1);
	delete[] x;
	return X.min;

}

int main(void)
{
	Circle circle;
	float a[LENGTH+1] = {0,1,2,3,4,5,6,7,8,9,10};
	cout<<"最小值为："<<CirclePerm(LENGTH,a)<<endl;
	return 0;
}

第二种方法

#include <iostream>
#include <ctime>#include <iostream>
#include <math.h>
#include <ctime>

#define LENGTH 10

using namespace std;

class Circle
{
	friend float CirclePerm(int,float *);
private:
	float Center(int t);	//计算当前序列中圆心得坐标 
	void Compute(void);		//计算距离 
	void Backtrack(int t);	//递归，全排列 
	void solve();
	float min,				//最优解
	      *x,				//记录院系坐标 
	      *r;				//记录全排列过程中的圆序列（用半径表示） 
	int n;					//序列中圆的个数 
};

float Circle::Center(int t)
{	
	float temp = 0;
	for(int j = 1;j<t;j++)
	{
		float valuex = x[j] + 2.0 * sqrt(r[t]*r[j]);
		if(valuex>temp)
			temp = valuex;
	}
	return temp;
}

void Circle::Compute(void)
{
	float low = 0,high = 0;		//low表示左边第一个圆的最左边坐标，肯定为负值（因为左边第一个圆圆心为0），high记录右边第一个圆最右边坐标，右边第一个圆的坐标多一个半径 
	for(int i=1;i<=n;i++)
	{
		if(x[i]-r[i]<low)	
		{
			low = x[i]-r[i];
		}
		if(x[i]+r[i]>high)
		{
			high = x[i]+r[i];
		}
	}
	if(high>low&&high-low<min)
	{
		min = high-low;		//high-low的值为当前序列圆的总长度 
	}
}
/*
全排列去重条件
每一位置的元素，只可以与其之后的相同的元素交换一次。比如之后又两个2，那么只与第一个2交换。 
*/
int isSwap(float *r,int start,int end)
{
	for(int i=start;i<end;i++)
	{
		if(fabs(r[i]-r[end])<1e-6)
		{
			return 0;
		}
	}
	return 1;
}

/*
 *递归求全排列 
 * */
void Circle::Backtrack(int t)
{
	if(t>n-1)			
	{
		x[n] = Center(n);
		Compute();
	}else
	{
		for(int j = t;j<n;j++)	  //只全排列到n-1 
		{
			if(isSwap(r,t,j))
			{
				swap(r[t],r[j]);
				float centerx = Center(t);
				if(centerx+r[t]+r[1]<min)	//剪枝条件：如果现在长度已经超过之前求得的最小值，显然不会再出现最优解；所以只有当小于之前求的最小值的时候，才继续递归下去 
				{
					x[t] = centerx;
					Backtrack(t+1);
				}
				swap(r[t],r[j]);
			}
		}
	}
}

void Circle::solve()
{
	int num[LENGTH*LENGTH][2];
	int count = 0;
	for(int i=1;i<=LENGTH;i++)
	{
		for(int j=1;j<=LENGTH;j++)
		{
			if(r[i]<=r[j]&&i!=j)
			{
				num[count][0] = i;
				num[count++][1] = j;
 			}
		}
	}
	for(int i=0;i<count;i++)
	{
		int a = num[i][0],b = num[i][1];
		swap(r[a],r[1]);
		swap(r[b],r[n]);
		x[1] = 0;
		Backtrack(2);
	}
}

float CirclePerm(int n,float *a)
{
	Circle X;
	X.n = n;
	X.r = a;
	X.min = 999999;
	float *x = new float[n+1];
	X.x = x;
	X.solve();  // 先把符合条件的第一位和第n位保存在num数组中，然后直接全排列 2~n-1位 
	delete[] x;
	return X.min;

}

int main(void)
{
	clock_t start,end;
	Circle circle;
	start = clock();
	float a[LENGTH+1] = {0,1,2,3,4,5,6,7,8,9,10};
	cout<<"最小值为："<<CirclePerm(LENGTH,a)<<endl;
        end = clock();
	cout<<"time is: "<<end-start<<"  ms"<<endl;
	return 0;
}

第三种方法

#include <iostream>
#include <ctime>
#include <math.h>
using namespace std;
class Circle {
	friend float CirclePerm(int, float*);
private:
	float Center(int t);
	void Compute(void);
	void Backtrack(int t);
	float 	min, 
			*x, 
			*r;
	int n,
		flag=0;   //flag为 1，表示进入2~n-1全排列（不再干扰），为 0表示正在筛选第n位大于等于第一位 
};

float Circle::Center(int t)
{	
	float temp = 0;
	for(int j = 1;j<t;j++)
	{
		float valuex = x[j] + 2.0 * sqrt(r[t]*r[j]);
		if(valuex>temp)
			temp = valuex;
	}
	return temp;
}

void Circle::Compute(void)
{
	float low = 0,high = 0;		//low表示左边第一个圆的最左边坐标，肯定为负值（因为左边第一个圆圆心为0），high记录右边第一个圆最右边坐标，右边第一个圆的坐标多一个半径 
	for(int i=1;i<=n;i++)
	{
		if(x[i]-r[i]<low)	
		{
			low = x[i]-r[i];
		}
		if(x[i]+r[i]>high)
		{
			high = x[i]+r[i];
		}
	}
	if(high-low<min)
	{
		min = high-low;		//high-low的值为当前序列圆的总长度 
	}
}

int isSwap(float* r, int start, int end)
{
	for (int i = start; i < end; i++)
	{
		if (fabs(r[i]-r[end])<1e-6)
		{
			return 0;
		}
	}
	return 1;
}
/*
去除镜像思路：去除镜像，保证第一位小于等于第n位。 
		以下代码思路：第一位正常与其后元素交换，到第二位时筛选出比第一位大的数，然后交换给n位元素，从而保证首尾达到去除镜像条件，然后全排列 2~n-1位。
		
去除重复思路：每一位元素只与其后相同数值的元素交换一次 
*/
void Circle::Backtrack(int t) 
{
	if (t > n-1) {
		x[n] = Center(n);
		Compute();
	}
	else {
		for (int j = t; j <= n-flag; j++) 
		{
			if(isSwap(r,t,j))  //去除重复 
			{
				if(t==1||flag)
				{
					//全排列交换
					swap(r[t], r[j]);
					float centerx = Center(t);
					if (centerx + r[t] + r[1] < min) 
					{
						x[t] = centerx;
						Backtrack(t + 1);
					}
					swap(r[t], r[j]);
				}else 
				{
					if (r[j] >= r[1]) {
						flag = 1;
						swap(r[j], r[n]);
						Backtrack(2);		//筛选成功后，进入 2 ~ n-1 位元素的全排列（不再干扰） 
						swap(r[j], r[n]);
						flag = 0;
					}
				}
			} 
		}
	}
}

float CirclePerm(int n, float*a) 
{
	Circle X;
	X.n = n;
	X.r = a;
	X.min = 100000;
	float*x = new float[n + 1];
	X.x = x;
	X.flag = 0;	X.Backtrack(1);
	delete[] x;
	return X.min;
}

int main() 
{
	clock_t start, stop;
	int n;
	cout << "输入圆的个数：";
	cin >> n;
	float*a = new float[n + 1];
	cout << "输入各个圆的半径：";
	for (int i = 1; i <= n; i++) 
	{
		cin >> a[i];
	}
	start = clock();
	float result = CirclePerm(n, a);
	stop = clock();
	cout << "最小排列长度：" << result << endl;
	cout << "去镜像后的时间：" << stop - start << "ms" << endl;
	system("pause");
	return 0;
}