请生成一段可以在vs2010上运行的c语言代码，实现动态输入一个有向图的邻接矩阵，输出该图的强分图的邻接矩阵和弱分图的邻接矩阵

好的，以下是可以在vs2010上运行的c语言代码，实现动态输入一个有向图的邻接矩阵，输出该图的强分图的邻接矩阵和弱分图的邻接矩阵：

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100

typedef struct {
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
    int vexnum; // 顶点数
} Graph;

void CreateGraph(Graph *G);
void PrintGraph(Graph G);
void StronglyConnectedComponents(Graph G, Graph *SG, Graph *WG);

int main() {
    Graph G, SG, WG; // G为原图，SG为强分图，WG为弱分图
    CreateGraph(&G);
    StronglyConnectedComponents(G, &SG, &WG);
    printf("强分图的邻接矩阵：\n");
    PrintGraph(SG);
    printf("弱分图的邻接矩阵：\n");
    PrintGraph(WG);
    return 0;
}

// 创建一个有向图
void CreateGraph(Graph *G) {
    printf("请输入顶点数：");
    scanf("%d", &(G->vexnum));
    printf("请输入邻接矩阵：\n");
    for (int i = 0; i < G->vexnum; i++) {
        for (int j = 0; j < G->vexnum; j++) {
            scanf("%d", &(G->arcs[i][j]));
        }
    }
}

// 输出一个邻接矩阵
void PrintGraph(Graph G) {
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            printf("%d ", G.arcs[i][j]);
        }
        printf("\n");
    }
}

// 求强连通分量
void StronglyConnectedComponents(Graph G, Graph *SG, Graph *WG) {
    int visited[MAX_VERTEX_NUM] = {0}; // 标记是否已访问过
    int dfn[MAX_VERTEX_NUM] = {0}; // 时间戳
    int low[MAX_VERTEX_NUM] = {0}; // 最小时间戳
    int stack[MAX_VERTEX_NUM], top = -1; // 栈
    int time = 0; // 时间戳
    int SCC[MAX_VERTEX_NUM], SCC_num = 0; // 存储强连通分量
    // 求强连通分量
    for (int i = 0; i < G.vexnum; i++) {
        if (!visited[i]) {
            visited[i] = 1;
            stack[++top] = i;
            dfn[i] = low[i] = ++time;
            while (top != -1) {
                int v = stack[top];
                int j;
                for (j = 0; j < G.vexnum; j++) {
                    if (G.arcs[v][j]) { // 如果v到j有边
                        if (!visited[j]) { // 如果j未访问过
                            visited[j] = 1;
                            stack[++top] = j;
                            dfn[j] = low[j] = ++time;
                            break;
                        } else if (dfn[j] != 0 && SCC[j] == 0) { // 如果j在栈中
                            if (dfn[j] < low[v]) {
                                low[v] = dfn[j];
                            }
                        }
                    }
                }
                if (j == G.vexnum) { // 如果v没有未访问的邻点
                    int w;
                    SCC_num++;
                    do {
                        w = stack[top--];
                        SCC[w] = SCC_num;
                    } while (w != v);
                }
            }
        }
    }
    // 构造强分图
    SG->vexnum = SCC_num;
    for (int i = 0; i < SCC_num; i++) {
        for (int j = 0; j < SCC_num; j++) {
            SG->arcs[i][j] = 0;
        }
    }
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            if (G.arcs[i][j]) { // 如果i到j有边
                if (SCC[i] != SCC[j]) { // 如果i和j不在同一个强连通分量中
                    SG->arcs[SCC[i] - 1][SCC[j] - 1] = 1;
                }
            }
        }
    }
    // 构造弱分图
    WG->vexnum = G.vexnum;
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            if (G.arcs[i][j]) { // 如果i到j有边
                WG->arcs[i][j] = 1;
            }
            if (SCC[i] == SCC[j]) { // 如果i和j在同一个强连通分量中
                WG->arcs[i][j] = 1;
            }
        }
    }
}