C++博客-程序大本营-随笔分类-ACM

HOJ 1027 - Equipment Box

远风 — Tue, 18 Aug 2009 02:51:00 GMT

地址：http://acm.hit.edu.cn/judge/show.php?Proid=1027
思路：假设A、B是外部矩形的长和宽，X、Y是内部矩形的长和宽，首先确保长>=宽，否则进行swap；分三种情况进行讨论，当Y>=B时不可能；当X=A&&Y代码如下：

#include <stdio.h>
#include <math.h>

#define PI 3.1415926

void swap(double &x, double &y)
{
    double tmp;

    tmp = x;
    x = y;
    y = tmp;
}

int main()
{
    int num;
    double A, B, X, Y;
    double diagIn;
    double radian1, radian2;
    double result;

    scanf("%d", &num);
    while(num)
    {
        num--;

        scanf("%lf%lf%lf%lf", &A, &B, &X, &Y);
        if(A < B)
            swap(A, B);
        if(X < Y)
            swap(X, Y);

        if(Y >= B)
        {
            printf("Box cannot be dropped.\n");
        }
        else if(X < A && Y < B)
        {
            printf("Escape is possible.\n");
        }
        else
        {
            diagIn = sqrt(pow(X / 2.0, 2) + pow(Y / 2.0, 2));
            radian1 = acos(B / (2 * diagIn));
            radian2 = 2 * acos(X / (2 * diagIn));
            result = diagIn * cos(PI / 2 - radian1 - radian2);
            if(result < A / 2.0)
            {
                printf("Escape is possible.\n");
            }
            else
            {
                printf("Box cannot be dropped.\n");
            }
        }
    }

    return 0;
}

远风 2009-08-18 10:51 发表评论

HOJ 1087 - Self Numbers

远风 — Mon, 17 Aug 2009 05:48:00 GMT

地址：http://acm.hit.edu.cn/judge/show.php?Proid=1087
思路：求1到1000000以内的自数，用了最笨的方法，先是i从1到1000000循环一遍求以i为基数的d(i)，对flag[d(i)]置true，然后利用flag[]判断为那些false的是自数。本以为会超时，结果居然AC了，自己也感觉很奇怪……
代码如下：

#include <stdio.h>
#include <memory.h>

#define MAX 1000001

int main()
{
    bool flag[MAX];
    int i;
    int result, tmp;

    memset(flag, 0, sizeof(flag));
    for(i = 1; i < MAX; i++)
    {
        tmp = result = i;
        while(tmp != 0)
        {
            result += tmp % 10;
            tmp /= 10;
        }

        if(result < MAX)
        {
            flag[result] = true;
        }
    }

    for(i = 1; i < MAX; i++)
    {
        if(flag[i] != true)
        {
            printf("%d\n", i);
        }
    }

    return 0;
}

远风 2009-08-17 13:48 发表评论

HOJ 1006 - Weird Clock

远风 — Sun, 16 Aug 2009 07:05:00 GMT

地址：http://acm.hit.edu.cn/judge/show.php?Proid=1006&Contestid=0
思路：最简单的方法就是用visted[60]来存储分针数是否重复过，如果重复了说明后面的结果在不断循环而不会到达0。然而更快捷的方法是利用60的因子分解，60=2*2*3*5，每次time = ((d + 1) * time) % 60，如果可以，那么最多2次就可以到达0，否则永远到达不了。
代码如下：

#include <stdio.h>

int main()
{
    int d, tmp;
    int num;

    while(scanf("%d%d", &tmp, &d) == 2 && (tmp || d))
    {
        if(tmp == 0)
        {
            printf("0\n");
            continue;
        }
        if(d == 0)
        {
            printf("Impossible\n");
            continue;
        }

        for(num = 1; num <= 2; num++)
        {
            tmp = ((d + 1) * tmp) % 60;
            if(tmp == 0)
                break;
        }

        if(tmp == 0)
            printf("%d\n", num);
        else
            printf("Impossible\n");
    }

    return 0;
}

远风 2009-08-16 15:05 发表评论

HOJ 1033 - Play on Words

远风 — Sun, 16 Aug 2009 06:38:00 GMT

