给定n个计算节点的邻接矩阵，节点之间的通信代价各不相同，需要求得一种连接方式，使通信代价总和最小,且每个节点的度不超过k。请给出相应的不使用贪心算法的C语言代码

这个问题可以通过使用动态规划（Dynamic Programming）算法来解决。具体来说，我们可以定义一个二维数组dp，其中dp[i][j]表示前i个节点中选择j个节点连接的最小代价。然后，我们可以使用以下递推式来更新dp数组：

dp[i][j] = min(dp[i-1][j], min(dp[i-1][j-1]+cost[i][u]))

其中，cost[i][u]表示第i个节点和第u个节点之间的通信代价，u是前i-1个节点中选择的一个节点，且u的度数不超过k-1。最终的答案即为dp[n][k]。

以下是相应的C语言代码实现：

#include <stdio.h>
#include <limits.h>

#define MAX_N 100
#define MAX_K 10

int cost[MAX_N+1][MAX_N+1]; // 邻接矩阵
int dp[MAX_N+1][MAX_K+1];   // 动态规划数组

int min(int a, int b) {
    return a < b ? a : b;
}

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

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            scanf("%d", &cost[i][j]);
        }
    }

    // 初始化动态规划数组
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    dp[0][0] = 0;

    // 动态规划递推
    for (int i = 1; i <= n; i++) {
        dp[i][0] = 0;
        for (int j = 1; j <= k; j++) {
            for (int u = 0; u < i; u++) {
                if (j-1 <= u && cost[i][u+1] != -1) {
                    dp[i][j] = min(dp[i][j], dp[u][j-1]+cost[i][u+1]);
                }
            }
        }
    }

    // 输出结果
    int ans = INT_MAX;
    for (int j = 0; j <= k; j++) {
        ans = min(ans, dp[n][j]);
    }
    printf("%d\n", ans);

    return 0;
}

注意，这里假设节点之间的通信代价都是正整数，如果有负数代价，需要对算法进行一些修改。同时，邻接矩阵中没有连接的节点之间的代价应该设置为-1，代表不可达。