POJ 1915 Knigth Moves

本文介绍了一种使用BFS算法解决棋盘上从一个点到另一个点的最短路径问题的方法,具体实现了一个名为KnightMoves的程序,通过定义结构体、初始化地图和进行广度优先搜索来求解问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Knight Moves

在棋盘上从某个点出发以最短的距离到达另一个点。直接用BFS。代码如下:

#include<stdio.h>
#include<string.h>
#include<queue>

using namespace std ;

struct Node{
	int x ;
	int y ;
	int s ;
};

int n ;
int l ;

int map[305][305] ;
int dir[][2] ={{-1,2} ,{1,2} ,{2,1} , {2,-1} , 
{1,-2} ,{-1,-2} ,{-2 ,-1},{-2 , 1}} ;

void bfs(int sx , int sy , int ex , int ey){
	
	queue<Node> Q ;
	Node a ;
	Node b ;
	a.x = sx ;
	a.y = sy ;
	a.s = 0  ;
	map[sx][sy] = 1 ;
	Q.push(a) ;
	
	while(!Q.empty()){
		b = Q.front() ;
		
		if(b.x == ex && b.y == ey){
			printf("%d\n" , b.s) ;
		}
		
		Q.pop() ;
		
		for(int i = 0 ; i < 8 ; i ++){
			if(b.x + dir[i][0] >= 0 && b.x + dir[i][0] < l && b.y + dir[i][1] >= 0 && b.y + dir[i][1] < l){
				Node c ;
				
				c.x = b.x + dir[i][0] ;
				c.y = b.y + dir[i][1] ;
				c.s = b.s + 1 ;
				if(!map[c.x][c.y]){
					Q.push(c) ;	
					map[c.x][c.y] = 1 ;
				}
			}
		}
	}
}

void work(){
	scanf("%d" , &l) ;
	
	int sx ;
	int sy ;
	int ex ;
	int ey ;
	
	scanf("%d %d" , &sx , &sy) ;
	scanf("%d %d" , &ex , &ey) ;
	memset(map , 0 , sizeof(map)) ;
	
	bfs(sx , sy , ex , ey) ;
}
int main(){
	
	scanf("%d" , &n) ;
	while(n--){
		work() ;
	}
	
	return 0 ;
}


### POJ1915 解题思路 POJ1915 是关于图论中的强连通分量问题,主要涉及 Tarjan 算法的应用以及如何通过缩点使有向无环图(DAG)变为强连通图。以下是该问题的核心算法思路: #### 问题描述 题目要求计算在一个有向图中,最少需要添加多少条边才能使得整个图成为强连通图。 --- #### 核心算法分析 1. **Tarjan 缩点** 使用 Tarjan 算法找到所有的强连通分量并将其缩成单个节点,从而得到一个新的有向无环图(DAG)。此过程可以有效简化原始图结构[^2]。 2. **统计入度和出度为零的节点数** 对于新的 DAG 图,分别统计入度为零的节点数量 \(in\_zero\) 和出度为零的节点数量 \(out\_zero\)。这两个值决定了需要增加的边的数量。 3. **计算所需新增边数** 新增边的数量取决于以下两种情况的最大值: \[ answer = \max(in\_zero, out\_zero) \] 这是因为每一条新加入的边都可以消除一个入度或出度为零的情况。 4. **特殊情况处理** 如果初始图已经是强连通图,则无需任何操作,即答案为 0。 --- #### 实现细节 下面提供了一个基于 C++ 的实现框架,展示了如何利用 Tarjan 算法解决这个问题: ```cpp #include <iostream> #include <vector> #include <stack> using namespace std; const int MAXN = 1e4 + 5; int n, m, idx, scc_cnt; int dfn[MAXN], low[MAXN]; bool in_stack[MAXN]; vector<int> adj[MAXN]; stack<int> stk; vector<vector<int>> SCC; // 存储每个强连通分量 void tarjan(int u) { dfn[u] = low[u] = ++idx; stk.push(u); in_stack[u] = true; for (auto &v : adj[u]) { if (!dfn[v]) { tarjan(v); low[u] = min(low[u], low[v]); } else if (in_stack[v]) { low[u] = min(low[u], dfn[v]); } } if (low[u] == dfn[u]) { vector<int> component; while (true) { int t = stk.top(); stk.pop(); in_stack[t] = false; component.push_back(t); if (t == u) break; } SCC.push_back(component); scc_cnt++; } } // 主函数逻辑 int main() { cin >> n >> m; for (int i = 0; i < m; ++i) { int a, b; cin >> a >> b; adj[a].push_back(b); } // 初始化 Tarjan 参数 memset(dfn, 0, sizeof(dfn)); memset(in_stack, false, sizeof(in_stack)); idx = scc_cnt = 0; // 执行 Tarjan 算法 for (int i = 1; i <= n; ++i) { if (!dfn[i]) tarjan(i); } // 构建 DAG 并统计出入度 int indegree_zero = 0, outdegree_zero = 0; vector<int> dag_in(scc_cnt + 1, 0), dag_out(scc_cnt + 1, 0); for (int u = 1; u <= n; ++u) { for (auto &v : adj[u]) { if (SCC[dfn[u]].back() != SCC[dfn[v]].back()) { // 不同强连通分量之间才有边 dag_in[SCC[dfn[v]].back()]++; dag_out[SCC[dfn[u]].back()]++; } } } for (int i = 1; i <= scc_cnt; ++i) { if (dag_in[i] == 0) indegree_zero++; if (dag_out[i] == 0) outdegree_zero++; } cout << max(indegree_zero, outdegree_zero); // 输出结果 } ``` --- #### 关键点解释 - **Tarjan 算法的作用** Tarjan 算法能够高效地找出所有强连通分量,并将它们压缩成单一节点,便于后续的操作[^2]。 - **为什么取最大值?** 添加一条边最多能减少一个入度为零或者出度为零的节点。因此,最终的结果应为两者之间的较大者。 - **时间复杂度** 整体的时间复杂度为 \(O(n+m)\),其中 \(n\) 表示节点数,\(m\) 表示边数。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值