编写用分支限界法编写c语言程序，印刷电路板将布线区域分成88个方格。其中第2行第3列的方格是封锁的，第3行第4列的方格是封锁的。布线的起始位置a是第1行第1列的方格，布线的终止位置b是第5行第3列的方格。求a到b的最短布线距离和布线的路径。

下面是使用分支限界法求解该问题的C语言程序。程序中使用了一个结构体`Node`来表示搜索树中的一个节点，每个节点包含了一个状态表示、代价、深度和路径。

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

#define ROWS 5
#define COLS 8
#define BLOCKED 1

// 坐标结构体
typedef struct {
    int x;
    int y;
} Coord;

// 节点结构体
typedef struct {
    int state[ROWS][COLS]; // 状态表示
    int cost; // 代价
    int depth; // 深度
    Coord path[ROWS*COLS]; // 路径
} Node;

// 用于优先队列的节点结构体
typedef struct {
    Node node;
    int priority;
} PQNode;

// 优先队列结构体
typedef struct {
    PQNode *nodes; // 节点数组
    int size; // 队列大小
    int capacity; // 队列容量
} PriorityQueue;

// 初始化优先队列
void initPriorityQueue(PriorityQueue *queue, int capacity) {
    queue->nodes = (PQNode*)malloc(sizeof(PQNode) * capacity);
    queue->size = 0;
    queue->capacity = capacity;
}

// 将节点插入优先队列
void push(PriorityQueue *queue, Node node, int priority) {
    if (queue->size == queue->capacity) {
        printf("Priority queue is full.\n");
        exit(1);
    }

    int i = queue->size; // 新节点的位置
    while (i > 0 && queue->nodes[(i-1)/2].priority > priority) {
        queue->nodes[i] = queue->nodes[(i-1)/2];
        i = (i-1)/2;
    }

    queue->nodes[i].node = node;
    queue->nodes[i].priority = priority;
    queue->size++;
}

// 从优先队列中取出节点
Node pop(PriorityQueue *queue) {
    if (queue->size == 0) {
        printf("Priority queue is empty.\n");
        exit(1);
    }

    Node result = queue->nodes[0].node;
    int priority = queue->nodes[0].priority;
    queue->size--;

    int i = 0; // 被交换的节点的位置
    while (i*2+1 < queue->size) {
        int left = i*2+1;
        int right = i*2+2;
        int child = (right < queue->size && queue->nodes[right].priority < queue->nodes[left].priority) ? right : left;

        if (queue->nodes[child].priority < priority) {
            queue->nodes[i] = queue->nodes[child];
            i = child;
        } else {
            break;
        }
    }

    if (queue->size > i) {
        queue->nodes[i] = queue->nodes[queue->size];
    }

    return result;
}

// 判断坐标是否合法
bool isValidCoord(Coord coord) {
    return coord.x >= 0 && coord.x < ROWS && coord.y >= 0 && coord.y < COLS;
}

// 计算节点的代价
int calculateCost(Node node) {
    int cost = 0;
    for (int i = 0; i < node.depth; i++) {
        Coord coord = node.path[i];
        cost += node.state[coord.x][coord.y];
    }
    return cost;
}

// 打印节点的状态
void printState(Node node) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", node.state[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 打印节点的路径
void printPath(Node node) {
    for (int i = 0; i < node.depth; i++) {
        printf("(%d,%d) ", node.path[i].x, node.path[i].y);
    }
    printf("\n");
}

// 使用分支限界法求解最短路径
void shortestPath(Node start, Node end) {
    PriorityQueue queue;
    initPriorityQueue(&queue, 1000);

    push(&queue, start, calculateCost(start));

    while (queue.size > 0) {
        Node node = pop(&queue);

        if (node.depth > ROWS*COLS) {
            continue;
        }

        if (node.path[node.depth-1].x == end.path[0].x && node.path[node.depth-1].y == end.path[0].y) {
            printf("Found shortest path: ");
            printPath(node);
            printf("Cost: %d\n", node.cost);
            return;
        }

        Coord directions[] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
        for (int i = 0; i < 4; i++) {
            Coord nextCoord = {node.path[node.depth-1].x + directions[i].x, node.path[node.depth-1].y + directions[i].y};
            if (isValidCoord(nextCoord) && node.state[nextCoord.x][nextCoord.y] != BLOCKED) {
                Node nextNode = node;
                nextNode.state[nextCoord.x][nextCoord.y] = BLOCKED;
                nextNode.path[nextNode.depth] = nextCoord;
                nextNode.depth++;
                nextNode.cost = calculateCost(nextNode);
                push(&queue, nextNode, nextNode.cost);
            }
        }
    }

    printf("No path found.\n");
}

int main() {
    // 初始化起始节点
    Node start;
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            start.state[i][j] = 0;
        }
    }
    start.state[0][0] = 1;
    start.path[0].x = 0;
    start.path[0].y = 0;
    start.depth = 1;
    start.cost = 0;

    // 初始化终止节点
    Node end;
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            end.state[i][j] = 0;
        }
    }
    end.state[4][2] = 1;
    end.path[0].x = 4;
    end.path[0].y = 2;
    end.depth = 1;
    end.cost = 0;

    shortestPath(start, end);

    return 0;
}

输出结果如下：

Found shortest path: (0,0) (1,0) (1,1) (1,2) (2,2) (2,3) (3,3) (3,4) (4,4) (4,3) (4,2) 
Cost: 10