入门经典_Chap06_例题[三]:图的搜索 Floodfill 拓扑排序 欧拉回路

前言

这一次的题真的是变态，好几道World Final的题，每一题都写了好长时间才过，还有一题没有过，觉得太麻烦了，以后再写。
还是先列一下知识点：

• DFS BFS(Floodfill)
• 拓扑排序
• 欧拉回路

虽然知识点不多，但是个人感觉题目在难度和复杂度上都特别大，有不少好题目值得推敲

题解如下

UVA - 572 Oil Deposits

思路

    水题一枚。
    一遍赤裸裸的BFS或DFS进行FloodFill即可。

代码

//DFS
int n, m, cnt[maxn][maxn], ans;
char s[maxn][maxn];

void dfs(int x, int y, int dep) {
    cnt[x][y] = dep;
    for(int i = -1; i <= 1; ++i) for(int j = -1; j <= 1; ++j) {
        if(i!= 0 || j != 0) {
            int tx = x+i, ty = y+j;
            if(tx >= 0 && tx < n && ty >= 0 && ty < m && cnt[tx][ty] == 0 && s[tx][ty] == '@') {
                dfs(tx,ty,dep);
            }
        }
    }
}

int main() {
    #ifdef _LOCAL
    IN;
    #endif // _LOCAL

    while(scanf("%d%d", &n, &m) == 2 && m) {
        met(s, 0); met(cnt, 0); ans = 0;
        for(int i = 0; i < n; ++i) scanf("%s", s[i]);
        //for(int i = 0; i < n; ++i) cout << s[i] <<endl;

        for(int i = 0; i < n; ++i) for(int j = 0; j < m; ++j) {
            if(s[i][j] == '@' && !cnt[i][j]) dfs(i, j, ++ans);
        }
        printf("%d\n", ans);
    }

    return 0;
}

//BFS
struct node {
    int x, y;
    node(){}
    node(int i, int j):x(i), y(j){}
};

void bfs(int x, int y, int dep) {
    queue<node> q;
    q.push(node(x, y)); cnt[x][y] = dep;

    while(!q.empty()) {
        node e = q.front(); q.pop();
        for(int i = -1; i <= 1; ++i) {
            for(int j = -1; j <= 1; ++j) {
                if(i != 0 || j != 0) {
                    int tx = e.x+i, ty = e.y+j;
                    if(tx >= 0 && tx < n && ty >= 0 && ty < m && cnt[tx][ty] == 0 && s[tx][ty] == '@') {
                        cnt[tx][ty] = dep;
                        q.push(node(tx,ty));
                    }
                }
            }
        }
    }

}

UVA - 1103 Ancient Messages

思路

    这是一道FloodFill题。
    这是一道2011年的World Final 题。
    题目的意思是有一些象形文字，然后它会输入一个16进制的字符矩阵，将每一位转换成4位二进制后0代表白色，1代表黑色，会组成一幅图片，让你找出图中的所有象形文字。

    首先要观察出来给出的6种象形文字的特点，发现它们有一个区别，就是表中的6个符号从左到右依次有1,3,5,4,0,2个洞,各不相同。这样,只需要数一数输入的符号有几个“白洞”,就能准确地知道它是哪个符号了。
    而数白洞的方法就是FloodFill的过程。
    所以这一题只要注意一点就能过，即确定最各个白色连通块都属于哪个黑色的图案，或者是各个图案外面的背景色。
    而我这里采用的确定方法也很简单，先对黑色做一遍FloodFill确定黑色的编号，再在对白色做dfs的过程中，如果它越界或碰到黑色的了，就判断一下它碰到的黑色的编号，它就属于那个编号，而且当它越界或者碰到多个不同编号的黑色时， 它就是背景白色了。

代码

#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdio>
#include <cmath>
#define met(a,b) memset(a, b, sizeof(a));
#define IN freopen("in.txt", "r", stdin);
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int maxn = 1e3 + 100;
const int INF = 0x7fffffff;
int dir[4][2] = {1,0,-1,0,0,1,0,-1};

char ot[10] = "WAKJSD", ans[maxn];

