题目描述
给出一张有向图,从所有节点中取一个节点作为起始节点,使得遍历这张图的总代价最小.
总代价是到达各个节点的代价的和. 到达每个节点的代价的计算方法是:从这个节点的前驱节点到达这个节点的边的边权*从起始节点到前驱节点的路径上的节点数(包括起始节点和前驱节点,但是不包括这个节点本身).
题目分析
p r i m prim prim算法
一个我从来没学过的最小生成树算法.
和 d i j k s t r a dijkstra dijkstra非常相似,都是基于边贪心的思路. (因此不能用来求最大生成树)
算法描述:
1.将图中所有顶点v分成两个集合 V A V_A VA和 V B V_B VB,在计算过程中 V A V_A VA中的点为已经选好连接进最小生成树的点, V B V_B VB中的点则相反.
2. V A V_A VA起始时只包含根节点s,每次把集合 V B V_B VB中到 V A V_A VA距离最小的一个点添加进 V A V_A VA中,直到 V B V_B VB为空.
加入堆优化后复杂度同 d i j k s t r a dijkstra dijkstra算法,为 O ( ( n + m ) l o g   m ) O((n+m)log\:m) O((n+m)logm).
#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;
}
但是在这道题中我们并不能使用 p r i m prim prim,如下图:
如果从 1 1 1开始做 p r i m prim prim,必死无疑.
但是 p r i m prim prim算法给了我们启发:
我们能不能找出一个所有点的遍历序列,使得这种遍历序列的总代价最小.
显然如果爆搜的话时间复杂度必定爆表,又因为这是一个最优解问题,所以我们上模拟退火.
模拟退火( S A SA 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;
}