两种K短路问题

一：普通的K短路问题。

这个就是在一张图里面求k短路长度。。没有什么限制。

这个可以用A*算法解决。

先说大概思路：用优先队列储存状态。。。每次出队step值（就是当前走到这个点所经过的距离值）最小的点，用它扩展到周围的点的状态。。然后把这些新状态入队。。。

（就和普通bfs差不多），那么目标点第一次出队时，这个状态的step值就是他的第一短路。。同理，第k次出队时所对应状态的step值就是他的k短路。。

然后考虑加进A*。。。每个状态的估价函数g设计为从当前点到目标点的最短路（预处理一次得出：反建边，从目标点求单源最短路）。。然后把优先队列改成每次出队（step+g）值最小的状态。。

大概就是这样了。。。（如果不理解什么是A*的话可能看不懂，建议去翻一下A*相关资料或者给我留言- -）

#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int n,m;
int S,T,k;
int head[1000+10],l=0;
int dis[1000+10];
int cnt[1000+10];
bool vis[1000+10];
struct E
{
	int v,w,next;
	bool rev;
}e[100000*2+10];
struct state
{
	int step,u;
	bool operator <(const state &b)const
	{
		return step+dis[u]>b.step+dis[b.u];
	}
}start;
typedef pair<int,int>pii;
void add(int u,int v,int w)
{
	e[l].v=v;
	e[l].w=w;
	e[l].next=head[u];
	e[l].rev=0;
	head[u]=l++;
	e[l].v=u;
	e[l].w=w;
	e[l].next=head[v];
	e[l].rev=1;
	head[v]=l++;
}
int dijkstra()
{
	memset(dis,0x3f,sizeof(dis));
	dis[T]=0;
	priority_queue<pii,vector<pii>,greater<pii> >q;
	q.push(make_pair(dis[T],T));
	while(!q.empty())
	{
		int x=q.top().second;
		q.pop();
		if(vis[x])continue;
		vis[x]=true;
		for(int i=head[x];i!=-1;i=e[i].next)
		{
			if(e[i].rev)
			{
				int v=e[i].v;
				if(dis[v]>dis[x]+e[i].w)
				{
					dis[v]=dis[x]+e[i].w;
					q.push(make_pair(dis[v],v));
				}
			}
		}
	}
}
void Astar()
{
	priority_queue<state>q;
	start.u=S;
	start.step=0;
	q.push(start);
	while(!q.empty())
	{
		state cs=q.top();
		q.pop();
		cnt[cs.u]++;
		if(cnt[cs.u]>k)continue;
		if(cs.u==T)
		{
			if(k==cnt[cs.u])
			{
				printf("%d\n",cs.step);
				exit(0);
			}
		}
		for(int i=head[cs.u];i!=-1;i=e[i].next)
		{
			if(!e[i].rev)
			{
				state ns;
				ns.u=e[i].v;
				ns.step=cs.step+e[i].w;
				q.push(ns);
			}
		}
	}
	if(k>0)printf("-1\n");
}
int main()
{
	memset(head,-1,sizeof(head));
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w);
	}
	scanf("%d%d%d",&S,&T,&k);
	if(S==T)k++;
	dijkstra();
	Astar();
	return 0;
}

二：简单k短路问题：【scoi2007】kshort

还是要求k短路。。只不过每条路线都必须不经过重复的点。。用刚才的方法就不能保证是简单路了（或者说考虑状压？可能也行。。但我没试过）

关于这个有一个专门的偏离算法。。。不过我没学

就说说当点比较少的时候的情况，比如这道题。

基本的思想就是二分路径长度，每次搜索只找到有多少存在条长度小于二分值mid的路径（需要知道的是有没有k条或以上这样的路径，所以如果已经找到的k条那么就不要继续搜索了）。。。

（于是当路径值大于mid时就剪枝。。）这里还是可以借鉴上面一个问题的某个地方。。。算出每个点到目标点的最短路来剪枝。

二分出求出最后的mid之后。我们便知道要求的路径的长度一定为mid。

于是我们再通过一次搜索求出长度小于等于mid-1的路径有x条，那么我们要求的路径就转换为长度为mid，字典序为第k-x小的路径。

那么就直接再搜一次，每次都先走最小能到的点，然后走到终点长度为mid的边才统计。一直走到第k-x个被统计的路径。。。这个路径，就是答案，输出就完了

有个比较坑的特殊数据要这样才能过：由于一开始求出的那个最短路没有考虑有些点不能走。。。所以每搜到一个dfs节点就要重新计算没经过已走点的最短路，然后再用来剪枝。。这样判断的代价非常高，所以当前点能过了，但其他点的时间通通大幅增加，最后一个点还会T。。不过BZOJ上算的是总时间。。。所以也就水过了。（这种高代价剪枝。。考场上用风险太大了）

代码实际上用了mato神犇说的迭代变优搜索：http://www.cppblog.com/MatoNo1/archive/2012/09/23/191705.html

 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int inf=~0u >> 2;