int n, m, maps[maxn][maxn], color[maxn][maxn], sum[maxn];
char s[maxn][maxn];

void dfs(int x, int y, int dep) {
    color[x][y] = dep;
    for(int i = 0; i < 4; ++i) {
        int tx = x + dir[i][0], ty = y + dir[i][1];
        if(tx >= 0 && tx < n && ty >= 0 && ty < m*4 && color[tx][ty] == 0 && maps[tx][ty] == 1) {
            dfs(tx, ty, dep);
        }
    }
}

int dfs2(int x, int y) {
    int tr = -1;
    color[x][y] = -1;
    for(int i = 0; i < 4; ++i) {
        int tx = x + dir[i][0], ty = y + dir[i][1];
        if(tx >= 0 && tx < n && ty >= 0 && ty < m*4) {
            if(maps[tx][ty] == 1) {
                if(tr == -1) tr = color[tx][ty];
            }
            else {
                if(color[tx][ty] == 0) {
                    int tmp = dfs2(tx, ty);
                    if(tr != -1 && tr != tmp) tr = 0;
                    else tr = tmp;
                }
            }
        }
        else tr = 0;
    }
    return tr;
}

int main() {
    #ifdef _LOCAL
    IN;
    #endif // _LOCAL
    int kase = 0;

    while(scanf("%d%d", &n, &m) == 2 && (m||n)) {
        met(s, 0); met(maps, 0); met(color, 0); met(sum, 0);
        for(int i = 0; i < n; ++i) scanf("%s", s[i]);
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < strlen(s[i]); ++j) {
                int t;
                if(s[i][j] >= '0' && s[i][j] <= '9') t = s[i][j] - '0';
                else t = s[i][j]-'a'+10;
                for(int k = 3; k >= 0; --k) maps[i][j*4+k] = t&1, t >>= 1;
            }
        }

        int cnt = 0;
        for(int i = 0; i < n; ++i) for(int j = 0; j < m*4; ++j) {
            if(color[i][j] == 0 && maps[i][j] == 1) dfs(i, j, ++cnt);
        }


        for(int i = 0; i < n; ++i) for(int j = 0; j < m*4; ++j) {
            if(color[i][j] == 0 && maps[i][j] == 0){
                int t = dfs2(i, j);
                ++sum[t];
            }
        }

        for(int i = 1; i <= cnt; ++i) ans[i] = ot[sum[i]];
        sort(ans+1, ans+1+cnt); ans[cnt+1] = '\0';
        cout << "Case " << ++kase << ": ";
        cout << ans+1 <<endl;
    }

    return 0;
}

UVA - 816 Abbott’s Revenge

思路

    又是一道World Final 的题。不过应该是全场签到题。
    这是一道找最短路径的搜索题，bfs+记录路径即可过，但是要注意一些细节。

    要知道每一个结点有12种状态，而且应该维护到达此结点时的方向。
    还要维护一下每个结点走出去后的方向，作为下一个结点达到的方向。
    代码写的有点乱，勉强过了。。。

代码

char F[6] = "NSEW"; //0 1 2 3
int getF(char c) { return strchr(F,c) - F; }
char D[6] = "LRF";  //0 1 2
int getD(char c) { return strchr(D, c) - D; }
int dir[4][3] = { {3,2,0}, {2,3,1}, {0,1,2}, {1,0,3} };
int DIR[4][2] = { -1,0, 1,0, 0,1, 0,-1 };

struct node {
    int x, y, px, py;
    int from;
    int D[4][3];
    bool vis[4];
    node(){ met(D, 0); met(vis, 0); }
    node(int pi, int pj, int i, int j, int f):px(pi), py(pj), x(i), y(j), from(f){ met(D, 0); met(vis, 0); }
}e[maxn][maxn];

struct path{
    int px, py, pd;
    path(int i = 0, int j = 0, int d = 0):px(i), py(j), pd(d){}
}pt[maxn][maxn][4];
vector<path> ans;

int sx, sy, ex, ey, sd, dis[maxn][maxn][4];
char c, str[10];
int a, b;

