智能程序设计（C语言）

表格类数据天然是"行×列": 成绩表、棋盘、矩阵……二维数组就是一张表

int m[5][9];

• int——元素类型: 每个格子都是 int

• m——数组名: 这张表的名字

• [5][9]——5 行 9 列

行、列下标都从 0 开始:

访问 i 行 j 列的元素, 写成 m[i][j]:

m[2][3] = 42;          /* 第 2 行第 3 列 = 42 */
printf("%d", m[2][3]); /* 像普通变量一样用 */

/* ---- 配合循环, 扫过一整行 ---- */
for (j = 0; j < 9; j++) {
  printf("%d ", m[2][j]);
}

• m[i] 是第 i 行, m[i][j] 是这一行里的第 j 个元素

• 行下标 0~4, 列下标 0~8——都从 0 数起

• 配合循环就能扫过一整行——稍后的嵌套循环页正式登场

下一行代码看起来和它几乎一样——却是最容易写错的写法

m[i][j]    /* 第 i 行第 j 列 */
m[i,j]     /*** WRONG: 不是二维访问! ***/

m[i,j] 里的逗号是逗号运算符: 先算 i、再算 j, 整个表达式等于 m[j]——只取了第 j 行, 根本不是二维访问

• C 编译不报错——又是"能编译但答非所问"的坑

• 键盘上多打一个逗号, 程序就悄悄错了

int m[5][9] = { {1, 1, 1, 1, 1, 0, 1, 1, 1},
                {0, 1, 0, 1, 0, 1, 0, 1, 0},
                {0, 1, 0, 1, 1, 0, 0, 1, 0},
                {1, 1, 0, 1, 0, 0, 0, 1, 0},
                {1, 1, 0, 1, 0, 0, 1, 1, 1} };

int m[5][9] = { {1, 1, 1, 1, 1, 0, 1, 1, 1},
                {0, 1, 0, 1, 0, 1, 0, 1, 0},
                {0, 1, 0, 1, 1, 0, 0, 1, 0} };

把一维初始化式嵌套起来, 就得到二维数组的初始化式

高维数组以此类推

初始化式不足以填满时, 其余元素自动补 0:

下面的初始化式只填了前三行——后两行自动为 0

转置: 行列互换, b[j][i] = a[i][j]

int a[3][4] = { {1, 2, 3, 4},
                  {5, 6, 7, 8},
                  {9, 10, 11, 12} };
int b[4][3];

for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 4; j++) {
    b[j][i] = a[i][j];   /* 行列互换 */
  }
}

• 3×4 的矩阵 a 转置后是 4×3 的矩阵 b

• 注意 b 的行列数与 a 正好相反

矩阵乘法: \(c_{ij} = \sum_k a_{ik} \times b_{kj}\) (a 的列数必须等于 b 的行数)

/* a: m×n, b: n×p, c: m×p */
for (int i = 0; i < m; i++) {
  for (int j = 0; j < p; j++) {
    c[i][j] = 0;
    for (int k = 0; k < n; k++) {
      c[i][j] += a[i][k] * b[k][j];
    }
  }
}

• 三层循环: 外层两重选行与列, 最内层求和

• 神经网络的核心运算就是矩阵乘法 (GEMM): 全连接、卷积、注意力最后都归到它——三层循环是朴素版, 真实库还会做分块、向量化优化

/* 奇数阶幻方: 右上走 + 回绕 + 冲突下移 */
#include <stdio.h>
#define N 3

int main(void)
{
  int magic[N][N] = {0};
  int i, j, num;

  i = 0; j = N / 2;              /* 1 放在第一行正中间 */
  for (num = 1; num <= N * N; num++) {
    magic[i][j] = num;
    int ni = (i - 1 + N) % N;    /* 右上候选 (回绕) */
    int nj = (j + 1) % N;
    if (magic[ni][nj] != 0) {    /* 被占: 改往正下 */
      i = (i + 1) % N;
    } else {
      i = ni; j = nj;
    }
  }

  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      printf("%3d", magic[i][j]);
    }
    printf("\n");
  }
  return 0;
}

• "右上"是两个下标的同时变化: 行 -1、列 +1——二维数组的下标游戏

• 走出棋盘用 % N 回绕

