CS50 Tideman代码无法编译，请求技术支持

以下是我的代码：

#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];
pair swap[0];

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 lock_check(int ii, int jj);

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(name, candidates[i]) == 0)
    {
        ranks[rank] = i;
        return true;
    }
}
return false;
}

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

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

// Sort pairs in decreasing order by strength of victory
void sort_pairs(void)
{
//compare people that prefer winner to loser
for (int i = 0; i < pair_count; i++)
{
    for (int j = 0; j < pair_count - i - 1; j++)
    {
        int i1 = pairs[j].winner;
        int j1 = pairs[j].loser;

        int strength_pair1 = preferences[i1][j1] - preferences[j1][i1];

        int i2 = pairs[j + 1].winner;
        int j2 = pairs[j + 1].loser;

        int strength_pair2 = preferences[i2][j2] - preferences[j2][i2];

        if (strength_pair1 < strength_pair2)
        {
            swap[0] = pairs[j];
            pairs[j] = pairs[j + 1];
            pairs[j + 1] = swap[0];
        }
    }
}
return;
}

// Lock pairs into the candidate graph in order, without creating cycles
void lock_pairs(void)
{
// Loop pairs
for (int i = 0; i < pair_count; i++)
{
    int ii = pairs[i].winner;
    int jj = pairs[i].loser;
    locked[ii][jj] = true;

    if (lock_check(ii, jj))
    {
        locked[ii][jj] = false;
    }
}
return;
}

// Print the winner of the election
void print_winner(void)
{
for (int j = 0; j < candidate_count; j++)
{
    int counter1 = 0;

    for (int i = 0; i < candidate_count; i++)
    {
        if (locked[j][i] == false)
        {
            counter1++;

            if (counter1 ++ candidate_count)

                printf("%s\n", candidates[j]);
            }
        }
    }

return;

}

bool lock_check(int ii, int jj)
{
if (candidate_count == 1)

return false;

if (ii == jj)

return true;

for (int i = 0; i < candidate_count; i++)
{
    if (locked[jj][i] == true)
    {
        if (lock_check(ii, i))
    return true;
    }
}

    return false;
}

check50测试结果 #

• ✅ tideman.c 文件存在
• ❌ tideman 编译失败
• ⚠️ 当输入候选人姓名时vote返回true：需先解决编译问题才能进行检查
• ⚠️ 当输入无效姓名时vote返回false：需先解决编译问题才能进行检查
• ⚠️ vote正确设置第一偏好的排名：需先解决编译问题才能进行检查
• ⚠️ vote正确设置所有偏好的排名：需先解决编译问题才能进行检查
• ⚠️ record_preferences正确设置第一位选民的偏好：需先解决编译问题才能进行检查
• ⚠️ record_preferences正确设置所有选民的偏好：需先解决编译问题才能进行检查
• ⚠️ 无平局时add_pairs生成正确的配对数量：需先解决编译问题才能进行检查
• ⚠️ 存在平局时add_pairs生成正确的配对数量：需先解决编译问题才能进行检查
• ⚠️ add_pairs将获胜配对填入pairs数组：需先解决编译问题才能进行检查
• ⚠️ add_pairs不将失败配对填入pairs数组：需先解决编译问题才能进行检查
• ⚠️ sort_pairs按获胜优势降序排序配对：需先解决编译问题才能进行检查
• ⚠️ 无环时lock_pairs锁定所有配对：需先解决编译问题才能进行检查
• ⚠️ 若最后一对会创建环则lock_pairs跳过：需先解决编译问题才能进行检查
• ⚠️ 若中间一对会创建环则lock_pairs跳过：需先解决编译问题才能进行检查
• ⚠️ 当一位候选人击败所有对手时print_winner输出胜者：需先解决编译问题才能进行检查
• ⚠️ 存在部分平局时print_winner输出胜者：需先解决编译问题才能进行检查

编译错误修复方案 #

1. 修复record_preferences循环变量错误
   原代码中for (int j = i + j; j < candidate_count; j++)是无效的初始化逻辑，会导致无限循环，修正为：

   for (int j = i + 1; j < candidate_count; j++)
   

2. 替换无效的swap数组
   全局定义的pair swap[0];长度为0，无法存储数据，排序时访问会越界。直接用临时变量替代交换逻辑，修改sort_pairs中的交换代码：

   if (strength_pair1 < strength_pair2)
   {
       pair temp = pairs[j];
       pairs[j] = pairs[j + 1];
       pairs[j + 1] = temp;
   }
   

   同时删除全局的pair swap[0];定义。

3. 修复print_winner语法与逻辑错误
   原代码存在运算符缺失、大括号不匹配、判断逻辑错误的问题，修正后：

   void print_winner(void)
   {
       for (int j = 0; j < candidate_count; j++)
       {
           int in_edge_count = 0;
           for (int i = 0; i < candidate_count; i++)
           {
               if (locked[i][j])
               {
                   in_edge_count++;
               }
           }
           // 没有入边的节点就是胜者
           if (in_edge_count == 0)
           {
               printf("%s\n", candidates[j]);
               return;
           }
       }
       return;
   }
   

4. 修正lock_check递归逻辑与调用方式
   原递归逻辑方向错误，应该检查从败者能否回到胜者（即添加边后是否形成环），修正lock_check：

   bool lock_check(int start, int end)
   {
       if (start == end)
       {
           return true;
       }
       for (int i = 0; i < candidate_count; i++)
       {
           if (locked[end][i])
           {
               if (lock_check(start, i))
               {
                   return true;
               }
           }
       }
       return false;
   }
   

   同时修改lock_pairs中的调用逻辑，先检查再锁定：

   void lock_pairs(void)
   {
       for (int i = 0; i < pair_count; i++)
       {
           int winner = pairs[i].winner;
           int loser = pairs[i].loser;
           if (!lock_check(loser, winner))
           {
               locked[winner][loser] = true;
           }
       }
       return;
   }
   

内容的提问来源于stack exchange，提问作者Jordan