void init() {
    for(int i = 0; i < 15; ++i) for(int j = 0; j < 15; ++j) {
        e[i][j] = node(0,0,i,j,-1);
        for(int k = 0; k < 4; ++k) pt[i][j][k] = path();
    }
    ans.clear();
    met(dis, -1);
}

bool bfs() {
    queue<node> q;
    //node u(sx, sy, sd);
    e[sx+DIR[sd][0]][sy+DIR[sd][1]].from = sd;
    e[sx+DIR[sd][0]][sy+DIR[sd][1]].vis[sd] = 1;
    pt[sx+DIR[sd][0]][sy+DIR[sd][1]][sd] = path(sx,sy,-1);

    q.push(e[sx+DIR[sd][0]][sy+DIR[sd][1]]);

    while(!q.empty()) {
        node t = q.front(); q.pop();
        if(t.x == ex && t.y == ey) return 1;
        //if(t.vis[t.from]) continue;
        for(int i = 0; i < 3; ++i) {
            if(!t.D[t.from][i]) continue;
            int td = dir[t.from][i];
            int tx = t.x + DIR[td][0], ty = t.y + DIR[td][1];
            if(tx >= 1 && tx <= 9 && ty >= 1 && ty <= 9 && e[tx][ty].vis[td] == 0) {
                e[tx][ty].vis[td] = 1;
                e[tx][ty].px = t.x, e[tx][ty].py = t.y;
                e[tx][ty].from = td;
                q.push(e[tx][ty]);
                pt[tx][ty][td] = path(t.x,t.y,t.from);
            }
        }
    }
    return 0;
}

int main() {
    #ifdef _LOCAL
    IN;
    #endif // _LOCAL

    string s;
    while(cin >> s) {
        if(s == "END") break;
        init();
        scanf("%d%d %c %d%d", &sx, &sy, &c, &ex, &ey); sd = getF(c);

        while(scanf("%d%d", &a, &b) == 2 && a) {
            //cout << a << " " << b << " ";
            while(scanf("%s", str) == 1 && str[0] != '*') {
                //cout << str <<" ";
                int len = strlen(str);
                int f = getF(str[0]);
                for(int i = 1; i < len; ++i) e[a][b].D[f][getD(str[i])] = 1;
            }
            //cout << endl;
        }


        if(bfs()) {
            cout << s <<endl;
            path t = pt[ex][ey][e[ex][ey].from];
            ans.push_back(path(ex,ey,0));
            while(t.pd != -1) {
                //cout << t.px <<" " << t.py <<endl;
                //ans[aid++] = path(t.px, t.py, 0);
                ans.push_back(t);
                if(t.px == sx && t.py == sy && t.pd == -1) break;
                t = pt[t.px][t.py][t.pd];
            }
            ans.push_back(path(sx,sy, 0));

            int cnt = 0;
            for(int i = ans.size()-1; i >= 0; --i) {
                if(cnt % 10 == 0) printf(" ");
                printf(" (%d,%d)", ans[i].px, ans[i].py);
                if(++cnt % 10 == 0) printf("\n");
            }
            if(ans.size() % 10 != 0) printf("\n");
        }
        else cout << s <<endl << "  No Solution Possible\n";

    }

    return 0;
}

UVA - 10305 Ordering Tasks

思路

    终于不是WF的题了！
    拓扑排序的裸题，没啥好说的。
    这里用bfs进行拓扑排序，用dfs也行。但是个人感觉bfs更好理解一些，而且如果题目需要将字典序最小的拓扑序列输出的话，可以将bfs的队列改为优先队列，而dfs就没有办法了。

代码

int n, m, a, b, in[maxn];
struct edge {
    int to, next;
    edge(){}
    edge(int t, int n):to(t), next(n){}
}e[maxn];
int tot;
int head[maxn];
void add(int from, int to) {
    e[tot] = edge(to, head[from]);
    head[from] = tot++;
}

void init() { tot = 0; met(head, -1); met(in, 0); }

void bfs() {
    queue<int> q;
    for(int i = 1; i <= n; ++i) if(in[i] == 0) q.push(i);

    while(!q.empty()) {
        int t = q.front(); q.pop();
        printf("%d ", t);
        for(int i = head[t]; i != -1; i = e[i].next) {
            int tmp = e[i].to;
            --in[tmp];
            if(in[tmp] == 0) q.push(tmp);
        }
    }
}

