P3959 宝藏（模拟退火）

P3959 宝藏

特别鸣谢

题目描述

给出一张有向图，从所有节点中取一个节点作为起始节点，使得遍历这张图的总代价最小.

总代价是到达各个节点的代价的和. 到达每个节点的代价的计算方法是：从这个节点的前驱节点到达这个节点的边的边权*从起始节点到前驱节点的路径上的节点数（包括起始节点和前驱节点，但是不包括这个节点本身）.

题目分析

$prim$算法

一个我从来没学过的最小生成树算法.

和$dijkstra$非常相似，都是基于边贪心的思路. （因此不能用来求最大生成树）

算法描述：
1.将图中所有顶点v分成两个集合$V_A$和$V_B$，在计算过程中$V_A$中的点为已经选好连接进最小生成树的点，$V_B$中的点则相反.
2.$V_A$起始时只包含根节点s，每次把集合$V_B$中到$V_A$距离最小的一个点添加进$V_A$中，直到$V_B$为空.

加入堆优化后复杂度同$dijkstra$算法，为$O((n+m)log\:m)$.

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
#define maxn 5010
using namespace std;
struct edge{
	int v,w,next;
}e[maxn<<7];
int head[maxn],tot;
void add(int u,int v,int w){
	e[++tot].v =v,e[tot].w =w;
	e[tot].next =head[u];head[u]=tot;
}
int n,m,ans;
struct node{
	int dis,pos;
	bool operator <(node nd)const{
		return nd.dis <dis;
	}
};
bool vis[maxn];
void prim(int s){
	priority_queue<node>q;
	q.push((node){0,s});
	while(!q.empty()){
		node now=q.top();q.pop();
		int u=now.pos ,dis=now.dis ;
		if(vis[u])continue;
		ans+=dis;
		vis[u]=true;
		for(int i=head[u];i;i=e[i].next ){
			int v=e[i].v ;
			if(!vis[v]){
				q.push((node){e[i].w ,v});
			}
		}
	}
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1,u,v,w;i<=m;i++){
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w);
		add(v,u,w);
	}
	prim(1);
	for(int i=1;i<=n;i++)if(!vis[i]){printf("orz\n");exit(0);}
	printf("%d\n",ans);
	return 0;
} 

但是在这道题中我们并不能使用$prim$，如下图：

如果从$1$开始做$prim$，必死无疑.

但是$prim$算法给了我们启发：

我们能不能找出一个所有点的遍历序列，使得这种遍历序列的总代价最小.

显然如果爆搜的话时间复杂度必定爆表，又因为这是一个最优解问题，所以我们上模拟退火.

模拟退火（$SA$）

熟悉的算法，不同的配方.

如果我没记错的话，我曾写过一篇文章：模拟退火学习报告

在这篇文章里，我把整个数组分为两部分，然后通过交换两部分的元素，实现状态的转移.

我们在这里也可以采用这种方法，通过随机交换两个节点的访问顺序转移状态.

然后按照访问顺序得到当前状态的解，比较其与当前最优解，更新最优解.

然后就完了.

问：这道题的模拟退火是一个“残废”的模拟退火，并没有传统一定概率取非最优解的环节，而是无论优劣，都维持当前的状态. 但是A了，反而是传统的写法挂了. 为什么？？？？
——因为这样子相比于原来的模拟退火，更容易更新到新的状态，从而得到新的最优解.
——另外，这里的最优状态和下一个最优状态并没有明显关联，所以随机更新会更好.

程序实现

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
#define esp 1e-5
#define dt 0.998
#define maxn 20
#define ll long long
using namespace std;
int n,m,sqc[maxn],dis[maxn],e[maxn][maxn];
ll ans;//这种写法爆int
ll deal(){
	ll ret=0;
	memset(dis,inf,sizeof dis);
	dis[sqc[1]]=1;
	for(int i=2;i<=n;i++){
		int v=sqc[i];
		ll disv=inf;
		for(int j=1;j<i;j++){
			int u=sqc[j];
			if((ll)e[u][v]*(ll)dis[u]<disv){
				disv=(ll)e[u][v]*(ll)dis[u];
				dis[v]=dis[u]+1;
			}
		}
		if(disv==inf)return inf;
		ret+=disv;
	}
	return ret;
}//求按当前遍历顺序所得到的解
void SA(){
	double T=12.3;//幸运数字
	while(T>esp){
		int x=rand()%n+1,y=rand()%n+1;
		swap(sqc[x],sqc[y]);//注意这里无论优劣，都不会回到前一个状态. 也就是当前状态一直维持，这样子更容易得到新的最优解（如果有的话）
		ll w=deal();
		//swap(sqc[x],sqc[y]);
		if(w==inf){T*=dt;continue;}
		if(ans==inf){ans=w;T*=dt;continue;}
		ll delta=w-ans;
		if(delta<0){
			//swap(sqc[x],sqc[y]);
			ans=w;
		}
		//else if(exp(delta/T)*RAND_MAX<rand()){//温度越低，差值越大，越不容易取到非最优解
		//	swap(sqc[x],sqc[y]);
		//}//为什么！没有传统的取非最优解环节，反而A了
		T*=dt;
	}
}
int main(){
	srand(time(0));
	scanf("%d%d",&n,&m);
	memset(e,inf,sizeof e);
	for(int i=1;i<=n;i++)sqc[i]=i;//sqc表示访问顺序，初始为正序
	for(int i=1,u,v,w;i<=m;i++){
		scanf("%d%d%d",&u,&v,&w);
		if(u==v){e[u][v]=0;continue;}
		e[u][v]=min(e[u][v],w);
		e[v][u]=e[u][v];
	}
	ans=inf;
	SA();
	printf("%lld\n",ans);//输出（可能？）最优解
	return 0;
}