poj 1330 Nearest Common Ancestors LCA/DFS

13 篇文章 0 订阅
1 篇文章 0 订阅

题目链接:

http://poj.org/problem?id=1330

题意:

求出两点间的最近公共祖先。

题解:

第一种:
并查集维护:http://www.cnblogs.com/procedure2012/archive/2012/01/29/2331468.html
利用并查集在每次对子树进行遍历时进行合并,因为对以x为根的子树的遍历时只有当x的所有子树都遍历过后才会把它合并到他父亲的集合里,所以当需要查找的两个节点q1、q2中q1已被遍历且q2正是当前遍历的节点时说明此时只有距他们最近的祖先是在集合里的(可能为q1或q2),所以只要找到已被遍历的q1所在集合的祖先就是这两的节点的LCA。
这里写图片描述

第二种
直接dfs:每次从u和v的depth较深的开始往上面找,然后如果一样就跳出,不一样继续找

代码:

并查集

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
#define MS(a) memset(a,0,sizeof(a))
#define MP make_pair
#define PB push_back
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline ll read(){
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//////////////////////////////////////////////////////////////////////////
const int maxn = 1e4+10;

vector<int> g[maxn];
int f[maxn],vis[maxn],fa[maxn];
int q1,q2;
int a[maxn];

int find(int x){
    return fa[x]==x ? x : fa[x]=find(fa[x]);
}

void Union(int x,int y){
    int p1=find(x),p2=find(y);
    if(p1 == p2) return ;
    fa[p1] = p2;
}

void dfs(int u){
    for(int i=0; i<(int)g[u].size(); i++){
        int v = g[u][i];
        dfs(v);
        Union(u,v); // 合并的时候是u合并到v上,u的父亲是v,利于下面寻找祖先,也就是所有u的父亲的祖先都是u
        a[find(u)] = u; // u的所有孩子的祖先都是u
    }
    vis[u] = 1;
    if(q1==u && vis[q2]) printf("%d\n",a[find(q2)]);
    if(q2==u && vis[q1]) printf("%d\n",a[find(q1)]);
    return ;
}

int main(){
    int T = read();
    while(T--){
        int n = read();
        for(int i=0; i<=n; i++) {
            g[i].clear();
            f[i] = 0;
            fa[i] = i;
            vis[i] = 0;
            a[i] = 0;
        }
        int u,v;
        for(int i=1; i<n; i++){
            scanf("%d%d",&u,&v);
            f[v] = 1;
            g[u].push_back(v);
        }
        cin >> q1 >> q2;
        int i;
        for(i=1; i<=n; i++)
            if(f[i]==0) break;
        dfs(i);
    }

    return 0;
}

直接找:

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
#define MS(a) memset(a,0,sizeof(a))
#define MP make_pair
#define PB push_back
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline ll read(){
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//////////////////////////////////////////////////////////////////////////
const int maxn = 1e4+10;

vector<int> g[maxn];
int d[maxn],p[maxn],f[maxn];

void dfs(int u,int fa,int de){
    p[u] = fa;
    d[u] = de;
    for(int i=0; i<(int)g[u].size(); i++){
        int v = g[u][i];
        if(v == fa) continue;
        dfs(v,u,de+1);
    }
}

int lca(int u,int v){
    while(d[u] > d[v]) u = p[u];
    while(d[v] > d[u]) v = p[v];
    while(u != v){
        u = p[u];
        v = p[v];
    }

    return u;
}

int main(){
    int T = read();
    while(T--){
        int n = read();
        for(int i=0; i<=n; i++) {
            g[i].clear();
            f[i] = 0; d[i] = 0; p[i] = 0;
        }
        int u,v;
        for(int i=1; i<n; i++){
            scanf("%d%d",&u,&v);
            f[v] = 1;
            g[u].push_back(v);
        }
        int i;
        for(i=1; i<=n; i++)
            if(f[i]==0) break;
        dfs(i,-1,0);
        cin >> u >> v;
        cout << lca(u,v) << endl;
    }

    return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
POJ 1321 排兵布阵问题可以使用 DFS 算法求解。 题目要求在一个 n x n 的棋盘上,放置 k 个棋子,其中每行、每列都最多只能有一个棋子。我们可以使用 DFS 枚举每个棋子的位置,对于每个棋子,尝试将其放置在每一行中未被占用的位置上,直到放置了 k 个棋子。在 DFS 的过程中,需要记录每行和每列是否已经有棋子,以便在尝试放置下一个棋子时进行判断。 以下是基本的 DFS 模板代码: ```python def dfs(row, cnt): global ans if cnt == k: ans += 1 return for i in range(row, n): for j in range(n): if row_used[i] or col_used[j] or board[i][j] == '.': continue row_used[i] = col_used[j] = True dfs(i + 1, cnt + 1) row_used[i] = col_used[j] = False n, k = map(int, input().split()) board = [input() for _ in range(n)] row_used = [False] * n col_used = [False] * n ans = 0 dfs(0, 0) print(ans) ``` 其中,row 代表当前尝试放置棋子的行数,cnt 代表已经放置的棋子数量。row_used 和 col_used 分别表示每行和每列是否已经有棋子,board 则表示棋盘的状态。在尝试放置棋子时,需要排除掉无法放置的位置,即已经有棋子的行和列,以及棋盘上标记为 '.' 的位置。当放置了 k 个棋子时,即可计数一次方案数。注意,在回溯时需要将之前标记为已使用的行和列重新标记为未使用。 需要注意的是,在 Python 中,递归深度的默认限制为 1000,可能无法通过本题。可以通过以下代码来解除限制: ```python import sys sys.setrecursionlimit(100000) ``` 完整代码如下:
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值