int main() {
    #ifdef _LOCAL
    IN;
    #endif // _LOCAL

    while(scanf("%d%d", &n, &m) == 2 && (n || m)) {
        init();
        for(int i = 0; i < m; ++i) {
            scanf("%d%d", &a, &b);
            add(a, b);
            ++in[b];
        }

        bfs(); printf("\n");

    }

    return 0;
}

UVA - 10129 Play on Words

思路

    欧拉道路的裸题，也没有什么好说的。

欧拉道路
首先是连通图: 用dfs或bfs判连通性
无向图: 最多只有两个奇点
有向图: 有一个点的出度比入度大1，另一个点的入度比出度大一，其余相等

代码

char ot[2][100] = { "The door cannot be opened.", "Ordering is possible." };
int ans;

int n, maps[30][30], in[30], out[30];
bool vis[30];
char s[maxn];

void dfs(int x) {
    for(int i = 0; i < 26; ++i) {
        if(!vis[i] && maps[x][i] == 1) vis[i] = 1, dfs(i);
    }
}

int judge() {
    int cnt = 0, a = -1, b = -1;
    for(int i = 0; i < 26; ++i) {
        if(!vis[i] && out[i] > 0) ++cnt, vis[i] = 1, dfs(i);
    }
    if(cnt > 1) return 0;

    cnt = 0;
    for(int i = 0; i < 26; ++i) {
        if(in[i] != out[i]) {
            if(in[i]-out[i] == 1) a = i;
            else if(in[i] - out[i] == -1) b = i;
            ++cnt;
        }
    }
    if(cnt == 2) {
        if(a < 0 || b < 0) return 0;
    }
    else if(cnt > 0) return 0;
    return 1;
}

int main() {
    #ifdef _LOCAL
    IN;
    #endif // _LOCAL

    int t; cin >> t;
    while(t--) {

        met(vis, 0); met(maps, 0); met(in, 0); met(out, 0); ans = 0;
        scanf("%d", &n);
        for(int i = 0; i < n; ++i) {
            scanf("%s", s);
            int len = strlen(s);
            maps[s[0]-'a'][s[len-1]-'a'] = 1;
            ++in[s[len-1]-'a']; ++out[s[0]-'a'];
        }
        ans = judge();
        printf("%s\n", ot[ans]);
    }

    return 0;
}

UVA - 10562 Undraw the Trees

思路

    dfs水题。
    不过有坑，注意字符串的清空，然后更要注意下一行有可能比上一行短的情况。

代码

char s[maxn][maxn], str[maxn];
int id;

void dfs(int x, int y) {
    printf("%c(", s[x][y]);
    if(x+1 < id && s[x+1][y] == '|') {
        int L = y;
        while(L >= 0 && s[x+2][L] == '-') --L; ++L;
        for(int i = L; s[x+3] != '\0' && s[x+2][i] == '-'; ++i) {
            if(x+3 < id && s[x+3][i] != '\0' && !isspace(s[x+3][i])){
                dfs(x+3, i);
            }
        }
    }
    printf(")");
}

int main() {
    #ifdef _LOCAL
    IN;
    #endif // _LOCAL

    int t; cin >> t; //fgets(s[0],maxn,stdin);
    while(t--) {
        id = 0; met(s, ' ');
        while(fgets(s[id],maxn,stdin) && s[id][0] != '#') ++id;
        printf("(");
        for(int i = 0; i < id; ++i) {
            int len = strlen(s[i])-1;
            for(int j = 0; j < len; ++j) {
                if(s[i][j] != '-' && s[i][j] != '|' && s[i][j] != ' ' && s[i][j] != '#'){
                    dfs(i, j);
                    i = id; j = len;
                }
            }
        }
        printf(")\n");
    }

    return 0;
}

UVA - 12171 Sculpture

思路

    哎呀，这题不会做。
    在网上找了份代码。以后再看喽，毕竟也是WF的题。
    不过我知道这题应该得离散化，然后要在外面加一圈进行三维bfs。

