SWERC 2016 K dfs判环(map容器的妙用)

博客围绕三维空间中线段能否构成至少含3个点的环及投影到二维平面能否成环展开。题解先将点用结构体存储并用map映射,需重载map以映射结构体元素,再用vector存图,最后用dfs判环,通过记录深度差值判断是否存在3元及以上环。

题意: 给出n条三维空间中的线段,每条线段用两个三维坐标表示给出n条三维空间中的线段,每条线段用两个三维坐标表示n线线
问这些线段能否构成至少包含3个点的环,并且投影到二维平面上能否构成至少包含3个点的环问这些线段能否构成至少包含3个点的环,并且投影到二维平面上能否构成至少包含3个点的环线33

题解:
将每个点用结构体存储,然后用编号进行映射,这里使用了map。map如果要映射结构体元素,将每个点用结构体存储,然后用编号进行映射,这里使用了map。map如果要映射结构体元素,使mapmap
需要进行重载(学到了,debug半天哈哈哈)需要进行重载(学到了,debug半天哈哈哈)debug
用vector存图,然后就是简单的dfs判环,这里需要注意这个环至少要包括3个不同的点用vector存图,然后就是简单的dfs判环,这里需要注意这个环至少要包括3个不同的点vectordfs3
所以dfs的时候一边记录第一次遍历到某个点时的深度,一边传递第二次遍历到该点时的当前深度,所以dfs的时候一边记录第一次遍历到某个点时的深度,一边传递第二次遍历到该点时的当前深度,dfs
然后判断这两个深度之差然后判断这两个深度之差如果差值大于等于2,就说明存在3元及以上环如果差值大于等于2,就说明存在3元及以上环23

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<cmath>
#include<map>
#include<set>
#include<vector> 
using namespace std;
#define inf 0x3f3f3f3f
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define mem(a,b) memset(a,b,sizeof(a));
#define lowbit(x)  x&-x;  
#define debugint(name,x) printf("%s: %d\n",name,x);
#define debugstring(name,x) printf("%s: %s\n",name,x);
typedef long long ll;
typedef unsigned long long ull;
const double eps = 1e-6;
const int maxn = 1e5+5;
const int mod = 1e9+7;
inline int read()
{
    int 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;
}

struct node{
    int x,y,z;
    bool operator<(const node C)const{
        if(x == C.x){
            if(y == C.y) return z < C.z;
            else return y < C.y;
        }
        return x < C.x;
    }
}a,b;
map<node,int>mp,m3,m2;
vector<int>v3[maxn],v2[maxn];
int n,id3,id2;
int check(node x){
    if(!mp[x]){
        mp[x] = 1;
        return 1;
    }
    return 0;
}
int vis[maxn];
int ok3 = 0,ok2 = 0;
void dfs3(int u,int st,int fa){
    int sz = v3[u].size();
    if(vis[u] || ok3) return;
    vis[u] = st;

    for(int i = 0; i < sz; i++){
        int v = v3[u][i];
        if(v == fa) continue; 
        if(!vis[v]) dfs3(v,st+1,u);
        else{
            if(vis[v]-st>=2){
                ok3 = 1;
                return;
            }
        }
    }
}
void dfs2(int u,int st,int fa){
    int sz = v2[u].size();
    if(vis[u] || ok2) return;
    vis[u] = st;

    for(int i = 0; i < sz; i++){
        int v = v2[u][i];
        if(v == fa) continue;
        if(!vis[v]) dfs2(v,st+1,u);
        else{
            if(vis[v]-st>=2){
                ok2 = 1;
                return;
            }
        }
    }
}
int main() {
    scanf("%d",&n);
    for(int i = 1; i <= n; i++){
        scanf("%d%d%d%d%d%d",&a.x,&a.y,&a.z,&b.x,&b.y,&b.z);
        if(check(a)) m3[a] = ++id3;
        if(check(b)) m3[b] = ++id3;
        //printf("a:%d b:%d\n",m3[a],m3[b]);
        if(m3[a] != m3[b]){
            v3[m3[a]].push_back(m3[b]);
            v3[m3[b]].push_back(m3[a]);
        }

        a.z = b.z = 0;
        if(check(a)) m2[a] = ++id2;
        if(check(b)) m2[b] = ++id2;
        //printf("a:%d b:%d\n",m2[a],m2[b]);
        if(m2[a] == m2[b]) continue;
        v2[m2[a]].push_back(m2[b]);
        v2[m2[b]].push_back(m2[a]);
    }
    for(int i = 1; i <= id3; i++){
        if(vis[i]) continue;
        dfs3(i,0,-1);
        if(ok3) break;
    }
    mem(vis,0);
    for(int i = 1; i <= id2; i++){
        if(vis[i]) continue;
        dfs2(i,0,-1);
        if(ok2) break;
    }
    if(!ok3) puts("No true closed chains");
    else puts("True closed chains");
    if(!ok2) puts("No floor closed chains");
    else puts("Floor closed chains");
}

