Question

我的代码工作正常，但在创建周期时未能通过对跳对的check50测试。我用来检查周期的逻辑是，在创建从赢家到输家的优势之前，我先从赢家退回优势，并检查它是否到达了输家。如果确实如此，则意味着它将创建一个循环，因此会跳过边缘，但不起作用。如果让我知道，我的逻辑也可能是错误的。这是我的代码-

#include <cs50.h>
#include <stdio.h>
#include <string.h>

// Max number of candidates
#define MAX 9

// preferences[i][j] is number of voters who prefer i over j
int preferences[MAX][MAX];

// locked[i][j] means i is locked in over j
bool locked[MAX][MAX];

// Each pair has a winner, loser
typedef struct
{
    int winner;
    int loser;
}
pair;

// Array of candidates
string candidates[MAX];
pair pairs[MAX * (MAX - 1) / 2];

int pair_count;
int candidate_count;

// Function prototypes
bool vote(int rank, string name, int ranks[]);
void record_preferences(int ranks[]);
void add_pairs(void);
void sort_pairs(void);
void lock_pairs(void);
void print_winner(void);
bool check_cycle(int n, int m);

int main(int argc, string argv[])
{
    // Check for invalid usage
    if (argc < 2)
    {
        printf("Usage: tideman [candidate ...]\n");
        return 1;
    }

    // Populate array of candidates
    candidate_count = argc - 1;
    if (candidate_count > MAX)
    {
        printf("Maximum number of candidates is %i\n", MAX);
        return 2;
    }
    for (int i = 0; i < candidate_count; i++)
    {
        candidates[i] = argv[i + 1];
    }

    // Clear graph of locked in pairs
    for (int i = 0; i < candidate_count; i++)
    {
        for (int j = 0; j < candidate_count; j++)
        {
            locked[i][j] = false;
        }
    }

    pair_count = 0;
    int voter_count = get_int("Number of voters: ");

    // Query for votes
    for (int i = 0; i < voter_count; i++)
    {
        // ranks[i] is voter's ith preference
        int ranks[candidate_count];

        // Query for each rank
        for (int j = 0; j < candidate_count; j++)
        {
            string name = get_string("Rank %i: ", j + 1);

            if (!vote(j, name, ranks))
            {
                printf("Invalid vote.\n");
                return 3;
            }
        }

        record_preferences(ranks);

        printf("\n");
    }

    add_pairs();
    sort_pairs();
    lock_pairs();
    print_winner();
    return 0;
}

// Update ranks given a new vote
bool vote(int rank, string name, int ranks[])
{
    // TODO
    for (int i = 0; i < candidate_count; i++)
    {
        if (strcmp(candidates[i], name) == 0)
        {
            ranks[rank] = i;
            return true;
        }
    }

    return false;
}

// Update preferences given one voter's ranks
void record_preferences(int ranks[])
{
    // TODO
    for (int i = 0; i < candidate_count; i++)
    {
        for (int j = 1; j < candidate_count - i; j++)
        {
            preferences[ranks[i]][ranks[i + j]]++;
        }
    }

    return;
}

// Record pairs of candidates where one is preferred over the other
void add_pairs(void)
{
    // TODO
    for (int i = 0; i < candidate_count; i++)
    {
        for (int j = 0; j < candidate_count; j++)
        {
            if (preferences[i][j] > preferences[j][i])
            {
                pairs[pair_count].winner = i;
                pairs[pair_count].loser = j;
                pair_count++;
            }
        }
    }

    return;
}

// Sort pairs in decreasing order by strength of victory
void sort_pairs(void)
{
    // TODO
    pair k;
    for (int i = 0; i < pair_count; i++)
    {
        for (int j = i + 1; j < pair_count; j++)
        {
            if (preferences[pairs[i].winner][pairs[i].loser] < preferences[pairs[j].winner][pairs[j].loser])
            {
                //memcpy
                k = pairs[i];
                pairs[i] = pairs[j];
                pairs[j] = k;
            }
        }
    }

    return;
}

// Lock pairs into the candidate graph in order, without creating cycles
void lock_pairs(void)
{
    // TODO
    for (int i = 0; i < pair_count; i++)
    {
        if (!check_cycle(pairs[i].winner, pairs[i].loser))
        {
            locked[pairs[i].winner][pairs[i].loser] = true;
        }
    }
    return;
}

// Print the winner of the election
void print_winner(void)
{
    // TODO
    for (int i = 0; i < candidate_count; i++)
    {
        bool source = true;

        for (int j = 0; j < candidate_count; j++)
        {
            if (locked[j][i] == true)
            {
                source = false;
                break;
            }
        }

        if (source == true)
        {
            printf("%s\n", candidates[i]);
        }
    }

    return;
}

//checking for cycle
bool check_cycle(int n, int m)
{
    if (locked[m][n] == true)
    {
        return true;
    }

    for (int i = 0; i < candidate_count; i++)
    {
        if (locked[i][n] == true)
        {
            check_cycle(i, m);
        }
    }
    return false;
}

Answer 1

您只是在反转循环的方向。我使用了与您相同的逻辑，并且有效： 1.看看当前的失败者是否锁定了当前的胜利者； 2.如果是，则返回true；否则，返回true。 3.否则，看看是否还有其他人锁定了当前的获胜者； 4.递归调用循环检查器，以查看当前失败者是否锁定到“ i”。现在请谨慎执行此步骤，因为您必须将值传递给函数，以便基本案例检查器执行[loser] [i]而不是[i] [loser]，因为基本案例检查了初始LOSER是否锁定在获胜者身上。并记得回来。这是我使用的代码，效果很好。

