gougou40 (2)

  第2部份的4道题开始啦!

  Sortint It All Out,我用的是Floyd算法去判断有没有inconsistency(检查是否有自己相连的情况),然后统计已经得到的点的出入度(Floyed后,满足题意时出入度正好是0,1,2,...,n-1)可以去确定是否determine。不过这个算法貌似十分低效,正解应该是Topological Sorting……

#include 
#include 
#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
using namespace std;
const long double pi = 3.1415926535898;
int n;
bool mat[26][26];
struct A
{
    int i, n;
}a[26];
bool cmp(A a, A b)
{
    return a.n < b.n;
}
int check(string *str)
{
    bool tmpmat[26][26];
    memcpy(tmpmat, mat, sizeof(tmpmat));
    for(int k = 0; k < n; k++)
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                tmpmat[i][j] |= tmpmat[i][k] && tmpmat[k][j];
    for(int i = 0; i < n; i++)
        if(tmpmat[i][i])
            return -1;
    memset(a, 0, sizeof(a));
    for(int i = 0; i < n; i++)
    {
        a[i].i = i;
        for(int j = 0; j < n; j++)
            if(tmpmat[i][j])
                a[j].n++;
    }
    sort(a, a + n, cmp);
    for(int i = 0; i < n; i++)
    {
        if(a[i].n != i)
            return 0;
        *str += a[i].i + 'A';
    }
    return 1;
}
int main()
{
    int m;
    cin >> n >> m;
    while(n || m)
    {
        bool b = 0;
        memset(mat, 0, sizeof(mat));
        int M = m;
        while(m--)
        {
            char first, second;
            getchar();
            scanf("%c<%c", &first, &second);
            if(b)
                continue;
            mat[first - 'A'][second - 'A'] = 1;
            string str;
            int line = check(&str);
            if(line == 1)
                cout << "Sorted sequence determined after " << M - m << " relations: " << str << '.' << endl;
            if(line == -1)
                cout << "Inconsistency found after " << M - m << " relations." << endl;
            b = line;
        }
        if(!b)
            cout << "Sorted sequence cannot be determined." << endl;
        cin >> n >> m;
    }
    return 0;
}

  Space Station Shielding惭愧地搞定。一开始用DFS搜里面的grid cubes,后来发现没办法区分里面和外面,看了别人的代码后发现应该搜不属于这个n*m*k grid的外面一层,这样就可以判定里外了。一开始仍然用刚开始写的DFS,发现SF,测试了60 60 60 1 0这个数据发现的确是DFS太深Stack Overflow了,于是通过vector改用BFS,需要判断已加入vector的元素(已加入则一定不能再加入),用一个62*62*62的数组保存加入情况(本来使用find判断,后来发现自定义数据结构似乎无法用find?)。只要想到了以上这些写起来就比较方便:遇到ACM就加一个面,遇到非ACM的有效cube就不重复地加入vector,无效的情况就跳出。

