C++博客-lzmagic-随笔分类-POJ

poj 1094 Sorting It All Out

lzmagic — Sun, 12 Apr 2009 15:13:00 GMT

    wa了很多次，终于过了，咔咔~笑一下先。
    第一次很快用拓扑排序把代码敲出来，提交，wa，仔细分析后，发现忽略了重复边的情况，插入边(u, v)，如果图g已经存在了边(u,v)，就不能再增加v的入度。
    很快改过来，提交，还是wa，很无奈，上网看看大牛评论，原来是只要当前输入数据能“确定唯一”，及时后面输入数据“有环”，也是判定为“确定唯一”。也就是说，每输入一条边，如果判定有结果，忽略后面输入数据，即使后面输入数据能改变结果。
    再改，再提交，还是wa，几度欲放弃之，还是坚持下来了，上google找别人代码来分析，结果发选只要当前输入数据“有环”，及时当前输入数据“不能确定唯一”，也是判定为“有环”。
    把判定顺序改过后，提交，终于ac!!!
    呼~~~爽YY中……

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <climits>
#include <ctime>
#include <cstdlib>
#include <cctype>
using namespace std;

#define UNSURE 0 // 不能确定
#define CYCLED 1 // 存在回路
#define SORTED 2 // 已经排序

int n;                            // n ：顶点个数
vector<list<int> > g;           // g ：图
vector<int> top;                // top ：拓扑序列
vector<int> ins;                // ins ：入度

int Topsort()
{
    bool unsure(false);
    queue<int> que;
    vector<int> cnt(ins.begin(), ins.end());    // 用cnt存储ins，避免修改ins。
    for (int j = 0; j < n; ++j)
        if (cnt[j] == 0) que.push(j);            // 入度为0的顶点入队。
    int u;
    list<int>::iterator it;
    top.clear();
    while (!que.empty())
    {
        if (que.size() != 1) unsure = true;        // 如果选择顶点多余1个，不能确定。
        u = que.front(); que.pop();
        top.push_back(u);
        for (it = g[u].begin(); it != g[u].end(); ++it)
            if (--cnt[*it] == 0) que.push(*it);
    }
    if (top.size() != n) return CYCLED;        // 先判断是否有环，即使不能确定，
    if (unsure) return UNSURE;                // 再判断是否不能确定。
    return SORTED;
}

int main()
{
    int steps, ans;
    string exp;
    int m, u, v, i;

    while (cin >> n >> m, n != 0 || m != 0)    // 2 <= n <= 26
    {
        g.assign(n, list<int>());
        ins.assign(n, 0);
        ans = UNSURE;
        for (steps = 0; ans == UNSURE && steps < m; ++steps)
        {
            cin >> exp;
            u = int(exp[0] - 'A'), v = int(exp[2] - 'A');
            if (find(g[u].begin(), g[u].end(), v) == g[u].end()) // 如果不存在边(u, v)，添加。
                g[u].push_back(v), ++ins[v];
            ans = Topsort();
        }
        for (i = steps; i < m; ++i) cin >> exp; // 处理剩下无用的输入数据。

        if (ans == UNSURE) // Output()
            cout << "Sorted sequence cannot be determined." << endl;
        else if (ans == CYCLED)
            cout << "Inconsistency found after " << steps << " relations." << endl;
        else
        {
            cout << "Sorted sequence determined after " << steps << " relations: ";
            for (i = 0; i < n; i++) cout << char('A' + top[i]);
            cout << "." << endl;
        } // end Output()
    }
    system("pause");
    return 0;
}

ps.第一，要仔细看题，第二，还是要仔细看题。

lzmagic 2009-04-12 23:13 发表评论

poj 1024 Tester Program

lzmagic — Thu, 19 Mar 2009 00:59:00 GMT

/**
* (1)求各点到源点的最小步数（BFS）
* (2)求各点到终点的最小步数（BFS）
* (3)如果点不是给定路径上的点，那么：该点到源点的最小步数＋该点到终点的最小步数<给定路径的步数，否则给定路径不是唯一最短的
* (4)如果两相邻点a、b之间存在墙，那么：a到源点的最小步数＋1＋b到终点的最小步数<=给定路径的步数
*                              或者 a到终点的最小步数＋1＋b到源点的最小步数<=给定路径的步数，否则墙多余
* (5)如果存在点不可达，说明存在墙将该点封闭起来，可以证明墙至少有一块多余
*/
#include <iostream>
#include <string>
#include <queue>
using namespace std;

struct Grid
{
    bool inpath;    // 是否是路径方格
    bool uwal;      // 是否有上墙
    bool rwal;      // 是否有右墙
    int scnt;       // 到源点步数
    int dcnt;       // 到终点步数
};