//Can_reach recursive auxiliary function: returns true if a can reach b.
//a = initial winner, b = initial loser
bool loopcheck(int a, int b)
{
    if (locked[b][a] == true)
    {
        return true;
    }

    for (int i = 0; i < candidate_count; i++)
    {
        if (locked[i][a] == true)
            {
            return loopcheck(i, b);
        }
    }
    return false;
}

Answer 2

我认为以前的某些答案没有给出正确的答案。

对于n个候选人，存在ith个候选人，没有指向她或他的箭头，当且仅当 “锁定”表全为假。在这种情况下，如果第i列必须是节点，则可以绘制带有n个节点的圆。
但是，这不能保证没有其他较小的圈子。如果我们将“锁定”表缩小一倍（即删除 nth个候选人，现在我们将有一个(n-1) *(n-1)被“锁定” 表。像我们在step(1)中所做的一样，我们可以确保也无法绕过n-1个节点。重复此过程，就不可能有圆圈（任何大小）。
我们可以使用递归检查它。

如果不检查是否可以缩小圆角，则会出现如下错误：

lock_pairs如果创建周期则跳过中间对 lock_pairs无法正确锁定所有非周期性对

这是代码：

bool is_circle (bool locked_array[MAX][MAX], int candi_count)
{
    //check the basic case
    //if there is only one node of course it doesn't form a circle
    if (candi_count == 1)
    {
        return false;
    }

    //recursively check whether the smaller locked_array with n-1 candidate form a circle
    //if the smaller one have a circle
    //this mean a middle pair create a circle if added into the "locked" table
    if (!is_circle(locked_array, candi_count - 1))
    {
        //if the one-size smaller "locked" table doesn't have a circle
        //check whether adding a new candidate forms a circle

        //if there is a column that is all false's after adding a new candidate
        //then it must not introduce a circle in this step
        for (int j = 0; j < candi_count; j++)
        {
            //a indicator variable for check whether a column has a true value;
            bool true_in_column = false;

            for (int i = 0; i < candi_count; i++)
            {
                if (locked_array[i][j] == true)
                {
                    true_in_column = true;
                }
            }

            //if there is a column doesn't have a true value then not circle is create at this step
            if (true_in_column == false)
            {
                return false;
            }
        }

        //if we cannot find such a column then the graph represented by current locked array
        //must have a circle
        return true;

    }

    //the smaller "locked" table forms a circle
    else
    {
        return true;
    }

}

Answer 3

if (locked[i][n] == true)，则此“获胜者”（n）在另一个锁定对中是“失败者”，因此将创建一个循环。 IMO就是您决定是否在lock_pairs函数中锁定此对的全部信息。

Answer 4

在if (locked[i][n] == true)内，如果check_cycle(i, m)返回true，则还应该在check_cycle（n，m）中返回true，以使函数正常工作。

Answer 5

我想出了这个非递归版本。在锁定货币对之前，如果有锁定节点，则在一个锁定节点中搜索失败者成为赢家-跳过它。

//set first locked pair
if(pair_count > 0)
{
    locked[pairs[0].winner][pairs[0].loser] = true;
}

for (int i = 1; i < pair_count; i++)
{
    bool cycle = false;
    for (int j = 0; j < pair_count; j++){
        if(locked[pairs[i].loser][j])
        {
            cycle = true;
            break;
        }
    }

    //check if adding this node will create a cycle
    if(!cycle)
    {
        locked[pairs[i].winner][pairs[i].loser] = true;
    }
}

Answer 6

我认为您在check_cycle (i, m)中的if (locked[i][n] == true)返回的值不一致

这是修复此问题的代码

bool check_cycle(int n, int m)
{
    if (locked[m][n] == true)
    {
        return true;
    }

    for (int i = 0; i < candidate_count; i++)
    {
        if (locked[i][n] == true)
        {
            if (check_cycle(i, m))
            {
                return true;   
            }
            else 
            {
                return false;
            }
        }
    }
    return false;
}

Answer 7

//Set all the edges in graph
for (int i = 0; i < pair_count; i++)
{
    locked[pairs[i].winner][pairs[i].loser] = true;
}
//Check if there is a cycle remove the edges that make a cycle
for (int i = 0; i < pair_count; i++)
{
    for (int j = i + 1; j < pair_count; j++)
    {
        if (pairs[i].winner == pairs[j].loser)
        {
            locked[pairs[j].winner][pairs[j].loser] = false;
        }
    }
}

Answer 8

只需从您的lock_pairs函数中以（失败者，获胜者）作为参数来调用此函数，即可检查失败者是否具有可以追溯到获胜者的任何连接。

为了简化是否要检查的问题，可以建立连接a-> b，然后只需调用if（！circle（b，a）{}。如果链接将在封闭的循环中返回，则结果为true，否则为false如果不是，我们在进入n（要检查的目标）和i（我们要继续跟踪的ID）的同时实质上进入了递归模式

Private Sub Worksheet_Change(ByVal Target As Excel.Range)

If Range("h2").Value <> "" Then
    Range("g4").Select
End If

如何检查图中的周期？

8 个答案: