多目标Pareto最优解集构造方法（伪代码）

构造Pareto最优解集的简单方法

算法的时间复杂度为O(N²)

Deb的非支配排序方法

设进化群体为P，同时设置一个构造集P’。算法开始时将第一个个体放入构造集P’中，依次将进化群体P中的个体p取出并放入构造集P‘中，同时将当前取出的p依次与P’中的所有个体进行比较，删除P’中所有被p支配的个体，若个体p被P‘中任意一个个体所支配，则将p中P‘中删除。

• 算法1

P' = find_nondominated_front(P)
P' = {1}	//把第一个个体放入P‘中
for each (p in P) and (p not in P')
{
	P' = P' + {p}
	for each (q in P') and q != p
	{
		if p dominate q then	//如果p支配q
			P' = P' - {q}
		else if q dominate p then
			P' = p' - {p}
	}
}

在最坏情况下，即P中所有个体均为非支配个体时，总比较次数：
1+2+3+···+(N-1) = N²/2
每次比较时有r个子目标，时间复杂度为O(rN²)

用排除法构造非支配集

将进化群体Pop中的每个个体X依次与非支配集NDSet（开始时为空）中的个体Y比较，如果X支配Y，说明Y是被支配个体，将Y从NDSet中删除。如果X不被NDSet中任何一个个体所支配，则将X并入NDSet中。当NDSet为空/初始时，直接将X并入NDSet。

• 算法2

NDSet = null;	//初始时为空
for each X in Pop
{
	dominated_sign = True
	if(isEmpty(NDSet)) then	//当NDSet为空时
		NDSet = NDSet + {X}
	else
		each Y in NDSet
		{
			if(X dominate Y) then
				NDSet = NDSet - {Y}
			else if (Y dominate X) then
				dominated_sign = False
		}
	if (dominated_sign) then
		NDSet = NDSet + {X}
}

最坏情况下时间复杂度为O(rN²)。
当非支配集｜NDSet｜比较小时效率比较高。

算法2的执行效率比算法1高
、若当前比较个体p多次被P’中其他个体支配时，算法1将多次重复执行删除操作
、在执行过程中出现空集的情况，这种情况下，算法2只需要将从进化群体中取出的当前个体放入NDSet中即可

将构造集与非支配集分开，初始时设构造集NDSet1为进化群体Pop，非支配集NDSet为空。将构造集NDSet1中不同个体X依次与其他个体Y比较（包括非支配集中个体），若X支配Y，则将Y从构造集NDSet1中清除；在一轮比较后若X不被任何其他个体支配，则X是非支配的，将X并入非支配集NDSet中。无论在任何时候，NDSet中的个体一定是非支配的。

• 算法3
  函数调用：NDSet = find_nondominated_set2(Pop)

NDSet = null
NDSet1 = Pop
while |NDSet1| > 1 do
{
	sign = True
	X = first(NDSet1)		//X为NDSet中第一个个体
	NDSet1 = NDSet1 - {X}
	for each Y in (NDSet1 or NDSet)
	{
		if (X dominate Y) then
			NDSet1 = NDSet1 - {Y}
		else if (Y dominate X) then
			sign = False
	}
	if (sign) then
		NDSet = NDSet + {X}
}
NDSet = NDSet + NDSet1

最坏情况下，即当｜NDSet｜= 1 ，且这个唯一的非支配个体是Pop中最后一个个体，且前面（N-1）个个体不存在支配关系，此时比较次数为N²/2。此外当｜NDSet｜ = N时，比较次数也为N²/2。在最坏情况下的时间复杂度为O(rN²)。
算法3的效率与非支配个体的分布也有很大关系，若非支配个体分布在序列的前面，则算法的效率就高一些。

用庄家法则构造Pareto最优解集

设P为一进化群体，Q为构造集，初始时Q=P，NDSet为非支配集，初始时为空。从Q中任取一个个体，依次与所有其他个体比较，将被该个体所支配的个体从Q中删除，如果该个体没有被其他任何一个个体所支配，则它是非支配的，将它并入非支配集NDSet中，否则也从Q中清除该个体。

• 算法4
  函数调用：Function NDs(Pop:population)

Q = Pop
while(isNotEmpty(Q)) do		//Q不为空时
{
	x in Q, Q = Q - {x}		//从Q中取一个个体
	x-is-undominated = True
	for each y in Q
	{
		if(x dominate y) then
			Q = Q - {y}
		else if (y dominate x) then 
			x-is-undominated = False
	}
	if(x-is-undominated) then
		NDSet = NDSet + {x}
}

个人感觉算法3和算法4差别不大
算法3是从构造集中取出一个个体与构造集和非支配集中所有个体比较
算法4是从构造集中取出一个个体，只与非支配集中个体进行比较
（如果理解不对，烦请指正，我也是刚开始学的小白，谢谢🙏）

用擂台赛法则构造Pareto最优解集

设P为一进化群体，Q为构造集，初始时Q=P；NDSet为非支配集，初始时为空。从Q中任取一个个体x，依次与Q中所有其他个体y比较，如果x支配y，则将个体y从Q中清除；如果y支配x，则用y替代x（即产生新的擂台主），并继续进行比较。一轮比较后，形成族cluster(x) = {y|x dominate y,且x，y in P}，x为最小元，将x并入非支配集NDSet中。以此下去，直至Q为空。
产生了新的擂台主，需要记录最后以此替换操作的有关信息。因为在更新操作之前被保留下来的个体可能是被最新擂台主所支配的。那么最新的擂台主必须回过头去找出这样的被它所支配的个体并清除。

• 算法5
  函数调用：Function establish-Nds(Pop:population)

Q = Pop
sign-count2 = 0
while(|Q| > 1) do 
{
	X in Q,Q = Q - {X}
	sign = False
	sign-count1 = 0
	while((sign-count2 > 0) and (V2 dominate X)) do		
	//找到第一个不被V2支配的个体，即不被上次循环确定的非支配个体所支配的个体
	{
		X = succeed(X)
		sign-count2 = sign-count2 - 1
	}
	for each Y in Q
	{ 
		if (sign-count2 > 0) then
		{
			sign-count2 = sign-count2 -1
			if((X dominate Y) or (V2 dominate Y)) then
				Q = Q - Y
			if(Y dominate X) then
			{
				X = Y
				V1 = Y
				sign = True
				sign-count1 = the position of Y
			}
		}
		else if (X dominate Y) then 
			Q = Q - {Y}
		else if (Y dominate X) then
		{
			X = Y
			V1 = Y
			sign = True
			sign-count1 = the position of Y
		}
		Nds = Nds + {X}
		if (sign) then
		{
			sign-count2 = sign-count1
			V2 = V1
		}
	}
}
if (|Q| == 1) then
	Nds = Nds + Q
return establish_Nds

算法在最坏情况下的时间复杂度为O(rmN)，其中r为优化目标的个数
当非支配个体在进化群体中所占比例比较小时，擂台赛法具有比较高的构造效率，一般情况下m<=N/2，所以擂台赛法则具有较好的使用价值。

其实这部分代码我有点一知半解，就是即将看明白，但是还不是很明白，有没有大佬点我一下子。

用递归方法构造Pareto最优解集

假定在同一目标上没有相同的值，主过程Non-dominated-sort(S,M)带两个参数，其中S为进化群体，M为目标数。在主过程中（算法6-1），对每个个体s in S设置一个函数值f[s]，用于表示该个体所对应的边界层次。初始时将f[s]的额值均置为1，即在初始时认为S中所有个体均在第一层边界上。通过调用ND-helper_A(S,M)（算法6-2），使f[s]返回个体s所对应的边界层次。显然，所有f[s]=1(s in S)的个体s均为非支配的。但当待优化问题只有两个目标时（即M=2），则作为特殊情况处理，直接调用算法7，而不需要递归调用。
在递归过程ND-helper_A(S,M)中（算法6-2），S为进化群体，M为目标数，M个子目标分别表示为x₁…x_M。当S中只有两个个体时（即｜S｜=2），则将这连个个体进行比较。若s₁支配s₂，则令f[s₂]=max(f[s₁]+1,f[s₂])；若s₂支配s₁，则令f[s₁]=max(f[s₁],f[s₂]+1)。当S中个体大于2时，则将S分割为两个大小相等的子集L和H，即set(L,H)=split(S,x_M^split,M)。分割时，取第M个目标的中值x_M^split，然后将所有的第M个目标值小于等于x_M^split的个体放入L中，高于x_M^split的则放入H中。由此可知，L中的任何一个个体均不被H中个体所支配，因为有(任意s₁ in L) and (任意s₂ in H) >>>x_M(s₁)<x_M(s₂)。这样，通过进一步递归调用ND-helper_A(L,M)来构造L的非支配集，且在构造L的非支配集时就不需要考虑H。但H中的个体也有可能不被L中的个体所支配，因此在构造H的非支配集时必须考虑L。要判断s₂ in H是否被s₁ in L支配，需要调用ND-helper_B(L,H,M-1)（算法6-3）来比较L和H在前（M-1）个子目标上的支配关系。若s₁ in L支配s₂ in H，则令f[s₂]=max(f[s₁]+1,f[s₂])。此外，还需要判断H中的个体是否被H中其他个体所支配，因此需要调用ND-helper_A(H,M)。
其他情况下，处理要复杂一些：（这里我就蒙了）
1⃣️如果max(x_M(l₁),…,x_M(l_|L|))<=min(x_M(h₁),…,x_M(h_|H|))，表明在第M个目标上，L中个体比H中个体具有小的值。则直接调用ND-helper_B(L,H,M-1)。
2⃣️如果min(x_M(l₁),…,x_M(l_|L|))>max(x_M(h₁),…,x_M(h_|H|))，表明在第M个目标上，H中个体比L中个体具有小的值，这种情况下算法不需要做任何处理。（这是为什么啊？我不懂了，还有为什么会出现这种情况啊？）
3⃣️如果max(x_M(l₁),…,x_M(l_|L|))>min(x_M(h₁),…,x_M(h_|H|))，且min(x_M(l₁),…,x_M(l_|L|))<=max(x_M(h₁),…,x_M(h_|H|))，表明在第M个目标上，H中部分个体的值比L中个体小，同时H中部分个体的值又比L中个体大，在这种情况在，需要在H或L中针对第M个目标选取一个中值x_M^split，并将H分割为H₁和H₂，将L分割为L₁和L₂。然后分别递归调用ND-helper_B(L₁,H₁,M)、ND-helper_B(L₁,H₂,M-1)和ND-helper_B(L₂,H₂,M)

• 算法6-1
  函数调用：Non-dominated-sort(S,M)

for each s in S set f[s] = 1
{
	ND-helper_A(S,M)
	set F1 = null, F2 = null, ...
	for each s in S set Ff[s] = Ff[s] + {s}	//将S中元素加入对应层集中
	return (F1, F2, ...)
}

• 算法6-2
  函数调用：ND-helper_A(S,M)

if(|S| == 2) then
{
	sorting s
	and s2 by updating f[s1] and f[s2]
}
else if(|S| > 2) then
{
	set x_M_split = median(x_M(s1),...,x_M(s|S|))	//取中值
	set(L,H) = split(S,x_M_split,M)
	ND-helper_A(L,M)
	ND-helper_B(L,H,M-1)
	ND-helper_A(H,M)
}

• 算法6-3
  函数调用：ND-helper_B(L,H,M)

if(|L| == 1) then
{
	all h in H compare to l1 in L : update f[h]
}
else if(|H| == 1) then
{
	all l in L compare to h1 in H : update f[l]
}
else if (M == 2) then
{
	do 2D sorting of H according to L : update f[h] for h in H
}
else
{
	if(max(x_M(l1),..,x_M(l|L|)) <= min(x_M(h1),...,x_M(h|H|))) then
		ND-helper_B(L,H,M-1)
	else if(min(x_M(l1),..,x_M(l|L|)) <= max(x_M(h1),...,x_M(h|H|))) then
	{
		if(|L| > |H|) then
			set x_M_split = median(x_M(h1),...,x_M(l|L|))
		else
			set x_M_split = median(x_M(h1),...,x_M(h|H|))
		set(L1,L2) = split(L,x_M_split,M)
		set(H1,H2) = split(H,x_M_split,M)
		ND-helper_B(L1,H1,M)
		ND-helper_B(L1,H2,M-1)	//我不懂为什么只有这个是M-1
		ND-helper_B(L2,H2,M)
	}
}

针对两个目标优化问题构造非支配集

• 算法7
  函数调用：Non-dominated-sort-on-2D(S)

F1 = {s1}
A = 1
for( i = 2; i <= N; i = i + 1)	//N为S中个体个数
{
	/*F1，···，FA中保存非支配个体s1，···，s(i-1)，
	且F1，···，FA中个体均不被si，···，sN所支配*/
	if(si not dominated by FA) then	//si不被FA中个体所支配
	{
		找出最小的b，使si not dominated by Fb
		令Fb = Fb + {si}
	}
	else
	{
		A = A + 1
		FA = {si}
	}
}
return (F1,...,FA)

首先将S中个体排序为s₁,…,s_N，要满足条件i>>((x₁(s_i) < x₁(s_j)) or (x₁(s_i) = x₁(s_j))) and (x₂(s_i) < x₂(s_j))。用F₁保存第一层非支配个体，用F₂保存第二层非支配个体（即S中删除第一层非支配个体后的非支配个体），类似的，用F_A保存第A层非支配个体（即S中删除前A-1层非支配个体后的非支配个体。初始时，令F₁ = {s₁} , A= 1，然后一次判断个体s₂,…,s_N与F₁,…,F_A中个体之间的关系），并按他们之间的支配关系，将起保存到相应的F_i中(i=1…A , A >= 1)。

用快速排序方法构造Pareto最优解集

性质1：如果x和y不相关，且y dominate z ，则或者是x dominate z，或者是x和z不相关。
性质2:如果x dominat y，且y和z不相关，则或者是x domina z，或者x 和z不相关。
性质3:非支配集中的不同个体之间是彼此不相关的。
定义1:所有x, y in Pop , x dominate_d y iff x dominate y or x和y不相关。

用改进的快速排序方法构造Pareto最优解集