int main(int argc, char** argv)
{
    bool ok;
    int w, h, cnt, steps;   // 1 <= w, h <= 100
    string path;
    Grid grid[100][100];
    queue<pair<int, int> > q;

    int t, x, y, desx, desy, x2, y2, i;
    for (cin >> t; t > 0; --t)
    {
        // 初始化数据
        cin >> w >> h;
        for (y = 0; y < h; ++y)
            for (x = 0; x < w; ++x)
            {
                grid[y][x].inpath = false;
                grid[y][x].uwal = false;
                grid[y][x].rwal = false;
                grid[y][x].scnt = -1;
                grid[y][x].dcnt = -1;
            }
        cin >> path;
        x = 0, y = 0;
        grid[0][0].inpath = true;
        steps = path.size();
        for (i = 0; i < steps; ++i)
        {
            switch(path[i])
            {
                case 'U': ++y; break;
                case 'D': --y; break;
                case 'L': --x; break;
                case 'R': ++x; break;
            }
            grid[y][x].inpath = true;
        }
        desx = x, desy = y;
        cin >> cnt;
        for (i = 0; i < cnt; ++i)
        {
            cin >> x >> y >> x2 >> y2;
            if (x == x2)
                if (y + 1 == y2) grid[y][x].uwal = true;
                else grid[y2][x].uwal = true;
            else
                if (x + 1 == x2) grid[y][x].rwal = true;
                else grid[y][x2].rwal = true;
        }

        // 求各点到源点的最小步数（BFS）
        q.push(make_pair(0, 0));
        grid[0][0].scnt = 0;
        while (!q.empty())
        {
            y = q.front().first, x = q.front().second;
            if (y < h - 1 && grid[y][x].uwal == false && grid[y + 1][x].scnt == -1)
            {
                grid[y + 1][x].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y + 1, x));
            }
            if (0 < y && grid[y - 1][x].uwal == false && grid[y - 1][x].scnt == -1)
            {
                grid[y - 1][x].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y - 1, x));
            }
            if (0 < x && grid[y][x - 1].rwal == false && grid[y][x - 1].scnt == -1)
            {
                grid[y][x - 1].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y, x - 1));
            }
            if (x < w - 1 && grid[y][x].rwal == false && grid[y][x + 1].scnt == -1)
            {
                grid[y][x + 1].scnt = grid[y][x].scnt + 1;
                q.push(make_pair(y, x + 1));
            }
            q.pop();
        }

        // 求各点到终点的最小步数（BFS）
        q.push(make_pair(desy, desx));
        grid[desy][desx].dcnt = 0;
        while (!q.empty())
        {
            y = q.front().first, x = q.front().second;
            if (y < h - 1 && grid[y][x].uwal == false && grid[y + 1][x].dcnt == -1)
            {
                grid[y + 1][x].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y + 1, x));
            }
            if (0 < y && grid[y - 1][x].uwal == false && grid[y - 1][x].dcnt == -1)
            {
                grid[y - 1][x].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y - 1, x));
            }
            if (0 < x && grid[y][x - 1].rwal == false && grid[y][x - 1].dcnt == -1)
            {
                grid[y][x - 1].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y, x - 1));
            }
            if (x < w - 1 && grid[y][x].rwal == false && grid[y][x + 1].dcnt == -1)
            {
                grid[y][x + 1].dcnt = grid[y][x].dcnt + 1;
                q.push(make_pair(y, x + 1));
            }
            q.pop();
        }

        // 判断路径是否唯一最短，以及墙是否多余
        ok = true;
        for (y = 0; y < h && ok; ++y)
            for (x = 0; x < w && ok; ++x)
            {
                if (grid[y][x].scnt == -1 || grid[y][x].dcnt == -1)
                    ok = false;     // 是否有封闭区域
                if (y < h - 1 && grid[y][x].uwal
                        && grid[y][x].scnt + grid[y + 1][x].dcnt + 1 > steps
                        && grid[y][x].dcnt + grid[y + 1][x].scnt + 1 > steps)
                    ok = false;     // 是否上墙多余
                if (x < w - 1 && grid[y][x].rwal
                        && grid[y][x].scnt + grid[y][x + 1].dcnt + 1 > steps
                        && grid[y][x].dcnt + grid[y][x + 1].scnt + 1 > steps)
                    ok = false;     // 是否右墙多余
                if (!grid[y][x].inpath && grid[y][x].scnt + grid[y][x].dcnt <= steps)
                    ok = false;     // 是否存在更短路径或另一最短路径
            }
        if(ok) cout << "CORRECT" << endl;
        else cout << "INCORRECT" << endl;
    }

    return 0;
}

lzmagic 2009-03-19 08:59 发表评论

poj 1022 Packing Unit 4D Cubes

lzmagic — Wed, 18 Mar 2009 04:04:00 GMT

