前言
本文介绍了一种基于博弈学习的分布式卫星任务规划
摘要
将多卫星系统中的自组织任务分配作为一种潜在的博弈,提出了一种分布式任务分配算法(DT2A)问题。
证明了博弈的每个纳什均衡构成了一个任务覆盖,使执行任务的数量最大化。
此外,我们还证明了所提出的DT2A在有限时间内以概率收敛到接近最优赋值。数值实验证明了该算法对偶然干扰的鲁棒性,并揭示了内存长度对求解效率细化的积极影响。在小规模和大规模场景下的比较实验突出了所提出的方法优于现有的分布式或集中的典型方法。
问题建模
多卫星任务分配
考虑一个地球观测星座,它由一组卫星
S
=
{
s
i
∣
i
∈
N
}
S=\{s_i|i∈N\}
S={si∣i∈N}组成,其中
N
=
{
1
,
2
,
.
.
.
,
n
}
N = \{1,2,...,n\}
N={1,2,...,n}。每个
s
i
s_i
si都是由其绕飞行轨道
o
i
o_i
oi,观察类别(光学或雷达)、摇摆范围、存储容量以及两个相邻任务实现之间的最短时间间隔。用
R
=
{
r
j
∣
j
∈
M
}
R =\{r_j| j∈M\}
R={rj∣j∈M}、
M
=
{
1
,
2
,
.
.
.
,
m
}
M = \{1,2,...,m\}
M={1,2,...,m}表示客户端请求集,每个
r
j
r_j
rj是与一个观察类别、要观察的网格区域和最小存储要求相关联的元任务。
对于
s
i
s_i
si,表示其由
A
i
f
A_i^f
Aif设置的可行任务,它由位于其关注范围(FOR)内的任务组成可以独立完成。
为了考虑执行效率,一个给定的
s
i
s_i
si的可行任务集被视为一个唯一的任务序列,按照与
s
i
s_i
si相遇的时间顺序执行。
如图1所示,{r2、r3、r4}表示 s i s_i si的r4→r2→r3的任务序列。如果对应的任务序列 r i 1 r_{i_1} ri1→ r i 2 r_{i_2} ri2→…→ r i n i r_{i_{n_i}} rini,则定义 s i s_i si的可行分配 a i a_i ai不违反操作约束,可行分配集用 A i A_i Ai表示。
为了考虑执行效率,一个给定的si的可行任务集被视为一个唯一的任务序列,按照与si相遇的时间顺序执行。如图1所示,{r2、r3、r4}为si的r4→r2→r3的任务序列。如果对应的任务序列 r i 1 r_{i_1} ri1→ r i 2 r_{i_2} ri2→ r i 3 r_{i_3} ri3→… A i A_i Ai的可行分配rini不违反操作约束,可行分配集用 A i A_i Ai表示。因此,任务分配空间用 ∏ i = 1 n A i \prod_{i=1}^n A_i ∏i=1nAi表示,其中一个 { a 1 , a 2 , . . . , a n } \{a_1,a_2,...,a_n\} {a1,a2,...,an}是对所有卫星的可行分配的组合。
为了简单的理论分析,我们假设
当且仅当卫星有共同的可执行任务时,可通过星间链路通讯。据此,定义s的邻域为 Ω i = { s j ∣ A i f ∩ A j f ≠ ∅ } \Omega_i = \{s_j|A_i^f ∩ A_j^f \neq\varnothing \} Ωi={sj∣Aif∩Ajf=∅}
观测成本
O
C
i
(
a
i
)
OC_i(a_i)
OCi(ai)和卫星运行侧摆成本
S
C
i
(
a
i
)
SC_i(a_i)
SCi(ai)共同构成了运行成本:
f
(
a
i
)
=
O
C
i
(
a
i
)
+
S
C
i
(
a
i
)
=
∑
j
=
1
n
i
{
c
i
(
r
i
j
)
+
λ
i
∣
θ
i
j
−
θ
i
,
j
−
1
∣
}
f(a_i) = OC_i(a_i) + SC_i(a_i)= \sum_{j=1}^{n_i}\{c_i(r_{ij})+\lambda_i|\theta_{ij} - \theta_{i,j-1}|\}
f(ai)=OCi(ai)+SCi(ai)=j=1∑ni{ci(rij)+λi∣θij−θi,j−1∣}
其中,
c
i
(
r
i
j
)
c_i(r_{ij})
ci(rij)是
s
i
s_i
si观测
r
i
j
r_{ij}
rij的成本,
c
i
(
r
i
j
)
c_i(r_{ij})
ci(rij)
对于每个
s
i
s_i
si
多卫星任务分配的目的是找到使总成本最小化的最优任务覆盖范围。在数学上,它可以表述为一个无约束最小化问题,其全局目标函数定义为
F
(
a
)
=
∑
i
=
1
n
f
i
(
a
i
)
+
∑
j
m
[
1
−
b
j
(
a
)
]
ω
j
F(a)=\sum_{i=1}^{n}f_i(a_i) + \sum_{j}^{m}[1 − b_j(a)]\omega_j
F(a)=i=1∑nfi(ai)+j∑m[1−bj(a)]ωj
其中的第二部分是通过任务优先级权重
ω
j
\omega_j
ωj对任何未响应的请求
r
j
r_j
rj进行惩罚。具体来说,
b
j
=
0
b_j = 0
bj=0表示没有卫星选择任务
r
j
r_j
rj,而
b
j
=
1
b_j = 1
bj=1表示选择。
等效性分析
证明了F (a)的最优解与最优任务覆盖度之间的等价性。
定义
T
0
(
a
)
=
{
r
j
∣
b
j
(
a
)
=
0
,
j
∈
M
}
T_0(a) = \{r_j|b_j(a) = 0,j∈M\}
T0(a)={rj∣bj(a)=0,j∈M}组成的未分配任务集
定理一:
.如果
∀
j
∈
M
∀j∈M
∀j∈M,
ω
j
>
m
a
x
i
∈
N
f
(
A
i
f
)
ω_j>max_i∈N_f(A_i^f)
ωj>maxi∈Nf(Aif),则(2)的最优解必须是使总成本最小化的最优任务覆盖。
定理二:
网络势博弈
针对多卫星任务分配中的自组织问题,我们将网络博弈
G
=
(
S
,
A
i
,
U
i
)
G=(S,{A_i},{U_i})
G=(S,Ai,Ui)视为一个自主和理性的参与者。
从博弈论的角度来看,一个可行的任务分配
a
i
∈
A
i
a_i∈A_i
ai∈Ai被定义为一个动作,而每个任务分配的profile一个
a
∈
A
a∈A
a∈A被称为联合动作(a joint action)。
为了使局部效益
U
i
U_i
Ui最大化,每个玩家
s
i
s_i
si仅基于
i
i
i中的邻域信息从其动作集
A
i
A_i
Ai中迭代地选择其动作。
对于基于竞争博弈论的分布式协调和优化,纳什均衡、潜在博弈等定义的概念起着重要的作用,以下为相关的定义:
定义1(纳什均衡):对于有限策略博弈
G
=
(
S
,
A
i
,
U
i
)
G=(S,{A_i},{U_i})
G=(S,Ai,Ui),一个联合行动
a
∈
A
a∈A
a∈A被称为纳什均衡,如果任何参与者不能从单边偏离当前行动
a
i
a_i
ai中获益
∀
i
∈
N
,
U
i
(
a
i
,
a
−
i
)
=
m
a
x
a
~
i
∈
A
i
U
i
(
a
~
i
,
a
−
i
)
∀i∈N,U_i(a_i,a_{−i})=max_{\widetilde{a}_i∈A_i}U_i(\widetilde{a}_i,a_{−i})
∀i∈N,Ui(ai,a−i)=maxa
i∈AiUi(a
i,a−i)
定义2(潜在博弈):一个(精确的)潜在博弈被一个有限策略博弈
G
=
(
S
,
A
i
,
U
i
)
G=(S,{A_i},{U_i})
G=(S,Ai,Ui)去定义,如果存在一些潜在函数
φ
:
A
→
R
φ:A→\mathbb{R}
φ:A→R,
U
i
(
a
~
i
,
a
−
i
)
−
U
i
(
a
i
,
a
−
i
)
=
φ
(
a
~
i
,
a
−
i
)
−
φ
(
a
i
,
a
−
i
)
U_i(\widetilde{a}_i,a_{−i})−U_i(a_i,a_{−i})=φ(\widetilde{a}_i,a_{−i})−φ(a_i,a_{−i})
Ui(a
i,a−i)−Ui(ai,a−i)=φ(a
i,a−i)−φ(ai,a−i)适用于每一个
i
∈
N
i∈N
i∈N,每一个
∈
a
∈a
∈a,和每一个动作
a
~
∈
A
i
\widetilde{a}∈A_i
a
∈Ai
定义3(convention):表示从迭代t + 1−l到t的联合动作序列(在+1−l,在+2−l,…,at)。
如果每个元素都是相同的纳什均衡a,那么
h
l
t
h_l^t
hlt被称为convention。通过使用wonderful-life utility(具体参考论文XX )将系统级目标F(a)分解为每个个体,我们建立了以下潜在的博弈。
定理2
任务分配博弈
G
=
(
S
,
A
i
,
U
i
)
G=(S,{A_i},{U_i})
G=(S,Ai,Ui)是一个潜在的博弈,如果选择潜在函数
φ
(
a
)
φ(a)
φ(a)和局部收益
U
i
(
a
)
U_i(a)
Ui(a)为
ϕ
(
a
)
=
−
F
(
a
)
\phi(a)=-F(a)
ϕ(a)=−F(a)
U
i
(
a
)
=
−
f
(
a
i
)
−
∑
k
∈
U
i
(
a
)
ω
k
U_i(a)=-f(a_i)-\sum_{k∈\mathcal{U}_i(a)}\omega_k
Ui(a)=−f(ai)−∑k∈Ui(a)ωk
其中
U
i
(
a
)
=
A
i
f
∩
T
0
(
a
)
U_i(a) = A_i^f∩T_0(a)
Ui(a)=Aif∩T0(a)是对
s
i
s_i
si可行的未分配任务集
利用势博弈,其中势函数的优化器必须是纳什均衡,分布式任务分配问题可以通过获得纳什均衡并尽可能将其细化为全局最优性。
注意,由于
ω
j
ω_j
ωj可以设置为任意大的整数,因此不需要全局信息来保证定理1的满足
定理3对于任务分配博弈 G = ( S , A i , U i ) G=(S,{A_i},{U_i}) G=(S,Ai,Ui),每个纳什均衡 a ∈ A a∈A a∈A必须是一个没有重复分配任务的任务覆盖。
算法设计
3.1.分布式任务分配算法(DT2A)
**Require:**卫星集
S
S
S、客户端请求
R
R
R、观测成本、目标角度、成本系数
λ
i
λ_i
λi、任务
优先级权重
ω
i
ω_i
ωi、内存长度
l
l
l;
**Ensure:**任务覆盖的方案 随机初始化一个1和
M
1
M^1
M1
对于每个迭代
t
=
1
,
2
,
.
.
.
t = 1,2,...
t=1,2,...,执行
对于每个卫星
s
i
∈
S
s_i∈S
si∈S,同步地执行
a
i
t
a_i^t
ait与邻域交换信息;
计算
U
i
U_i
Ui,
B
i
t
B_i^t
Bit,
R
i
t
R_i^t
Rit;
R
i
t
R_i^t
Rit与邻域交换信息;
检查它是否是一个innovater;
计算
β
i
t
β_i^t
βit并更新
M
i
t
M_i^t
Mit;
随机更新到
a
i
t
+
1
a_i^{t+1}
ait+1;
结束循环
结束循环
为了平衡解决效率和收敛速度,我们通过给每个玩家分配一个大小为 l l l的有限内存来引入随机性。具体来说,第t次迭代中的内存向量用 M i t = ( v 1 , v 2 , . . . , v l ) , a i ∈ A i M_i^t =(v_1,v_2,...,v_l),a_i∈A_i Mit=(v1,v2,...,vl),ai∈Ai表示,内存配置文件用 M t = { M 1 t , M 2 t , . . . , M n t } M_t = \{M_1^t,M_2^t,...,M_n^t\} Mt={M1t,M2t,...,Mnt}表示。对于在地面上生成的一组给定请求R,我们假设一个广播机制,通过该机制所有卫星都可以被告知完整的任务集。在此基础上,每个si计算其可行任务集Ai f,并得到可行分配集Ai。
为了启动分布式任务分配,每个卫星从
A
i
A_i
Ai中随机选择在=1i和Mt=1 i初始化。在此之后,主要的协调过程以一种同步的方式实现。
在每次迭代t中,玩家只在i处与他们的邻域在i中交换当前的动作信息,基于(6)中的局部效用
U
i
t
U_i^t
Uit、最佳响应
B
i
t
B_i^t
Bit和遗憾值
R
i
t
R_i^t
Rit来计算
B
i
t
=
arg
max
a
~
i
∈
A
i
U
i
(
a
i
t
,
a
−
i
t
)
B_i^t = \mathop{\arg\max} \limits_{\widetilde{a}_i∈A_i}U_i(a_i^t,a_{-i}^t)
Bit=a
i∈AiargmaxUi(ait,a−it)
R
i
t
=
U
i
(
B
i
t
,
a
−
i
t
)
−
U
i
(
a
i
t
,
a
−
i
t
)
R_i^t = U_i(B_i^t,a_{-i}^t) - U_i(a_i^t,a_{-i}^t)
Rit=Ui(Bit,a−it)−Ui(ait,a−it)
用 R i t ∗ = m a x j ∈ Ω i R j t R_i^{t*}=max_{j∈\Omega_i}R_j^t Rit∗=maxj∈ΩiRjt表示i中的最大遗憾值,ID编号用 j ∗ = m i n ( arg max a ~ i ∈ A i R j t ) j∗= min(\mathop{\arg\max} \limits_{\widetilde{a}_i∈A_i}R_j^t) j∗=min(a i∈AiargmaxRjt)
如果同时满足以下两个条件,si将被定义为innovator:
(1)它在
Ω
i
\Omega_i
Ωi中有最大的正遗憾值,
即
R
i
t
>
0
,
R
i
t
>
R
j
t
,
∀
s
j
∈
Ω
i
R_i^t>0,R_i^t>R_j^t,∀s_j∈\Omega_i
Rit>0,Rit>Rjt,∀sj∈Ωi
(2)任何
j
<
i
j<i
j<i的邻域
∀
s
j
∈
Ω
i
∀s_j∈\Omega_i
∀sj∈Ωi
∀
j
<
i
,
R
j
t
<
R
i
t
∀j<i,R_j^t<R_i^t
∀j<i,Rjt<Rit
否则, s i s_i si就会被称为普通player。对于innovator,在任何给定的邻域i中,最多有一个创新者参与者。
仿真结果
为了评估DT2A在多卫星自组织任务分配中的有效性,并证明其与现有方法的优越性,本节通过蒙特卡罗模拟平均100多个独立运行的数值结果。
纳什均衡的生成和细化
首先,我们考虑一组n个=5个成像卫星,其地面轨迹如图2所示。
每颗卫星都配备了一个光学摄像机,用于收集地面信息,侧向摇摆范围为±25◦,摇摆成本系数为
λ
i
=
10
λ_i = 10
λi=10。为了验证我们的方法在纳什均衡解生成和细化中的有效性,在重叠区域生成了一组= 10
任务:
(1)经度120W-60W和纬度30N-60N;
(2)经度30W-30E和纬度60S- 30S;
(3)经度60E-120E和30N-60N。
由于本文关注的是分布式协调机制,因此由矩阵
C
n
×
m
C_{n×m}
Cn×m和
D
n
×
m
D_{n×m}
Dn×m给出了可行集,每个
c
i
j
c_{ij}
cij和
d
i
j
d_{ij}
dij表示
s
i
s_i
si执行
r
j
r_j
rj时的观测代价和目标摇摆角
在
C
1
C_1
C1和
D
1
D_1
D1,它需要
s
2
s_2
s2的成本
c
26
=
74
c_{26} = 74
c26=74观察第6个网格摇摆角
d
26
=
15
d
°
d_{26}=15d°
d26=15d°,而
c
43
=
∞
c_{43} =∞
c43=∞,
d
43
=
∞
d_{43} =∞
d43=∞表明
r
3
r_3
r3是一个不可执行的任务。据此,相关网格区域位于
s
4
s_4
s4的。因此,得到了
s
2
s_2
s2和
s
4
s_4
s4的可行集,分别为
A
2
f
=
{
r
j
∣
j
=
1
、
2
、
5
、
6
、
7
、
8
}
A_2^f = \{r_j| j = 1、2、5、6、7、8\}
A2f={rj∣j=1、2、5、6、7、8}和
A
4
f
=
{
r
j
∣
j
=
2
、
4
、
5
、
6
、
7
、
9
、
10
}
A_4^f = \{r_j| j = 2、4、5、6、7、9、10\}
A4f={rj∣j=2、4、5、6、7、9、10}。假设
A
i
f
A_i^f
Aif的每个子集都有一个满足操作约束的可行分配,分配轮廓空间a的基数为
∣
A
∣
=
2
30
≈
109
|A| = {2^{30}}≈109
∣A∣=230≈109。
实验
假设有5个卫星和10组任务,则设C和D为5*10的矩阵
有矩阵
C:
[
36
3
33
0
33
0
70
0
0
0
39
64
67
97
0
84
0
22
0
0
0
0
73
72
0
0
0
0
93
83
0
0
0
0
49
28
0
0
80
14
0
0
0
0
0
32
21
0
0
62
]
\begin{bmatrix} 36&3&33&0&33&0&70&0&0&0 \\ 39 & 64 & 67 & 97 & 0 & 84& 0 & 22& 0& 0 \\ 0& 0& 73 & 72 & 0& 0& 0& 0& 93& 83\\ 0& 0& 0& 0& 49& 28& 0& 0& 80& 14\\ 0& 0& 0& 0& 0& 32& 21& 0& 0& 62\ \end{bmatrix}
36390003640003367730009772003300490084028327000021022000009380000831462
卫星星执行任务载荷能量消耗矩阵,0表示无法执行该任务
D:
[
−
14
−
6
−
4
0
13
0
−
19
0
0
0
−
20
−
21
−
11
15
0
−
1
0
−
11
0
0
0
0
17
21
0
0
0
0
−
15
13
0
0
0
0
17
19
0
0
18
2
0
0
0
0
0
4
24
0
0
11
]
\begin{bmatrix} -14&-6&-4&0&13&0&-19&0&0&0 \\ -20& -21& -11 & 15 & 0 & -1& 0 &-11& 0& 0 \\ 0& 0& 17 & 21& 0& 0& 0& 0& -15& 13\\ 0& 0& 0& 0& 17& 19& 0& 0& 18& 2\\ 0& 0& 0& 0& 0& 4 & 24& 0& 0&11\ \end{bmatrix}
−14−20000−6−21000−4−111700015210013001700−10194−19000240−1100000−151800013211
卫星执行任务侧摆角度 0表示无法执行该任务
FT:需要执行的任务数量,和每个任务的编号
从上到下分别为每个卫星能够执行的任务编号
[ 5 1 2 3 5 7 0 0 0 0 6 1 2 3 4 6 8 0 0 0 4 3 4 9 10 0 0 0 0 0 4 5 6 9 10 0 0 0 0 0 3 6 7 10 0 0 0 0 0 0 ] \begin{bmatrix} 5&1&2&3&5&7&0&0&0&0 \\ 6& 1& 2&3&4&6&8 &0& 0& 0 \\ 4& 3& 4& 9& 10& 0& 0& 0& 0& 0\\ 4& 5& 6& 9& 10& 0& 0& 0& 0& 0\\ 3& 6& 7& 10& 0& 0& 0& 0& 0&0\ \end{bmatrix} 56443113562246733991054101007600008000000000000000000
完整策略是由{-1,0,1}组成的一个M行1列的矩阵,-1表示无法完成此任务,1表示执行此任务,0表示不执行此任务
[
1
1
0
−
1
0
−
1
1
−
1
−
1
−
1
0
0
1
1
−
1
0
−
1
1
−
1
−
1
−
1
−
1
0
0
−
1
−
1
−
1
−
1
1
1
−
1
−
1
−
1
−
1
1
1
−
1
−
1
0
0
−
1
−
1
−
1
−
1
−
1
1
0
−
1
−
1
0
]
\begin{bmatrix} 1&1&0&-1&0&-1&1&-1&-1&-1\\ 0& 0& 1&1&-1&0&-1&1& -1& -1\\ -1& -1& 0& 0& -1& -1& -1& -1& 1& 1\\ -1& -1& -1& -1& 1& 1& -1& -1& 0 &0\\ -1& -1& -1& -1& -1& 1& 0& -1& -1&0\ \end{bmatrix}
10−1−1−110−1−1−1010−1−1−110−1−10−1−11−1−10−1111−1−1−10−11−1−1−1−1−110−1−1−1100
方法
constexpr int MEMORY_LENGTH = 13; // 存储器长度
constexpr int TMAX = 16; // 最大迭代步数
constexpr int M = 10; // 客户端请求数量
constexpr int N = 5; // 卫星数量
constexpr double SWAY_COEFF = 10; // 侧摆代价效率
constexpr double UNCOVER_WEIGHT = 1000; // 未执行任务的惩罚系数
double ccost; // 当前任务总代价
double regret; // 遗憾值
Mat matC; // 每个任务的观测代价
Mat matD; // 每个任务的侧摆角
vector<uint32_t> feasibleStrategy; // 每个卫星的可执行策略编号
下列数据为按位运算变量,从高位开始
uint32_t csid, nsid, bestsid; // 当前策略编号,下一个策略编号,局部最优策略编号
uint32_t cstrategy; // 当前执行策略,1表示执行此任务,0表示不执行此任务
uint32_t neighbor=0; // 每个卫星的邻居集
uint32_t feasibleTask=0; // 每个卫星的可执行任务编号
SID_to_ImplementStrategy:根据策略编号计算执行策略
TotalStrategy_to_SID:计算策略编号
Strategy_Cost:计算当前个体采取给定执行策略的任务总代价
CountSetBits:计算执行了任务的收益
srand(time(0));
matC // 卫星执行任务载荷能量消耗矩阵 0表示无法执行该任务
matD // 卫星执行任务侧摆角度 0表示无法执行该任务
matFT// 需要执行的任务数量,和每个任务的编号
matNeighbor // 每个卫星的邻居数量,和每个邻居的编号
Agent stlt[N]; // N个卫星(satellite)
S; //随机的策略
matdata; // 临时数据
int intdata; // 临时数据
uint32_t task; // 一组任务的标志位
uint32_t ims; // 执行策略
double cost, cost1, cost2; // 总收益,执行了任务的收益,个体的代价
double maxvalue; uint32_t maxvaluei; // 最大值和最大值索引
//主要的函数如下
uint32_t NE; // 达到纳什均衡的个体数量
for (int t = 0; t < TMAX; t++) { // 分布式协调
NE = 0;
for (int i = 0; i < N; i++) { // 每个个体计算当前最优策略
task = 0;
for (int j = 0; j < N; j++) // 计算个体的所有邻居执行策略后的未覆盖任务
if (stlt[i].neighbor & (1 << (N-1-j))) // 是当前个体的邻居
task |= stlt[j].cstrategy; // 每个邻居个体依次执行自己的策略并更新任务标志位
task ^= (1<<M) - 1; // 将任务标志位取反表示尚未执行的任务
task &= stlt[i].feasibleTask; // 尚未执行并且可以由当前个体执行的任务
maxvalue = 0;
if (task) { // 当存在可执行的任务时,求当前最优策略
for (uint32_t j: stlt[i].feasibleStrategy) { // 在可执行任务中选择收益最大的任务
ims = stlt[i].SID_to_ImplementStrategy(j); // 根据策略编号计算执行策略
cost1 = UNCOVER_WEIGHT * CountSetBits(task & ims); // 执行了任务的收益
cost2 = stlt[i].Strategy_Cost(ims); // 个体的代价
cost = cost1 - cost2; // 每个策略的总收益
if (cost > maxvalue) // 求最优策略的代价值和编号
{ maxvalue = cost; maxvaluei = j; }
}
stlt[i].bestsid = maxvaluei; // 局部最优策略
}
else // 当没有可执行的任务时,最优策略为0
stlt[i].bestsid = 0;
cost1 = UNCOVER_WEIGHT * CountSetBits(task & stlt[i].cstrategy);
cost2 = stlt[i].Strategy_Cost(stlt[i].cstrategy);
cost = cost1 - cost2; // 计算当前策略的收益
stlt[i].regret = maxvalue - cost; // 计算遗憾值
if (stlt[i].regret == 0) // 0表示达到纳什均衡
NE++;
else if (stlt[i].regret < 0)
cout << "regret error!" << endl;
}
maxvalue = 0;
for (int i = 0; i < N; i++) { // 计算所有个体中的最大遗憾值
if (stlt[i].regret > maxvalue)
{ maxvalue = stlt[i].regret; maxvaluei = i; }
}
for (int i = 0; i < N; i++) { // 每个个体更新策略
if (maxvalue == 0)
stlt[i].nsid = stlt[i].csid;
else if (i == maxvaluei)
stlt[i].nsid = stlt[i].bestsid;
else
stlt[i].nsid = stlt[i].csid;
stlt[i].Update();
}
if (NE == N) // 所有个体都达到了纳什均衡
break;
}
task = 0;
for (int j = 0; j < N; j++) {
ims = stlt[j].SID_to_ImplementStrategy(stlt[j].nsid);
stlt[j].ccost = stlt[j].Strategy_Cost(ims);//更新当前任务总代价
task |= ims;
}
cout << Global_Fit(stlt, task) << endl;
for (int i = 0; i < N; i++)
cout << stlt[i].nsid << endl;
return 0;
}