离散数学中设备更新问题，用C语言的迪克斯塔拉算法编写程序来解决，要求输出为第i年和第j年为购买设备的时间，

以下是使用Dijkstra算法解决设备更新问题的C语言程序：

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

#define MAX_VERTICES 100
#define MAX_EDGES 1000
#define INF 1000000

typedef struct {
    int from;   // 边的起点
    int to;     // 边的终点
    int weight; // 边的权重
} Edge;

typedef struct {
    Edge edges[MAX_EDGES];  // 边的数组
    int num_edges;          // 边的数量
} Graph;

int V;              // 图的顶点数
Graph G;            // 图的邻接表表示
int dist[MAX_VERTICES]; // 距离数组，即从源点到各顶点的最短距离
int prev[MAX_VERTICES]; // 前驱数组，即到达各顶点的最短路径中的前驱顶点

void add_edge(int u, int v, int w) {
    G.edges[G.num_edges].from = u;
    G.edges[G.num_edges].to = v;
    G.edges[G.num_edges].weight = w;
    G.num_edges++;
}

void dijkstra(int s) {
    int i, j, u, min_dist;
    int visited[MAX_VERTICES];

    for (i = 0; i < V; i++) {
        dist[i] = INF;
        visited[i] = 0;
        prev[i] = -1;
    }

    dist[s] = 0;

    for (i = 0; i < V; i++) {
        // 找到未访问顶点中距离最小的顶点
        min_dist = INF;
        for (j = 0; j < V; j++) {
            if (!visited[j] && dist[j] < min_dist) {
                min_dist = dist[j];
                u = j;
            }
        }

        // 标记该顶点为已访问
        visited[u] = 1;

        // 更新与该顶点相邻的顶点的距离
        for (j = 0; j < G.num_edges; j++) {
            if (G.edges[j].from == u) {
                int v = G.edges[j].to;
                int w = G.edges[j].weight;
                if (dist[u] + w < dist[v]) {
                    dist[v] = dist[u] + w;
                    prev[v] = u;
                }
            }
        }
    }
}

int main() {
    int n, m, i, j, k, u, v, w;
    scanf("%d%d", &n, &m);  // 输入顶点数和边数

    V = n * m;  // 顶点数为 n * m

    // 初始化图
    G.num_edges = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < m - 1; j++) {
            scanf("%d", &w);
            u = i * m + j;
            v = i * m + j + 1;
            add_edge(u, v, w);
            add_edge(v, u, w);
        }
    }
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < m; j++) {
            scanf("%d", &w);
            u = i * m + j;
            v = (i + 1) * m + j;
            add_edge(u, v, w);
            add_edge(v, u, w);
        }
    }

    // 计算最短路径
    dijkstra(0);

    // 输出结果
    int i1 = 0, j1 = 0, i2 = 0, j2 = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            int v = i * m + j;
            if (dist[v] > dist[i1 * m + j1]) {
                i1 = i;
                j1 = j;
            }
            if (dist[v] > dist[i2 * m + j2] - 1) {
                i2 = i;
                j2 = j;
            }
        }
    }
    printf("%d %d %d %d\n", i1 + 1, j1 + 1, i2 + 1, j2 + 1);

    return 0;
}

其中，输入格式为：

n m
w11 w12 ... w1(m-1)
...
w(n-1)1 w(n-1)2 ... w(n-1)(m-1)
w11 w21 ... w(n-1)1
...
w1m w2m ... w(n-1)m

其中，第一行输入顶点数n和边数m，接下来n-1行每行输入m-1个数表示横向边的权重，最后一行输入m个数表示纵向边的权重。

程序将输出第一个购买设备的年份和第二个购买设备的年份，即第i年和第j年。注意，输出的行列号从1开始。