【问题标题】:showing different output for same input(nearly)显示相同输入的不同输出(几乎)
【发布时间】:2019-04-21 04:10:24
【问题描述】:

伙计们,我是竞争性编程的新手,我面临一个小问题 在提供输入的同时 在问题中的顶点数从 1 到 n 但我编写程序时考虑到节点从 0 开始

但是当我通过从每条边的每个顶点减少 1 来输入测试用例时,我的程序在给定的测试用例中运行良好;

given test case;
1(checking for first one only otherwise 2 was given)
4
1 2
1 3
3 4
2 2
1 2
3 4

my test case(after reducing 1 from edges):
1
4
0 1
0 2
2 3
2 2
0 1
2 3

问题链接:

https://hackerrank-challenge-pdfs.s3.amazonaws.com/29036-the-story-of-a-tree-English?AWSAccessKeyId=AKIAJ4WZFDFQTZRGO3QA&Expires=1542565481&Signature=WoegY4gKUz0OUDEQ3n2UT80FUc0%3D&response-content-disposition=inline%3B%20filename%3Dthe-story-of-a-tree-English.pdf&response-content-type=application%2Fpdf

但是当我改变我正在改变的 graph[(u-1)][(v-1)] = 1; graph[(v-1)][(u-1)] = 1; 在获取输入边时 也在这里alice[(vchild-1)] = (upar-1); 在我的程序中采用给定的测试用例,但这次我的答案出错了,我还在获取输入边的同时从每个顶点减少 1 为什么会发生这种情况?

    #pragma warning(disable:4996)
    #include<stdio.h>
    #include<stdlib.h>
    int visited[1000],parent[100],alice[100];
    struct queue {
        int rear;
        int front;
        int capacity;
        int* array;
    };

    struct queue* createqueue(int capacity) {
        struct queue* Q = (struct queue*)malloc(sizeof(struct queue));
        Q->capacity = capacity;
        Q->front = -1;
        Q->rear = -1;
        Q->array = (int*)malloc(sizeof(int)*capacity);
        return Q;
    }
    int isempty(struct queue* Q) {
        return(Q->front == -1 && Q->rear == -1);

    }
    int isfull(struct queue* Q) {
        return((Q->rear + 1) % Q->capacity == Q->front);

    }
    void push(struct queue* Q, int data) {
        if (isfull(Q))
            return;
        else if (isempty(Q))
        {
            Q->rear = 0;
            Q->front = 0;
            Q->array[Q->rear] = data;
        }
        else {
            Q->rear = ((Q->rear + 1) % Q->capacity);
            Q->array[Q->rear] = data;
        }
    }
    int pop(struct queue* Q) {
        if (isempty(Q))
            return -1;
        else if (Q->rear == Q->front) {
            int temp = Q->rear;
            Q->rear = -1;
            Q->front = -1;
            return(Q->array[temp]);
        }
        else {
            int temp = Q->front;
            Q->front = ((Q->front + 1) % Q->capacity);
            return Q->array[temp];

        }
    }
    void bfs(int** graph ,int ver,int s) {
        struct queue* Q=createqueue(100);
        push(Q, s);
        visited[s] = 1;
        int v, w;
        while (!isempty(Q)) {
            v = pop(Q);
            for (int j = 0; j < ver; j++) {
                if (visited[j] == 0 && graph[v][j] == 1)
                {
                    parent[j] = v;
                    push(Q, j);
                    visited[j] = 1;
                }
            }
        }
    }
    int main() {
        int t;
        scanf("%d", &t);
        while (t) {
            int** graph;
            int i, ver, u, v;
            scanf("%d", &ver);
            graph = (int**)malloc(sizeof(int*)*ver);
            for (i = 0; i < ver; i++)
                graph[i] = (int*)malloc(sizeof(int)*ver);
            for (int i = 0; i < ver; i++) {
                for (int j = 0; j < ver; j++) {
                    graph[i][j] = 0;
                }
            }
            //  printf("%d", graph[1][1]);
            for (int j = 0; j < ver - 1; j++) {
                scanf("%d %d", &u, &v);
                graph[u-1][v-1] = 1;
                graph[v-1][u-1] = 1;
            }
            int g, k;
            scanf("%d %d", &g, &k);
            int count = 0, win = 0;
            int vchild, upar;
            for (int i = 0; i < ver; i++)
                alice[i] = -1;
            for (int i = 0; i < g; i++) {
                scanf("%d %d", &upar, &vchild);
                alice[vchild-1] = upar-1;
            }
            for (int i = 0; i < v; i++) {
                bfs(graph, v, i);
                for (int j = 0; j < v; j++) {
                    if (alice[i] != -1 && alice[i] == parent[i])
                        count++;
                }
                if (count >= k)
                    win++;
            }
            for (int i = 2; i <= win && i <= ver; i++) {
                if (win%i == 0 && ver%i == 0) {
                    win = win / i;
                    ver = ver / i;
                }
            }
            printf("%d/%d\n", win, ver);
            t--;
        }




    }