/**
* FloodFill算法，深度遍历搜索。
*/
#include <iostream>
#include <map>
using namespace std;

struct Cube
{
    bool used;          // 是否已经使用
    int cood[4];        // 坐标
    int neighbor[4][2]; // 相邻标识号
};

void FloodFill(int row, int cnt, Cube *cube, int maxmin[4][2])
{
    if (cube[row].used == false)
    {
        cube[row].used = true;

        int i, j, k, row2;
        for (i = 0; i < 4; ++i)
            for (j = 0; j < 2; ++j)
                if (cube[row].neighbor[i][j] != -1 && cube[cube[row].neighbor[i][j]].used == false)
                {
                    row2 = cube[row].neighbor[i][j];
                    for (k = 0; k < 4; ++k)
                        cube[row2].cood[k] = cube[row].cood[k];
                    if (j == 0)
                    {
                        ++cube[row2].cood[i];
                        if (maxmin[i][0] < cube[row2].cood[i])
                            maxmin[i][0] = cube[row2].cood[i];
                    }
                    else
                    {
                        --cube[row2].cood[i];
                        if (maxmin[i][1] > cube[row2].cood[i])
                            maxmin[i][1] = cube[row2].cood[i];
                    }
                    FloodFill(row2, cnt, cube, maxmin);
                }
    }
}

int main(int argc, char** argv) {

    bool ok;
    int cnt;    // 1 <= cnt <= 100
    int maxmin[4][2];
    int minv;
    Cube cube[100];
    map <int, int> idmap;

    int t, i, j, k, id;
    for (cin >> t; t > 0; --t)
    {
        // 输入数据
        cin >> cnt;
        idmap.clear();
        for (i = 0; i < cnt; ++i)
        {
            cube[i].used = false;
            cin >> id;
            idmap[id] = i;
            for (j = 0; j < 4; ++j)
                for (k = 0; k < 2; ++k)
                    cin >> cube[i].neighbor[j][k];
        }

        // 标识号改为对应的行号
        for (i = 0; i < cnt; ++i)
            for (j = 0; j < 4; ++j)
                for (k = 0; k < 2; ++k)
                    cube[i].neighbor[j][k] = (cube[i].neighbor[j][k] == 0) ? -1 : idmap[cube[i].neighbor[j][k]];

        // 判断是否对称
        ok = true;
        for (i = 0; i < cnt && ok; ++i)
            for (j = 0; j < 4 && ok; ++j)
                for (k = 0; k < 2 && ok; ++k)
                    if (cube[i].neighbor[j][k] != -1 && cube[cube[i].neighbor[j][k]].neighbor[j][1 - k] != i)
                        ok = false;
        if (!ok)
        {
            cout << "Inconsistent" << endl;
            continue;
        }

        // Flood Fill 算法 (种子染色法)
        for (i = 0; i < 4; ++i) cube[i].cood[i] = 0;
        for (i = 0; i < 4; ++i) maxmin[i][0] = maxmin[i][1] = 0;
        FloodFill(0, cnt, cube, maxmin);

        // 判断是否连通
        ok = true;
        for (i = 0; i < cnt && ok; ++i)
            if (cube[i].used == false)
                ok = false;
        if (!ok)
        {
            cout << "Inconsistent" << endl;
            continue;
        }

        // 计算最小体积
        minv = 1;
        for (i = 0; i < 4; ++i)
            minv *= maxmin[i][0] - maxmin[i][1] + 1;
        cout << minv << endl;
    }
    return 0;
}

测试数据：
Input:
6
9
1 2 3 4 5 6 7 8 9
2 0 1 0 0 0 0 0 0
3 1 0 0 0 0 0 0 0
4 0 0 0 1 0 0 0 0
5 0 0 1 0 0 0 0 0
6 0 0 0 0 0 1 0 0
7 0 0 0 0 1 0 0 0
8 0 0 0 0 0 0 0 1
9 0 0 0 0 0 0 1 0
2
3 0 0 1 0 0 0 0 0
1 0 0 3 0 0 0 0 0
4
1 2 0 0 0 0 0 0 0
2 0 1 0 0 0 0 0 0
3 0 0 4 0 0 0 0 0
4 0 0 0 3 0 0 0 0
5
101 2 0 0 0 0 0 0 0
2 0 101 321 0 0 0 0 0
321 4 0 0 2 0 0 0 0
4 5 321 0 0 0 0 0 0
5 0 4 0 0 0 0 0 0
1
10 0 0 0 0 0 0 0 0
4
1 0 2 4 0 0 0 0 0
2 1 0 3 0 0 0 0 0
3 4 0 0 2 0 0 0 0
4 0 3 0 1 0 0 0 0

Output:
81
Inconsistent
Inconsistent
8
1
4

lzmagic 2009-03-18 12:04 发表评论