int n,m,k,a,b;
int ans=0;
int nextlenth=inf,LENTH;
int w[50+10][50+10];
int rev[100+10][100+10];
bool con[100+10][100+10];
bool vis[100+10];
int head[100+10],tail=0;
int head2[50+10],tail2=0,revdis[50+10];
bool in[50+10];
int lastlen=1;
bool last=false;
struct E
{
    int v,w,next;
}e[10000+10],e2[10000+10];
struct S
{
    int dis;
    int len;
    int order[100+10];
    bool operator <(const S &b)const
    {
        if(dis!=b.dis)return dis<b.dis;
        for(int i=0;i<min(len,b.len);i++)if(order[i]!=b.order[i])return order[i]<b.order[i];
        return len<b.len;
    }
}now;
void spfa()
{
    memset(revdis,0x3f,sizeof(revdis));
    revdis[b]=0;
    queue<int>q;
    q.push(b);
    in[b]=true;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        in[x]=false;
        for(int i=head2[x];i!=-1;i=e2[i].next)
        {
            int v=e2[i].v;
            if(!vis[v])
            {
                if(revdis[v]>revdis[x]+e2[i].w)
                {
                    revdis[v]=revdis[x]+e2[i].w;
                    if(!in[v])q.push(v),in[v]=true;
                }
            }
        }
    }
}
void add(int u,int v,int l)
{
    e[tail].v=v;e[tail].w=l;e[tail].next=head[u];
    head[u]=tail++;
    e2[tail2].v=u;e2[tail2].w=l;e2[tail2].next=head2[v];
    head2[v]=tail2++;
    w[u][v]=min(w[u][v],l);
    rev[v][u]=min(rev[v][u],l);
    con[u][v]=1;
}
void dfs(int u,int dis)
{
    if(u==b){ans++;return;}
    if(ans>=k)return;
    if(!con[u][b])return;
    if(dis+rev[b][u]>LENTH)
    {
        if(nextlenth>dis+rev[b][u])nextlenth=dis+rev[b][u];
        return;
    }
    vis[u]=false;
    spfa();
    if(dis+revdis[u]>LENTH)
    {
        if(nextlenth>dis+revdis[u])nextlenth=dis+revdis[u];
        return;
    }
    vis[u]=true;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        if(ans>=k)return;
        int v=e[i].v;
        if(!vis[v])
        {
            if(dis+e[i].w<=LENTH)
            {
                vis[v]=true;
                dfs(v,dis+e[i].w);
                vis[v]=false;
            }
            else
            {
                if(nextlenth>dis+e[i].w+rev[b][e[i].v])nextlenth=dis+e[i].w+rev[b][e[i].v];
            }
        }
    }
}
void dfs2(int u,int dis)
{
    if(u==b)
    {
        if(dis<=LENTH&&dis>lastlen)ans++;
        if(ans==k)
        {
            printf("%d",now.order[0]);
            for(int i=1;i<now.len;i++)printf("-%d",now.order[i]);
            printf("\n");
            exit(0);
        }
        return;
    }
    if(!con[u][b])return;
    if(dis+rev[b][u]>LENTH)
    {
        return;
    }
    vis[u]=false;
    spfa();
    if(dis+revdis[u]>LENTH)
    {
        return;
    }
    vis[u]=true;
    for(int i=1;i<=n;i++)
    {
        if(!vis[i]&&dis+w[u][i]<=LENTH)
        {
            vis[i]=true;
            now.order[now.len]=i;
            now.len++;
            dfs2(i,dis+w[u][i]);
            now.len--;
            vis[i]=false;
        }
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    memset(head2,-1,sizeof(head2));
    memset(w,0x3f,sizeof(w));
    memset(rev,0x3f,sizeof(rev));
    scanf("%d%d%d%d%d",&n,&m,&k,&a,&b);
    for(int i=1;i<=n;i++)w[i][i]=rev[i][i]=0,con[i][i]=1;
    for(int i=1;i<=m;i++)
    {
        int u,v,l;
        scanf("%d%d%d",&u,&v,&l);
        add(u,v,l);
    //  add(v,u,l);
    }
    for(int k1=1;k1<=n;k1++)
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                rev[i][j]=min(rev[i][j],rev[i][k1]+rev[k1][j]);
                con[i][j]|=con[i][k1]&con[k1][j];
            }
    }
//  int l=1,r=50;
//  while(l<r)
//  {
//      ans=0;
//      LENTH=(l+r)>>1;
//      vis[a]=true;
//      now.len=1;now.order[0]=a;
//      dfs(a,0);
//      if(ans>=k)break;
//      else l=LENTH+1;
//  }
    for(LENTH=1;ans<k&&LENTH!=inf;lastlen=LENTH,LENTH=nextlenth)
    {
        ans=0;
        nextlenth=inf;
        memset(vis,0,sizeof(vis));
        vis[a]=true;
        dfs(a,0);
        if(ans>=k)break;
    }
    if(ans<k)
    printf("No\n");
    else
    {
        int anslen=LENTH;
        LENTH=lastlen;
        ans=0;
        memset(vis,0,sizeof(vis));
        vis[a]=true;
        dfs(a,0);
        k=k-ans;
        ans=0;
        memset(vis,0,sizeof(vis));
        vis[a]=true;
        LENTH=anslen;
        now.len=1;
        now.order[0]=a;
        dfs2(a,0);
    }
    return 0;
}