使用 **DFS(深度优先搜索)** 可以判断图中是否存在(包括正权和负权),但 **DFS 不能直接用于检测负权回路(Negative Weight Cycle)是否影响最短路径的求解**,因为 DFS 无法判断的总权重是否为负。 不过,我们可以用 DFS判断 **是否存在任意(不关心权重)**。如果目标只是判断是否存在DFS 是一个有效的方法。 --- ## ✅ 一、使用 DFS 判断图中是否存在(适用于无向图和有向图) ### 1. **无向图中** 在无向图中,DFS 的核心思想是: - 每个节点在访问其邻接点时,要记录它的父节点; - 如果访问到一个已经被访问过的节点,并且它不是父节点,则说明存在。 ### ✅ 示例代码(C++98): ```cpp #include <bits/stdc++.h> using namespace std; const int maxn = 1005; vector<int> G[maxn]; bool vis[maxn]; int parent[maxn]; bool isCyclicUndirected(int u) { vis[u] = true; for (int i = 0; i < (int)G[u].size(); ++i) { int v = G[u][i]; if (!vis[v]) { parent[v] = u; if (isCyclicUndirected(v)) return true; } else if (v != parent[u]) { return true; // 发现 } } return false; } bool hasCycleUndirected(int n) { memset(vis, 0, sizeof(vis)); for (int i = 1; i <= n; ++i) { if (!vis[i]) { if (isCyclicUndirected(i)) return true; } } return false; } ``` --- ### 2. **有向图中** 在有向图中,DFS 需要记录当前 DFS 栈中的节点路径: - 如果访问到一个已经在当前 DFS 栈中的节点,说明存在; - 通常使用 `visiting` 状态来标记当前路径中的节点。 ### ✅ 示例代码(C++98): ```cpp #include <bits/stdc++.h> using namespace std; const int maxn = 1005; vector<int> G[maxn]; bool visited[maxn]; bool onStack[maxn]; bool isCyclicDirected(int u) { visited[u] = true; onStack[u] = true; for (int i = 0; i < (int)G[u].size(); ++i) { int v = G[u][i]; if (!visited[v]) { if (isCyclicDirected(v)) return true; } else if (onStack[v]) { return true; // 发现 } } onStack[u] = false; return false; } bool hasCycleDirected(int n) { memset(visited, 0, sizeof(visited)); memset(onStack, 0, sizeof(onStack)); for (int i = 1; i <= n; ++i) { if (!visited[i]) { if (isCyclicDirected(i)) return true; } } return false; } ``` --- ## ✅ 二、DFS 的局限性 | 问题 | 是否支持 | |------|----------| | 判断是否存在 | ✅ 支持 | | 判断是否为负权 | ❌ 不支持 | | 能否用于最短路径判断 | ❌ 不适合用于判断对最短路径的影响 | | 是否适用于稀疏图 | ✅ 是 | | 是否适用于稠密图 | ✅ 是 | --- ## ✅ 三、如何判断是否是负权DFS 本身无法判断的权重是否为负。 要判断是否存在**负权**,通常使用: - **Bellman-Ford 算法**:适用于判断从任意节点出发的负; - **SPFA 算法**:可以优化 Bellman-Ford,适合稀疏图; - **多次 SPFA**:用于检测整个图的负(每个连通块都跑一次); --- ## ✅ 四、总结 | 方法 | 是否 | 是否 | 是否适用于有向图 | 是否适用于无向图 | |------|------------|--------------|------------------|------------------| | DFS | ✅ | ❌ | ✅ | ✅ | | Bellman-Ford | ✅ | ✅ | ✅ | ✅ | | SPFA | ✅ | ✅ | ✅ | ✅ | --- ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值