【最短路】解题报告

4．最短路（path.c/cpp）

[问题描述]

给定一个包含N个点，M条边的无向图，每条边的边权均为1。

再给定K个三元组（A，B，C），表示从A点走到B点后不能往C点走。注意三元组是有序的，如可以从B点走到A点再走到C。

现在你要在K个三元组的限制下，找出1号点到N号点的最短路径，并输出任意一条合法路径，会有Check检查你的输出。

[输入格式]

输入文件第一行有三个数N，M，K，意义如题目所述。

接下来M行每行两个数A，B，表示A，B间有一条边。

再下面K行，每行三个数（A，B，C）描述一个三元组。

[输出格式]

输出文件共两行数，第一行一个数S表示最短路径长度。

第二行S+1个数，表示从1到N所经过的节点。

[样例输入]

4 4 2

1 2

2 3

3 4

1 3

1 2 3

1 3 4

[样例输出]

4

1 3 2 3 4

[数据范围]

对于40%的数据满足N≤10，M≤20，K≤5。

对于100%的数据满足N≤3000，M≤20000，K≤100000。

 

这道题是一道拆点的题，不过也可以用广搜来做，每次记录父亲就行了。

一开始我就卡在了这点上，走到下一个点，但是并不知道这个状态是由哪一个父亲派生出来的，但是其实就是这么简单，对每个队列中的元素都记录父亲。

广搜：

#include <cstdio>


struct node
{
	long y;
	long z;
	node* next;
};
node* g[3002][3002];


long n;long m;long k;
long que[1100000];
long que2[1100000];
long fa[3002];
bool map[3002][3002];


void insert(long x,long z,long y)
{
	node* tmp = new node;
	tmp -> z = z;
	tmp -> y = y;
	tmp -> next = g[x][y];
	g[x][y] = tmp;
}


void output(long p)
{
	if (fa[p]==0)
	{
		printf("%ld ",que[p]);
		return;
	}
	output(fa[p]);
	printf("%ld ",que[p]);	
}


bool check(long a,long b)
{
	node* ths = g[fa[a]][b];
	
	while (ths)
	{
		if (ths->z==a) return false;
		ths = ths->next;
	}
	return true;
}


void bfs()
{
	long l= 0;long r= 0;
	r++;
	que[r] = 1;
	while (l<r)
	{
		long now = que[++l];
		for (long i=1;i<n+1;i++)
		{
			if (now == i)continue;
			if (map[now][i]&&check(l,i))
			{
				map[now][i] = false;
				r++;
				fa[r] = l;
				que[r] = i;
				que2[r] = que2[l]+1; 
				if (i==n)
				{
					printf("%ld\n",que2[r]);
					output(r);
					return;
				}
			}
		}
	}
}


int main()
{
	freopen("path.in","r",stdin);
	freopen("path.out","w",stdout);
	scanf("%ld%ld%ld",&n,&m,&k);
	for (long i=1;i<m+1;i++)
	{
		long a;long b;
		scanf("%ld%ld",&a,&b);
		map[a][b] = true;
		map[b][a] = true;
	}	
	for (long i=1;i<k+1;i++)
	{
		long a;long b;long c;
		scanf("%ld%ld%ld",&a,&b,&c);
		insert(a,b,c);
	}
	bfs(); 
	return 0;
}

spfa+拆点

意思容易理解，只是代码不好写，因为结构体太多了。容易混淆

拆点关键就在于，对于hash、dist、还有记录方案的g统统都要增加一维。

上个方案的bfs中，hash增加了一维也是基于这个原因，因为不能从上一个点到这个点来了，但是还会有其他的路到这个点来

#include <cstdio>

struct node
{
	long z;
	node* next;
};
node* g[3002][3002];

struct node1
{
	long index;
	node1* next;
};

struct tnode
{
	long f;
	long i;
};

long n;long m;long k;
tnode que[100000];
bool map[3002][3002];
node1* dian[3002];
bool used[3002][3002];
long dist[3002][3002];
long fangan[3002][3002];

void insert1(long x,long y)
{
	node1* tmp = new node1;
	tmp->index = y;
	tmp->next = dian[x];
	dian[x] = tmp;
}

void insert(long x,long y,long z)
{
	node* tmp = new node;
	tmp -> z = z;
	tmp -> next = g[x][y];
	g[x][y] = tmp;
}

bool can(long a,long b,long c)
{
	node* ths = g[a][b];
	
	while (ths)
	{
		if (ths->z==c) return false;
		ths = ths->next;
	}
	return true;
}

void spfa()
{
	for (long i=0;i<n+1;i++)
	{
		for (long j=0;j<n+1;j++)
		{
			dist[i][j] = 0x7fff0000;
		}
	}
	used[1][1] = true;
	dist[1][1] = 0;
	long l = 0;
	long r = 1;
	que[r].f=1;
	que[r].i=1;
	while (l<r)
	{
		l++;
		tnode now = que[l];
		used[now.f][now.i] = false;
		node1* ths = dian[now.i];
		while (ths)
		{
			if (can(now.f,now.i,ths->index)&&dist[now.i][ths->index]>dist[now.f][now.i]+1)
			{
				dist[now.i][ths->index]=dist[now.f][now.i]+1;
				fangan[now.i][ths->index] = l;
				if (!used[now.i][ths->index])
				{
					used[now.i][ths->index] = true;
					r++;
					que[r].i = ths->index;
					que[r].f = now.i;
				}
			}
			ths = ths -> next;
		}
	}
}	

void output(long a,long b)
{
	if(b==1)
	{
		printf("1 ");
		return;
	}
	tnode* la = &que[fangan[a][b]];
	output(la->f,la->i);
	printf("%ld ",b);
}	

int main()
{
	freopen("path.in","r",stdin);
	freopen("path.out","w",stdout);
	scanf("%ld%ld%ld",&n,&m,&k);
	for (long i=1;i<m+1;i++)
	{
		long a;long b;
		scanf("%ld%ld",&a,&b);
		insert1(a,b);
		insert1(b,a);
	}	
	for (long i=1;i<k+1;i++)
	{
		long a;long b;long c;
		scanf("%ld%ld%ld",&a,&b,&c);
		insert(a,b,c);
	}
	spfa();
	long ans = 0x7fff0000;
	long t = 0;
  	for (long i=1;i<n;i++)
  	{
		if (dist[i][n]<ans)
  		{
		    ans=dist[i][n];
		    t=i;
		}
	}
  	printf("%ld\n",ans);
  	output(t,n);
	return 0;
}