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;
}