最近学了一波模拟退火。个人感觉，就是随机算法，然后我们的目标点，一开始温度T高的时候会移动的剧烈，T小的时候移动的缓和(所以这就是为什么每一次移动的距离都是乘T)。然后真正的模拟退火是如果当前的tem比ans优，那就毫不犹豫地接受，否则则以一定概率接受。也就是那个exp(dE/T)> rand 那个。

然后还有爬山算法，就是只会一直找更优解，不接受差解，具体就是在模拟退火基础上，一直找最优解，找不到就降温(所以会陷入局部最优解的坑)。在网上嫖了一份代码(https://blog.csdn.net/just_sort/article/details/51648958)

1 while(t>eps)

2 {

3 bool fuck = 1;

4 while(fuck)

5 {

6 fuck = 0;

7 for(int i=0; i<4; i++)

8 {

9 z.x = s.x+dir[i][0]*t;

10 z.y = s.y+dir[i][1]*t;

11 double tmp = getSum(p,n,z);

12 if(ans>tmp)

13 {

14 ans = tmp;

15 s = z;

16 fuck= 1;

17 }

18 }

19 }

20 t*=delta;

21 }

View Code

求费马点：poj2420

题目链接：https://vjudge.net/problem/POJ-2420

一开始就以坐标平均点作为起始点，然后移动的时候虽然可以无脑的向四周移动，但是我们可以这样看，求出每一个点和当前点的dx，dy，然后肯定是当前点朝dx和dy方向移动。这样会更好

(这个是带上一定概率接受更差解的)

1 #include

2 #include

3 #include

4 #include

5 #include

6 using namespace std;

7 #define eps 1e-6

8 int n;

9 const int N = 109;

10 struct Point{

11 double x,y;

12 }p[N],now;

13 double dis(Point a,Point b){

14 return sqrt( (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y - b.y));

15 }

16 double getsum(Point u){

17 double res = 0;

18 for(int i = 1;i<=n;++i){

19 res += dis(p[i],u);

20 }

21 return res;

22 }

23 int main(){

24 scanf("%d",&n);

25 for(int i = 1;i<=n;++i){

26 scanf("%lf %lf",&p[i].x,&p[i].y);

27 now.x += p[i].x;

28 now.y += p[i].y;

29 }

30 now.x /= n; now.y /= n;

31 double ans = getsum(now);

32 double T = 100;

33 srand(23333);

34 while(T > eps){

35 double dx = 0,dy = 0;

36 for(int i = 1;i<=n;++i){

37 dx += (p[i].x - now.x)/dis(now,p[i]);

38 dy += (p[i].y - now.y)/dis(now,p[i]);

39 }

40 Point next = (Point){now.x + dx*T, now.y + dy*T};

41 double tem = getsum(next);

42 if(tem < ans){

43 ans = tem;

44 now = next;

45 }

46 else if(exp( (ans - tem) / T) > (rand()%10000)/10000.0){

47 ans = tem;

48 now = next;

49 }

50 T *= 0.98;

51 }

52 printf("%.0f",ans);

53 return 0;

54 }

View Code

最小球覆盖：poj2069

题目链接：https://vjudge.net/problem/POJ-2069

和上一题差不多，先以平均点做起始点，然后每次移动肯定是往距离当前点的最远点移动。

(这个没有接受更差解了)

1 #include

2 #include

3 #include

4 #define eps 1e-6

5 using namespace std;

6 const int N = 40;

7 int n;

8 struct Point{

9 double x,y,z;

10 }p[N],now;

11 double dis(Point u,Point v){

12 return sqrt( (u.x-v.x)*(u.x-v.x) + (u.y-v.y)*(u.y-v.y) + (u.z - v.z)*(u.z - v.z));

13 }

14 int main(){

15 while(~scanf("%d",&n) && n){

16 for(int i = 1 ; i <= n ;++i){

17 scanf("%lf %lf %lf",&p[i].x,&p[i].y,&p[i].z);

18 now.x+=p[i].x; now.y+=p[i].y; now.z += p[i].z;

19 }

20 now.x/=n; now.y/=n; now.z/=n;

21 double T = 100;

22 double ans = 1e99;

23 while(T > eps){

24 int k = 1;

25 for(int i = 1;i <= n ;++i){

26 if(dis(now,p[i]) > dis(now,p[k]) ){

27 k = i;

28 }

29 }

30 double tem = dis(p[k],now);

31 ans = min(ans,tem);

32 now.x += ( (p[k].x - now.x)/tem )*T;

33 now.y += ( (p[k].y - now.y)/tem )*T;

34 now.z += ( (p[k].z - now.z)/tem )*T;

35 T *= 0.98;

36 }

37 printf("%.6f\n",ans);

38 }

39 return 0;

40 }

View Code

至于最小园覆盖，模拟退火的话和最小求覆盖一样啦。不过最小圆覆盖有线性的点增量法(下一篇讲到)，所以就不妨在这里了。

标签：now,tem,Point,int,double,费马点,模拟退火,include,模板

来源： https://www.cnblogs.com/xiaobuxie/p/11619652.html