UVA 11624 10054

这是前两天做的两道图论基础题，难度不算大，考察的算法也很基础（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;
}