Question

我是竞争编程的新手，我面临一个小问题在输入时在问题中，顶点的数量从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--;
        }




    }

Answer 1

您的代码有几个问题：

变量的范围太宽。您可以重用变量而无需重置它们。您可以通过在定义变量时使用尽可能接近的范围并在定义它们时对其进行初始化来避免这种情况。（重用旧值适用于parent和visited数组以及count。
计算爱丽丝的正确猜想时，内部循环的迭代变量为j，但检验alice[i]和parent[i]。
简化分数时，if应该是while，否则您将错过正方形和立方体。
在main中，您将顶点ver和变量v的数量混合在一起。

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

如上所述，您确实需要v时经常使用ver。变量v仅在扫描边缘时正确使用，并且对于基于1和基于0的输入当然是不同的。密探也是您的朋友在这里：将u和v放在扫描边缘的循环本地。

（就其价值而言，我认为该图的矩阵表示形式对较大的图没有用，因为该图是稀疏的。重复扫描100,000个条目的行时，您可能会浪费很多时间。）< / p>

显示相同输入的不同输出（近）

1 个答案: