输出最大选修学分问题

要解决这个问题，我们可以将课程先修关系建模为一个邻接列表，然后使用拓扑排序来确保我们按照先修顺序选择课程。接下来，我们将使用动态规划来找到最大学分的选课组合。

首先，我们需要创建一个二维数组adjacency_list来表示课程间的先修关系，其中adjacency_list[i]是一个整数数组，包含所有需要在课程i之前学习的课程索引。然后，定义一个一维数组dp用于存储动态规划状态，dp[i][j]表示前i个课程中选择j个课程时的最大学分。

以下是完整的C语言代码实现：

#include 
#include 

#define MAX_COURSES 100
#define MAX_STUDENTS 100

int adjacency_list[MAX_COURSES][MAX_COURSES];
int dp[MAX_COURSES + 1][MAX_STUDENTS + 1];

void add_edge(int from, int to) {
    adjacency_list[from][adjacency_list[from][0]++] = to;
}

int topological_sort(int n, int m) {
    int in_degree[MAX_COURSES] = {0};
    int i, j;

    for (i = 0; i < n; i++) {
        for (j = 0; j < adjacency_list[i][0]; j++) {
            in_degree[adjacency_list[i][j]]++;
        }
    }

    int stack[MAX_COURSES], top = -1;
    int sorted_courses[MAX_COURSES];
    int num_sorted = 0;

    for (i = 0; i < n; i++) {
        if (in_degree[i] == 0) {
            stack[++top] = i;
        }
    }

    while (top >= 0) {
        int cur_course = stack[top--];
        sorted_courses[num_sorted++] = cur_course;

        for (j = 0; j < adjacency_list[cur_course][0]; j++) {
            in_degree[adjacency_list[cur_course][j]]--;
            if (in_degree[adjacency_list[cur_course][j]] == 0) {
                stack[++top] = adjacency_list[cur_course][j];
            }
        }
    }

    return num_sorted <= m;
}

int max_score(int n, int m) {
    int i, j, k;
    int total_score = 0;

    for (i = 0; i < n; i++) {
        scanf("%d", &dp[i][0]);
        total_score += dp[i][0];
    }

    for (i = 1; i <= n; i++) {
        for (j = 1; j <= m; j++) {
            dp[i][j] = dp[i - 1][j];
            for (k = 0; k < adjacency_list[i - 1][0]; k++) {
                if (j >= adjacency_list[i - 1][k]) {
                    dp[i][j] = max(dp[i][j], dp[adjacency_list[i - 1][k]][j - adjacency_list[i - 1][k]] + dp[i - 1][0]);
                }
            }
        }
    }

    return dp[n][m];
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);

    for (int i = 0; i < n; i++) {
        dp[i][0] = 0;
    }

    for (int i = 0; i < n; i++) {
        dp[0][i] = 0;
    }

    int from, to;
    for (int i = 0; i < n; i++) {
        scanf("%d", &dp[i][0]);
    }

    for (int i = 1; i < n; i++) {
        scanf("%d %d", &from, &to);
        add_edge(from - 1, to - 1);
    }

    if (!topological_sort(n, m)) {
        printf("无法选满%d门课程\n", m);
    } else {
        int max_score_result = max_score(n, m);
        printf("最大学分: %d\n", max_score_result);
    }

    return 0;
}

这个程序首先读取课程数量、最大选修门数、每门课程的学分以及课程先修关系。接着，它使用邻接列表构建先修关系，并进行拓扑排序检查是否可以选满指定的课程数量。如果可以，它调用max_score函数使用动态规划计算最大可能的学分。

注意，这个代码没有处理错误输入的情况，实际应用中可能需要添加错误处理代码。此外，这个程序假定了输入的数据都是有效的，例如，所有的课程编号都在正确的范围内，并且不存在循环依赖的先修关系。