【问题讨论】:

  • 在调试器中单步执行似乎是一个很好的案例,因此您可以看到有什么区别。您还错过了在修改后的测试用例中更改一行。
  • 先生请帮忙
  • 在你的 scanf 行上添加一些错误检查,它返回一个值是有原因的。在程序的每个阶段添加一些 printfs,这样您就可以看到它运行时发生了什么。将您的 -1 更改为 -X 以便您可以轻松地更改您的程序以接受基于 1 和基于 0 的数据,以便您可以比较您添加的打印语句的输出并查看差异在哪里。通读:ericlippert.com/2014/03/05/how-to-debug-small-programs 调试是程序员可以拥有的最重要的技能。在您的程序还很小的时候立即学习。

标签: c algorithm graph


【解决方案1】:

你的代码有几个问题:

  • 变量的范围太宽。您可以重用变量而不重置它们。您可以通过在定义变量时使用最接近的可能范围并在定义变量时对其进行初始化来避免这种情况。 (重用旧值适用于您的 parentvisited 数组以及 count
  • 算Alice猜对的时候,内循环的迭代变量是j,但是你测试alice[i]parent[i]
  • 当您简化分数时,if 应该是 while,否则您将错过正方形和立方体。
  • main 中,您会混淆顶点数量ver 和变量v

但是当您将零索引变量作为输入时,为什么输出会有所不同?

正如我上面所说,当你真正想要ver 时,你经常使用v。变量v 仅在扫描边缘时正确使用,当然,对于基于 1 的输入和基于 0 的输入是不同的。关闭 scpoing 也是您的朋友:将 uv 设置为您扫描边缘的循环本地。

(对于它的价值,我不认为图的矩阵表示对较大的图有用,因为图是稀疏的。重复扫描 100,000 个条目的行时,您可能会浪费很多时间。)

【讨论】:

  • 好吧,修改你的代码。它有很多错误。我已经指出了一些。还要注意在 cmets 中给你的关于调试的建议。是你想参加比赛,所以它也应该是你的代码。 (此类比赛的理念是通过编程来学习。)
  • 先生,我整晚都尽力了,我还解决了您告诉我的问题,我仍然只通过了一个测试用例我自己尝试进行了许多大型测试,但我都通过了但它仍然没有通过系统测试用例,并且在某些一两个测试用例中它显示分段错误也请再次查看我的代码 [ideone.com/5pNxn5]
  • 拜托我不会再问你一次
  • 现在看起来好多了 :)。我没有看到任何基本故障。但请删除system("pause") 并确保您分配的所有内容都已free。我在您的代码中看到的问题是它非常低效。对于大型稀疏图,您的邻接矩阵查找速度很慢。您为每个访问分配或释放的队列很慢。您不需要访问过的数组;您可以检查是否已经设置了父级。
  • 最后,您不必对每个节点进行全遍历。这是一个你可以用铅笔和纸解决的问题:画一棵小树,比如五个节点。列出所有父节点,从节点 1 开始。然后列出所有父节点,从节点 1 的邻居节点开始。区别在哪里?也许这可以帮助您找到更有效的策略。祝你好运!
猜你喜欢
  • 1970-01-01
  • 2017-03-16
  • 1970-01-01
  • 2017-03-15
  • 1970-01-01
  • 2021-09-09
  • 1970-01-01
  • 2012-09-08
  • 1970-01-01
相关资源
最近更新 更多