C语言实现访问控制矩阵代码

以下是一个C语言实现访问控制矩阵的代码示例：

#include <stdio.h>

int main()
{
    int matrix[3][3] = { {1, 0, 1}, {0, 1, 0}, {1, 1, 0} }; // 访问控制矩阵，1表示有权限，0表示无权限
    int user, resource;

    printf("请输入用户编号：");
    scanf("%d", &user);
    printf("请输入资源编号：");
    scanf("%d", &resource);

    if (matrix[user][resource] == 1) // 判断用户是否有权限访问资源
    {
        printf("用户%d可以访问资源%d\n", user, resource);
    }
    else
    {
        printf("用户%d无法访问资源%d\n", user, resource);
    }

    return 0;
}

以上代码使用一个二维数组表示访问控制矩阵，用户输入用户编号和资源编号，程序会根据访问控制矩阵判断用户是否有权限访问资源。

相关问题

使用c语言实现基于邻接矩阵实现图的广度优先遍历

广度优先遍历（BFS）是一种图的遍历算法，可以用来找到从某个节点出发，到其他所有节点的最短路径。下面是使用 C 语言实现基于邻接矩阵的图的广度优先遍历的示例代码：

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

#define MAX_VERTICES 100

int adj_matrix[MAX_VERTICES][MAX_VERTICES];
bool visited[MAX_VERTICES];
int queue[MAX_VERTICES];
int front = 0, rear = -1;

void bfs(int v, int n) {
    visited[v] = true;
    queue[++rear] = v;

    while (front <= rear) {
        int cur = queue[front++];
        printf("%d ", cur);

        for (int i = 0; i < n; i++) {
            if (adj_matrix[cur][i] == 1 && !visited[i]) {
                visited[i] = true;
                queue[++rear] = i;
            }
        }
    }
}

int main() {
    int n, e; // n 表示顶点个数，e 表示边的个数
    scanf("%d %d", &n, &e);

    for (int i = 0; i < e; i++) {
        int u, v; // u 和 v 表示一条边的两个端点
        scanf("%d %d", &u, &v);
        adj_matrix[u][v] = 1;
        adj_matrix[v][u] = 1; // 无向图需要把边反向再存一次
    }

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

    bfs(0, n);

    return 0;
}

在这个示例代码中，我们首先定义了一个邻接矩阵 `adj_matrix`，用于存储图的边，同时还定义了一个 `visited` 数组，用于标记每个节点是否已经被访问过。我们还定义了一个队列 `queue`，用于存储待访问的节点。在 `bfs` 函数中，我们首先将起始节点加入队列中，并标记为已访问，然后循环访问队列中的节点，对于每个节点，我们遍历与其相邻的节点，并将其加入队列中。最后，我们输出访问过的节点，就得到了广度优先遍历的结果。

在 `main` 函数中，我们读入图的顶点个数和边的个数，然后读入每条边的两个端点，并将其存入邻接矩阵中。我们还需要将 `visited` 数组初始化为 false。最后，我们调用 `bfs` 函数进行广度优先遍历，并输出结果。

c语言实现邻接矩阵非递归深度优先遍历

邻接矩阵是表示图的一种方式，非递归深度优先遍历是指不使用递归算法来实现深度优先遍历。下面是C语言实现邻接矩阵非递归深度优先遍历的步骤：

1. 定义一个栈结构，用于存储待遍历的节点。
2. 定义一个visited数组，用于记录每个节点是否已经被遍历。
3. 从某个起始节点开始，将其压入栈中，并将visited数组中对应位置标记为已访问。
4. 循环执行以下步骤直到栈为空：
a. 取出栈顶元素，并输出该节点。
b. 遍历该节点的所有邻居节点，若该邻居节点未被访问，则将其压入栈中并标记为已访问。

下面是邻接矩阵非递归深度优先遍历的C语言实现代码：

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

#define MAX_VERTEX_NUM 100

typedef int VertexType;
typedef int EdgeType;

typedef struct {
    VertexType vertex[MAX_VERTEX_NUM];
    EdgeType edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int vertex_num, edge_num;
} MGraph;

typedef struct {
    VertexType data[MAX_VERTEX_NUM];
    int top;
} Stack;

void InitStack(Stack *S) {
    S->top = -1;
}

void Push(Stack *S, VertexType x) {
    S->data[++S->top] = x;
}

VertexType Pop(Stack *S) {
    return S->data[S->top--];
}

int IsEmpty(Stack *S) {
    return S->top == -1;
}

void CreateGraph(MGraph *G) {
    int i, j;
    printf("请输入图的顶点数和边数：\n");
    scanf("%d %d", &G->vertex_num, &G->edge_num);
    printf("请输入各个顶点：\n");
    for (i = 0; i < G->vertex_num; i++) {
        scanf("%d", &G->vertex[i]);
    }
    for (i = 0; i < G->vertex_num; i++) {
        for (j = 0; j < G->vertex_num; j++) {
            G->edge[i][j] = 0;
        }
    }
    printf("请输入各条边的起点和终点：\n");
    for (i = 0; i < G->edge_num; i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        G->edge[u][v] = G->edge[v][u] = 1;
    }
}

void DFS(MGraph *G, int v, int visited[]) {
    Stack S;
    InitStack(&S);
    Push(&S, v);
    visited[v] = 1;
    while (!IsEmpty(&S)) {
        int i, w = Pop(&S);
        printf("%d ", G->vertex[w]);
        for (i = 0; i < G->vertex_num; i++) {
            if (G->edge[w][i] && !visited[i]) {
                Push(&S, i);
                visited[i] = 1;
            }
        }
    }
}

void DFSTraverse(MGraph *G) {
    int visited[MAX_VERTEX_NUM] = {0};
    int i;
    for (i = 0; i < G->vertex_num; i++) {
        if (!visited[i]) {
            DFS(G, i, visited);
        }
    }
}

int main() {
    MGraph G;
    CreateGraph(&G);
    DFSTraverse(&G);
    return 0;
}