这是前两天做的两道图论基础题,难度不算大,考察的算法也很基础(BFS和打印欧拉回路),但是自己当初被一些细节困扰了许久。
UVA11624 Fire
这题是典型的BFS,如果没有着火的条件那就是一道裸算法题。有了着火的条件,无非是在BFS扩展结点时多一个判定条件:确保下一个扩展的结点不会着火。因此,首先以所有起火点(F标记)为起点做一次BFS,计算出图中每点的起火时间,用二维数组fireTime[][]储存。
fireTime[][]初始化:若G[i][j]=’F’,fireTime[i][j]=0,否则应设置为无穷大。
一遍BFS处理好fireTime后,从J点出发再做一次BFS。可扩展的结点必须确保下一时刻不会着火,方法是比较“当前结点的时刻+1”和“待扩展结点的fireTime值”,如果前者小于后者(必须是小于,等于不行),那么可以扩展,因为这说明Joe比火先到这个结点。最后在BFS过程中判定一下Joe有没有到达边界即可。
UVA10054 The Necklace
一道有关欧拉回路的题,不过这道题最大的启示是建模的重要性。我们应该把每一种颜色当做图中的一个点,建图方法是:如果一颗珠子两端的颜色是i和j,那么就在i、j之间连一条无向边。需要注意的是以下几点:
1. 珠子两端的颜色可能相同,也就是说图可能有自环。
2. 可能有相同的珠子,也就是说图可能有重边。
3. 图可能不连通,光靠顶点度数是否都为偶数不能断定图存在欧拉回路。
4. 给定的珠子中可能只出现了50种颜色中的一部分。我一开始想当然的从顶点1开始打印路径,最后才想到这个问题。
后来看别人博客里说UVA上数据不严谨,建出的图全部是连通的……
对于重边和自环,用邻接表存图自然没问题,但这题用邻接矩阵也是可以的。注意到图的边并没有权值,我们可以用G[i][j]表示有多少条(i,j)边,如果没有则G[i][j]=0。
判定图是否连通的方法就很多了,一共收集到这些方法:
1. 从一个点开始跑一遍DFS统计这个连通分量里有几个点,然后和顶点总数比较。
2. 用并查集,统计一下所有点的parent值是否相同。
3. 在打印欧拉回路的时候记录遍历的边数,图的边总数是珠子的数量,如果两者不等说明图存在不止一个连通分量。
//UVA 11624 675MS
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define LL long long
const int MAXN = 1002;
const int dx[] = {0,0,1,-1};
const int dy[] = {1,-1,0,0};
struct Grid
{
int x,y,step;
Grid(int a, int b, int s)
{
x = a; y = b; step = s;
}
};
queue<Grid> mq;
char mp[MAXN][MAXN];
int fireTime[MAXN][MAXN];
bool vst[MAXN][MAXN];
int R,C;
void bfs_fire()
{
while(!mq.empty())
{
Grid f = mq.front();
mq.pop();
for(int i=0; i<4; i++)
{
int nx = f.x+dx[i];
int ny = f.y+dy[i];
if(nx>=0 && nx<R && ny>=0 && ny<C && mp[nx][ny]!='#' && !vst[nx][ny])
{
fireTime[nx][ny] = f.step+1;
Grid next(nx, ny, fireTime[nx][ny]);
vst[nx][ny] = 1;
mq.push(next);
}
}
}
}
int bfs_escape(int sx, int sy)
{
for(int i=0; i<R; i++)
for(int j=0; j<C; j++) vst[i][j] = 0;
Grid g(sx, sy, 0);
mq.push(g);
vst[sx][sy] = 1;
while(!mq.empty())
{
Grid f = mq.front();
//走到了边界 成功逃脱
if(f.x == 0 || f.x == R-1 || f.y == 0 || f.y == C-1)
return f.step+1;
mq.pop();
for(int i=0; i<4; i++)
{
int nx = f.x+dx[i];
int ny = f.y+dy[i];
if(nx>=0 && nx<R && ny>=0 && ny<C && mp[nx][ny]!='#' && !vst[nx][ny]
&& f.step+1<fireTime[nx][ny])
{
Grid next(nx, ny, f.step+1);
vst[nx][ny] = 1;
mq.push(next);
}
}
}
return -1;
}
int main()
{
int cas,sx,sy;
scanf("%d", &cas);
while(cas--)
{
scanf("%d%d", &R,&C);
getchar();
for(int i=0; i<R; i++)
for(int j=0; j<C; j++)
{
vst[i][j] = 0;
fireTime[i][j] = (1<<30);//(i,j)着火时间初始化为无穷大
}
for(int i=0; i<R; i++)
{
for(int j=0; j<C; j++)
{
scanf("%c", &mp[i][j]);
if(mp[i][j] == 'J')
{
sx = i;
sy = j;
}
else if(mp[i][j] == 'F')
{
Grid g(i,j,0);
vst[i][j] = 1;
fireTime[i][j] = 0;
mq.push(g);
}
}
getchar();
}
bfs_fire();//BFS计算每个格子着火的时间点
int ans = bfs_escape(sx, sy);
while(!mq.empty()) mq.pop();
if(ans == -1)
printf("IMPOSSIBLE\n");
else printf("%d\n", ans);
}
return 0;
}
//UVA 10054 288MS
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LL long long
typedef pair<int,int> pii;
int degree[51];
int mp[51][51];
bool is_euler_graph(int n)
{
for(int i=1; i<=n; i++)
if(degree[i] & 1)
return false;
return true;
}
int cnt;//欧拉回路中边数
stack<pii> ms;
void print_path(int u)
{
cnt++;
for(int v=1; v<=50; v++)
if(mp[u][v])
{
mp[u][v]--;
mp[v][u]--;
print_path(v);
ms.push(make_pair(u,v));
}
}
int main()
{
int n,cas,st;
scanf("%d", &cas);
for(int cc = 1; cc<=cas; cc++)
{
scanf("%d", &n);
memset(mp, 0, sizeof(mp));
memset(degree, 0, sizeof(degree));
for(int i=0; i<n; i++)
{
int a,b;
scanf("%d%d", &a,&b);
mp[a][b]++;
mp[b][a]++;
degree[a]++;
degree[b]++;
st = a;
}
printf("Case #%d\n", cc);
if(!is_euler_graph(50))
printf("some beads may be lost\n");
else
{
cnt = 0;
print_path(st);
if(cnt-1 < n)
printf("some beads may be lost\n");
else while(!ms.empty())
{
pii tmp = ms.top();
ms.pop();
printf("%d %d\n", tmp.first, tmp.second);
}
}
if(cc < cas) printf("\n");
}
return 0;
}