POJ 1915 Knight Moves

本文介绍了一个简单的BFS(宽度优先搜索)算法实现,用于解决在一个较大但递归层次不深的问题中寻找路径的问题。文章通过一个具体的示例代码展示了如何在不进行剪枝的情况下完成搜索过程,并详细解释了每一步的实现细节。

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

就是简单的BFS,刚开始还在想要不要剪枝,后来试了一下不用剪枝就能过,可能因为不是马周游吧,虽然棋盘可以很大,但递归层数不是那么深。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MAXN = 305;
int vis[MAXN][MAXN], dist[MAXN][MAXN];

int dir[8][2] = {1, 2, 1, -2, -1, 2, -1, -2, 2, 1, 2, -1, -2, 1, -2, -1};
int kase = 0, X, Y;
int sx, sy, ex, ey;

struct Node
{
    int x, y;
    Node(int r, int c)
    {
        x = r, y = c;
    }
};

queue<Node> Q;

int BFS()
{
    while (!Q.empty())
        Q.pop();
    if (sx == ex && sy == ey)
        return 0;
    dist[sx][sy] = 0;
    vis[sx][sy] = kase;
    Q.push(Node(sx, sy));
    while (!Q.empty())
    {
        Node node = Q.front();
        Q.pop();
        int r = node.x, c = node.y;
        for (int i = 0; i < 8; i++)
        {
            int nx = r + dir[i][0];
            int ny = c + dir[i][1];
            if (nx >= 0 && nx < X && ny >= 0 && ny < Y && vis[nx][ny] != kase)
            {
                if (nx == ex && ny == ey)
                    return dist[r][c] + 1;
                dist[nx][ny] = dist[r][c] + 1;
                vis[nx][ny] = kase;
                Q.push(Node(nx, ny));
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        kase++;
        scanf("%d", &X);
        Y = X;
        scanf("%d%d", &sx, &sy);
        scanf("%d%d", &ex, &ey);
        printf("%d\n", BFS());
    }
}


### 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、付费专栏及课程。

余额充值