矩阵中的路径(C++牛客网)

209 篇文章 2 订阅
67 篇文章 2 订阅

解题思路:

(1)因为矩阵每个位置都有可能是起点,因此最外围需要遍历矩阵中的每个元素,找到路径则返回

(2)首先匹配当前位置,判断两个字符是否相同,相同则继续判断它四周的元素

(3)只要四周的元素有一个匹配即可继续寻找下一个元素

(4)如果当前位置匹配而四周的元素都不能和下一元素匹配,那么这个当前位置的选择是错误的,将其设置为未访问

(5)同时长度减一,即为回溯法

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str) {
	if(matrix == NULL || rows < 1 || cols < 1 || str == NULL)
	    return false;

	    bool *visited = new bool[rows * cols];
	    memset(visited, 0, rows * cols);//一段内存为0

	    int pathLength = 0;
	    for(int row = 0; row < rows; ++row) {
	        for(int col = 0; col < cols; ++col) {
		    if(hasPathCore(matrix, rows, cols, row, col, str,
			pathLength, visited)) {
			return true;
		    }
		}
	    }
	    delete[] visited;
	    return false;
	}

	bool hasPathCore(const char* matrix, int rows, int cols, int row,
		int col, const char* str, int& pathLength, bool* visited) {
	    if(str[pathLength] == '\0')
		return true;

	    bool hasPath = false;
	    if(row >= 0 && row < rows && col >= 0 && col < cols
		    && matrix[row * cols + col] == str[pathLength]
		    && !visited[row * cols + col]) {
	        ++pathLength;
	        visited[row * cols + col] = true;
        
                hasPath = hasPathCore(matrix, rows, cols, row, col - 1,
				str, pathLength, visited)
			|| hasPathCore(matrix, rows, cols, row - 1, col,
					str, pathLength, visited)
			|| hasPathCore(matrix, rows, cols, row, col + 1,
					str, pathLength, visited)
			|| hasPathCore(matrix, rows, cols, row + 1, col,
					str, pathLength, visited);

		if(!hasPath){
	            --pathLength;
		    visited[row * cols + col] = false;
		}
	}

	return hasPath;
    }

};

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
邻接矩阵求最短路径算法通常使用 Dijkstra 算法或 Floyd 算法。 1. Dijkstra 算法 Dijkstra 算法是一种单源最短路径算法,其基本思想是从源节点开始,不断扩展最短路径,直到到达目标节点为止。具体步骤如下: (1)初始化:将源节点 s 到所有节点的距离初始化为无穷大,将源节点 s 到自身的距离初始化为 0。 (2)遍历:从源节点 s 开始,按照距离从小到大的顺序遍历所有节点,并更新它们到源节点 s 的距离。 (3)更新:对于当前节点 u 的所有邻居节点 v,如果 u 到源节点 s 的距离加上 u 到 v 的距离小于当前已知的 v 到源节点 s 的距离,则更新 v 的距离。 (4)重复:重复步骤(2)和(3)直到遍历完所有节点或者找到目标节点。 C++ 代码实现: ```c++ const int INF = 0x3f3f3f3f; // 无穷大 int n; // 节点数 int G[MAX][MAX]; // 邻接矩阵 int d[MAX]; // s 到各点的距离 bool vis[MAX]; // 标记是否已确定最短距离 void Dijkstra(int s) { memset(vis, 0, sizeof(vis)); fill(d, d + n, INF); d[s] = 0; for (int i = 0; i < n; i++) { int u = -1; for (int j = 0; j < n; j++) { if (!vis[j] && (u == -1 || d[j] < d[u])) { u = j; } } vis[u] = true; for (int v = 0; v < n; v++) { if (!vis[v] && G[u][v] != INF && d[u] + G[u][v] < d[v]) { d[v] = d[u] + G[u][v]; } } } } ``` 2. Floyd 算法 Floyd 算法是一种多源最短路径算法,其基本思想是通过间节点的遍历,不断缩小节点间的距离,直到得到最终的最短路径。具体步骤如下: (1)初始化:将邻接矩阵 G 初始化为节点间的距离。 (2)遍历:从节点 i 到节点 j 的最短路径可能经过节点 k,因此遍历所有可能的 k 值,更新 i 到 j 的最短路径C++ 代码实现: ```c++ const int INF = 0x3f3f3f3f; // 无穷大 int n; // 节点数 int G[MAX][MAX]; // 邻接矩阵 void Floyd() { for (int k = 0; k < n; k++) { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { G[i][j] = min(G[i][j], G[i][k] + G[k][j]); } } } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值