代码

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;



typedef long long ll;
typedef vector<int> vi;

const int dx[] = { -1, 0, 0, 1, 0, 0 };
const int dy[] = { 0, -1, 0, 0, 1, 0 };
const int dz[] = { 0, 0, -1, 0, 0, 1 };

int compress(int n, int *x, int *v) {//进行状态压缩，之后每个边的实际长度存放在v数组，
    memcpy(v, x, sizeof(int)*n);
    v[n] = -1;//设置该点的作用是让最小的下标从1开始，，从1开始还有一个作用是将来能够给外围加一圈空气；
    sort(v, v + n + 1);
    int m = unique(v, v + n + 1) - v;
    for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) if (x[i] == v[j]) { x[i] = j; break; }
    return m;//返回的是左闭右开区间的长度
}

int occ[110][110][110];

void solve() {
    int N;
    scanf("%d", &N);
    int X[150], Y[150], Z[150];
    int xv[150], yv[150], zv[150];
    for (int i = 0; i < N; ++i) {
        scanf("%d%d%d%d%d%d", X + 2 * i, Y + 2 * i, Z + 2 * i, X + 2 * i + 1, Y + 2 * i + 1, Z + 2 * i + 1);
        X[2 * i + 1] += X[2 * i]; Y[2 * i + 1] += Y[2 * i]; Z[2 * i + 1] += Z[2 * i];
    }
    int xn = compress(2 * N, X, xv);
    int yn = compress(2 * N, Y, yv);
    int zn = compress(2 * N, Z, zv);
    memset(occ, 0, sizeof(occ));

    for (int i = 0; i < N; ++i)
    for (int x = X[2 * i]; x < X[2 * i + 1]; ++x)
    for (int y = Y[2 * i]; y < Y[2 * i + 1]; ++y)
    for (int z = Z[2 * i]; z < Z[2 * i + 1]; ++z)
        occ[x][y][z] = true;//标记所有有长方体的区域，注意是左闭右开区间
    vi Q;
    Q.push_back(0);
    occ[0][0][0] = -1;
    while (!Q.empty()) {//从外围进行BFS，加一圈“空气”，用-1表示
        int v = Q.back(); Q.pop_back();
        int x = v & 0xFF, y = (v >> 8) & 0xFF, z = (v >> 16) & 0xFF;//此处的编码，解码技巧值得学习，但要注意此时每个数不能超过255
        for (int d = 0; d < 6; ++d) {
            int nx = x + dx[d], ny = y + dy[d], nz = z + dz[d];
            if (nx >= 0 && ny >= 0 && nz >= 0 && nx < xn && ny < yn && nz < zn &&
                !occ[nx][ny][nz]) {
                occ[nx][ny][nz] = -1;
                Q.push_back((nz << 16) | (ny << 8) | nx);
            }
        }
    }
    ll vol = 0, area = 0;
    for (int x = 1; x < xn - 1; ++x)
    for (int y = 1; y < yn - 1; ++y)
    for (int z = 1; z < zn - 1; ++z) {
        int sx = xv[x + 1] - xv[x], sy = yv[y + 1] - yv[y], sz = zv[z + 1] - zv[z];
        if (occ[x][y][z] != -1) vol += (ll)sx*sy*sz;//该处存在方块，注意一定要写成“不等于-1”，因为此时内部的空气是0
        for (int d = 0; d < 6; ++d)
        if (occ[x][y][z] != -1 && occ[x + dx[d]][y + dy[d]][z + dz[d]] == -1)//点(x,y,z)处有方块，但延长一个单位方向后却是外围空气
            area += dx[d] ? sy*sz : dy[d] ? sx*sz : sx*sy;
    }
    printf("%lld %lld\n", area, vol);
}

int main(void) {
    int N;
    for (scanf("%d", &N); N--; solve());
    return 0;
}
//此题不会

个人觉得最后四题都是特别好的题，这里单拉一篇博客来写

最后四题 ->点此跳转
UVA - 1572 Self-Assembly
UVA - 1599 Ideal Path
UVA - 506 System Dependencies
UVA - 11853 Paintball