n*n 的棋盘上每格都对应着不同的分值(如图1所示),一个人从棋盘位置(i,j)(0 ≤ i、j≤ n- 1)出发，每次只能自下或自右移动一步，并获得对应位置的得分，直至走到棋盘边缘(即第n行/列) 请设计一个算法，计算从位置(i,i)能获得的最大分值，C语言实现

这个问题可以使用动态规划（Dynamic Programming）解决。我们可以创建一个二维数组 `dp`，其中 `dp[i][j]` 表示从 `(i, j)` 起步到达棋盘边缘的最大得分。因为每次只能向下或向右移动，所以状态转移方程会基于当前位置的得分加上当前位置的分数。

初始状态，棋盘的第一行和第一列的每个格子都是从它们本身开始走的，所以：

dp[0][0] = grid[0][0];
for (int i = 1; i < n; i++) {
    dp[i][0] = dp[i - 1][0] + grid[i][0]; // 第一行只向右移动
    dp[0][i] = dp[0][i - 1] + grid[0][i]; // 第一列只向下移动
}

然后对于内部的格子 `(i, j)`，我们有：

for (int i = 1; i < n - 1; i++) {
    for (int j = 1; j < n - 1; j++) {
        dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]` 中。

下面是完整的 C 语言实现：

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

// 定义网格大小和网格值
#define N 10
int grid[N][N];

// 动态规划函数
int maxScore(int i, int j) {
if (i == 0 || j == 0 || i == N - 1 || j == N - 1) {
return grid[i][j]; // 边缘情况直接返回网格值
}

if (dp[i][j] != -1) {
return dp[i][j]; // 如果已经计算过，则返回结果
}

dp[i][j] = max(maxScore(i - 1, j), maxScore(i, j - 1)) + grid[i][j]; // 更新并返回最优值
}

int main() {
// 初始化网格值
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
grid[i][j] = i * j; // 这里只是一个例子，实际应用中替换为实际的格子得分
}
}

// 使用 -1 表示未计算过的状态，初始化 dp 数组
int dp[N][N];
memset(dp, -1, sizeof(dp));

int result = maxScore(N - 1, N - 1);
printf("从 (%d, %d) 出发的最大分值为: %d\n", N - 1, N - 1, result);

return 0;
}