#include 
#include 
#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
using namespace std;
const long double pi = 3.1415926535898;
const int di[6] = {1, -1, 0, 0, 0, 0};
const int dj[6] = {0, 0, 1, -1, 0, 0};
const int dk[6] = {0, 0, 0, 0, 1, -1};
struct grids
{
    int i, j, k;
}grid;
int n, m, k, ACM[60][60][60], cnt;
bool b[238328];
vector myvector;
void bfs(int length, int width, int height)
{
    for(int l = 0; l < 6; l++)
    {
        int ni = length + di[l], nj = width + dj[l], nk = height + dk[l];
        if(ni < -1 || ni > n || nj < -1 || nj > m || nk < -1 || nk > k)
            continue;
        if(ni >= 0 && ni < n && nj >= 0 && nj < m && nk >= 0 && nk < k && ACM[ni][nj][nk])
        {
            cnt++;
            continue;
        }
        if(!b[(ni + 1) + (nj + 1) * 62 + (nk + 1) * 62 * 62])
        {
            grid.i = ni;
            grid.j = nj;
            grid.k = nk;
            myvector.push_back(grid);
            b[(grid.i + 1) + (grid.j + 1) * 62 + (grid.k + 1) * 62 * 62] = 1;
        }
    }
}
int main()
{
    int l;
    while(cin >> n >> m >> k >> l, n || m || k || l)
    {
        memset(ACM, 0, sizeof(ACM));
        cnt = 0;
        memset(b, 0, sizeof(b));
        myvector.clear();
        for(int i = 0; i < l; i++)
        {
            int cube;
            cin >> cube;
            int height = cube / (n * m);
            cube %= n * m;
            int length = cube % n, width = cube / n;
            ACM[length][width][height] = 1;
        }
        grid.i = grid.j = grid.k = -1;
        myvector.push_back(grid);
        b[(grid.i + 1) + (grid.j + 1) * 62 + (grid.k + 1) * 62 * 62] = 1;
        for(int i = 0; i < int(myvector.size()); i++)
            bfs(myvector[i].i, myvector[i].j, myvector[i].k);
        cout << "The number of faces needing shielding is " << cnt << '.' << endl;
    }
    return 0;
}

  Square Ice搞定!很简单的模拟题(涉及到一点点的数列),固定m后,实际上除了'-'和'|'其他的字符全部都固定了(数列推一下即可),确定'-'和'|':+-1的情况很容易,0的情况只要看上面的或左边的'H'有没有被使用(用一个bool数组储存是用情况),没有就是用,有就是用下面的或右边的'H'即可(之所以是这样的顺序是因为推的过程是从上到下、从左到右,如果推的过程相反,那么前面的判断也应该相反)。最后在192上提交30ms,是最慢的,但不是很清楚哪里慢了……

#include 
#include 
#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
using namespace std;
const long double pi = 3.1415926535898;
int main()
{
    int n = 1;
    int m, ASM[11][11];
    char ice[43][48];
    bool H[43][48];
    while(cin >> m, m)
    {
        if(n != 1)
            cout << endl;
        cout << "Case " << n++ << ':' << endl << endl;
        int length = 4 * m + 3, width = 4 * m - 1;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < m; j++)
                cin >> ASM[i][j];
        for(int i = 0; i < width; i++)
            for(int j = 0; j < length; j++)
                if(i == 0 || i == width - 1 || j == 0 || j == length - 1)
                    ice[i][j] = '*';
                else
                    ice[i][j] = ' ';
        for(int i = 0; i < 4 * m - 1; i++)
            ice[i][4 * m + 3] = 0;
        for(int i = 1; i < width; i += 4)
            for(int j = 3; j < length; j += 4)
                ice[i][j] = 'O';
        for(int i = 1, tag = -1; i < width; i += 2, tag = -tag)
            for(int j = 2 + tag; j < length; j += 4)
                ice[i][j] = 'H';
        memset(H, 0, sizeof(H));
        for(int i = 0; i < m; i++)
            for(int j = 0; j < m; j++)
            {
                int l = 4 * j + 3, w = 4 * i + 1;
                if(ASM[i][j] == 1)
                {
                    ice[w][l + 1] = ice[w][l - 1] = '-';
                    H[w][l + 2] = H[w][l - 2] = 1;
                }
                if(ASM[i][j] == -1)
                {
                    ice[w + 1][l] = ice[w - 1][l] = '|';
                    H[w + 2][l] = H[w - 2][l] = 1;
                }
                if(!ASM[i][j])
                {
                    if(l >= 2 && !H[w][l - 2])
                    {
                        ice[w][l - 1] = '-';
                        H[w][l - 2] = 1;
                    }
                    else
                    {
                        ice[w][l + 1] = '-';
                        H[w][l + 2] = 1;
                    }
                    if(w >= 2 && !H[w - 2][l])
                    {
                        ice[w - 1][l] = '|';
                        H[w - 2][l] = 1;
                    }
                    else
                    {
                        ice[w + 1][l] = '|';
                        H[w + 2][l] = 1;
                    }
                }
            }
        for(int i = 0; i < width; i++)
            puts(ice[i]);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/zxfx100/archive/2013/06/11/3131903.html

你可能感兴趣的:(gougou40 (2))