摘要: 地址：http://acm.hit.edu.cn/judge/show.php?Proid=1033&Contestid=0思路：可以把这道题等价地看成有向图中求哈密顿路的问题，每个在单词首尾出现过的字母看作一个节点，每个单词首字母看作节点的出度加1，尾字母看作节点的入度加1，而形成哈密顿路的条件是除了哈密顿路首尾两个节点外，其他节点的出度等于入度，而首节点出度比入度多1，尾节点入度比出度... 阅读全文

远风 2009-08-16 14:38 发表评论

HOJ 1018 - Multiple

远风 — Fri, 14 Aug 2009 08:01:00 GMT

地址：http://acm.hit.edu.cn/judge/show.php?Proid=1018
思路：主要是利用BFS原理，先对给定的数（0～9）排序，然后利用这些数不断构造整数（该整数可以很大很大，需要用char型数组保存），先是1位数，然后是2位数、3位数……直到找到n的最小倍数或者构造无法继续为止。建立一个char型二维数组保存构造的整数来模仿队列机制（如果直接使用队列保存构造的整数，频繁地对char型数组push和front将会导致超时），一个队列保存构造的整数对n求余的结果（与前者同步），一个bool型数组作为余数是否重复的标识，如果余数重复将不保存该构造的整数及其相应余数。注意当n为0时不需构造，直接输出0即可。
代码：

#include <stdio.h>
#include <algorithm>
#include <queue>
#include <memory.h>
#include <string.h>

#define MAX_ROW 5000
#define MAX_COL 5000

using namespace std;

char data[MAX_ROW][MAX_COL];

int main()
{
    int n, m;
    int i;
    int digits[10];
    int pre, now;
    queue<int> residue;
    bool flag[5000], done;
    int tmp1, tmp2, leng;
    int num;

    while(scanf("%d%d", &n, &m) == 2)
    {
        if(n == 0)
        {
            printf("0\n");
            continue;
        }

        for(i = 0; i < m; i++)
        {
            scanf("%d", &(digits[i]));
        }

        done = false;
        num = 0;
        pre = now = 0;
        sort(digits, digits + m);
        memset(flag, 0, sizeof(flag));
        while(residue.size() > 0)
        {
            residue.pop();
        }
        residue.push(0);

        while(done == false && residue.size() > 0)
        {
            num++;
            tmp1 = residue.front();
            residue.pop();
            for(i = 0; i < m; i++)
            {
                if(num == 1)
                {
                    if(digits[i] != 0)
                    {
                        tmp2 = digits[i] % n;
                        data[now][0] = digits[i] + '0';
                        data[now][1] = '\0';
                        if(tmp2 == 0)
                        {
                            printf("%s\n", data[now]);
                            done = true;
                            break;
                        }
                        else if(flag[tmp2] == false)
                        {
                            flag[tmp2] = true;
                            now = (now + 1) % MAX_ROW;
                            residue.push(tmp2);
                        }
                    }
                }
                else
                {
                    tmp2 = (tmp1 * 10 + digits[i]) % n;
                    strcpy(data[now], data[pre]);
                    leng = strlen(data[now]);
                    data[now][leng] = digits[i] + '0';
                    data[now][leng + 1] = '\0';
                    if(tmp2 == 0)
                    {
                        printf("%s\n", data[now]);
                        done = true;
                        break;
                    }
                    else if(flag[tmp2] == false)
                    {
                        flag[tmp2] = true;
                        now = (now + 1) % MAX_ROW;
                        residue.push(tmp2);
                    }
                }
            }

            if(num != 1)
                pre = (pre + 1) % MAX_ROW;
        }

        if(done == false)
        {
            printf("0\n");
        }
    }

    return 0;
}

在编程时遇到二维数组data[MAX_ROW][MAX_COL]设置过大导致Runtime Error的问题，查阅资料后得知是因为局部变量占用栈空间，导致栈空间不足。
解决办法如下：
（1）将局部变量改为全局变量
（2）使用new或者malloc在堆上申请空间
（3）在设置中提高运行栈的大小（project->settings->link->category，选择output->reserve中设定栈大小，最小4Byte）

远风 2009-08-14 16:01 发表评论