• 格子非 0 就是已被占用: 用数组内容做标记, 不用额外的 visited 数组

• 把 N 改成 5, 就是 5×5 幻方——每行和都是 65

• 此法只对奇数 N 成立: 偶数阶另有构造法 (2×2 干脆不存在幻方)

/* 生命游戏: 一代更新 */
#include <stdio.h>
#define N 5

int main(void)
{
  int old_grid[N][N] = {
    0, 0, 0, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 0, 0, 0
  };
  int new_grid[N][N];
  /* 对照表: 0->. 1-># */
  const char cell[] = {'.', '#'};
  int i, j, di, dj, count;

  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      count = 0;
      for (di = -1; di <= 1; di++) {
        for (dj = -1; dj <= 1; dj++) {
          int ni = i + di, nj = j + dj;
          if (ni >= 0 && ni < N &&
              nj >= 0 && nj < N &&
              !(di == 0 && dj == 0)) {
            if (old_grid[ni][nj]) {
              count++;
            }
          }
        }
      }
      if (old_grid[i][j]) {
        new_grid[i][j] =
            (count == 2 || count == 3);
      } else {
        new_grid[i][j] = (count == 3);
      }
    }
  }

  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      printf("%c ", cell[new_grid[i][j]]);
    }
    printf("\n");
  }
  return 0;
}

• 两张表是关键: 从 old 数邻居、写进 new——边数边改会把旧一代污染掉

• 邻居计数: 外面两重定位格子, 里面两重扫 3×3 邻域 (去掉自己)

• 边界: 棋盘外的格子当死细胞——ni >= 0 && ni < N 挡住

• 想跑多代: 把 new 拷回 old 再来一轮——这就是整张表更新

• cell 是 const对照表: 0/1 变图案——常量数组的查表

#include <stdio.h>
#define N 5
int main(void)
{
  int a[N][N] = {0};
  int i = 0, j = 0, num = 1;
  int dx[] = {0, 1, 0, -1};   /* 方向向量: 右 下 左 上 */
  int dy[] = {1, 0, -1, 0};
  int d = 0;
  int k;

  while (num <= N * N) {
    a[i][j] = num++;
    int ni = i + dx[d], nj = j + dy[d];
    if (ni < 0 || ni >= N || nj < 0 || nj >= N || a[ni][nj] != 0) {
      d = (d + 1) % 4;        /* 撞墙或已填: 转弯 */
    }
    i += dx[d]; j += dy[d];
  }

  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      printf("%3d", a[i][j]);
    }
    printf("\n");
  }
  return 0;
}

• dx/dy 是方向向量: 四个方向写进两张小表, d 指哪就往哪走

• 出界或已填 → d = (d+1) % 4 转弯——取模又见面了

• 这是走迷宫、搜索的经典技巧, 以后还会再见

#include <stdio.h>
#define N 9
int main(void)
{
  int board[N][N], i, j, k, ok = 1;
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      scanf("%d", &board[i][j]);
    }
  }

  for (i = 0; i < N && ok; i++) {          /* 每行查重 */
    int seen[10] = {0};
    for (j = 0; j < N; j++) {
      if (seen[board[i][j]]) { ok = 0; break; }
      seen[board[i][j]] = 1;
    }
  }
  for (j = 0; j < N && ok; j++) {          /* 每列查重 */
    int seen[10] = {0};
    for (i = 0; i < N; i++) {
      if (seen[board[i][j]]) { ok = 0; break; }
      seen[board[i][j]] = 1;
    }
  }
  for (i = 0; i < N && ok; i += 3)         /* 九宫格查重 */ {
    for (j = 0; j < N && ok; j += 3) {
      int seen[10] = {0};
      for (k = 0; k < 9; k++) {
        int v = board[i + k / 3][j + k % 3];
        if (seen[v]) { ok = 0; break; }
        seen[v] = 1;
      }
    }
  }
  printf(ok ? "Right\n" : "Wrong\n");
  return 0;
}

• 三种扫描 (行/列/九宫格) 是同一招标志数组查重的三次使用

• 九宫格的坐标 i + k/3、j + k%3 是二维下标推演的高光时刻

• 出错就 ok = 0 提前退出——早停的思想