745 C. Hongcow Builds A Nation codeforces (并查集)

本文介绍了一个基于并查集的数据结构实现,用于解决图论中的连接问题。通过输入节点之间的连接关系,并利用并查集进行节点合并,最终计算出特定条件下节点间可能形成的连接数。代码中还涉及了排序算法的应用,以优化处理过程。
#include<bits/stdc++.h>
using namespace std;
bool visit[1005];
int pre[1005],num;
struct node
{
    int flag;
    int num1;
    int num2;
}arr[1005];
int find(int x)
{
    int y=x;
    while(y!=pre[y])
    {
        y=pre[y];
    }
    int temp;
    while(pre[x]!=y)
    {
        temp=pre[x];
        pre[x]=y;
        x=temp;
    }
    return y;
}
bool cmp(node x,node y)
{
    if(x.num1>y.num1)return true;
    return false;
}
int main()
{
    int n,m,k,x,y;
    cin>>n>>m>>k;
    for(int i=1;i<=k;i++)
    {
        cin>>x;
        visit[x]=1;
    }
    for(int i=1;i<=n;i++)
        pre[i]=i;
    memset(arr,0,sizeof(arr));
    while(m--)
    {
        cin>>x>>y;
        if(x>y) swap(x,y);
        int xx=find(x),yy=find(y);
        if(xx!=yy)
        {
            pre[yy]=xx;
            arr[xx].num2+=arr[yy].num2+1;
        }
        else
        {
            arr[xx].num2++;
        }
    }
    int num=0;
    for(int i=1;i<=n;i++)
    {
        x=find(i);
        arr[x].num1++;
        if(arr[x].flag==0)
        arr[x].flag=visit[i];
    }
    sort(arr+1,arr+1+n,cmp);
    int i,sum=0,sum1=0;
    for(i=1;i<=n;i++)
    {
        if(arr[i].flag)
            break;
    }
    for(int j=1;j<=i-1;j++)
    {
        arr[i].num1+=arr[j].num1;arr[i].num2+=arr[j].num2;
        arr[j].num1=0;
    }
    for(int j=i+1;j<=n;j++)
    {
        if(arr[j].num1==0) break;
        if(!arr[j].flag)
        {
            arr[i].num1+=arr[j].num1;arr[i].num2+=arr[j].num2;
            arr[j].num1=0;
        }
    }

    for(int j=1;j<=n;j++)
    {
        if(arr[j].num1==0)
            continue;
        sum+=arr[j].num1*(arr[j].num1-1)/2-arr[j].num2;
    }
    cout<<sum<<endl;
    return 0;
}

在 Neo4j 查询中,当出现 `This query builds a cartesian product between disconnected patterns` 的警告时,意味着查询中涉及的图模式之间没有明确的关系连接,导致 Neo4j 在内部对这些模式进行笛卡尔积运算。这种操作可能显著降低查询性能,甚至返回不符合预期的结果。 ### 解决方案 1. **引入显式关系** 最直接的解决方式是在查询中添加连接不同模式的关系。例如,若查询中分别匹配了两个节点 `(a:LabelA)` 和 `(b:LabelB)` 且它们之间原本没有连接,则可以通过添加一个关系来避免笛卡尔积: ```cypher MATCH (a:LabelA) MATCH (b:LabelB) WHERE a.relatedId = b.id RETURN a, b ``` 或者使用 `WITH` 子句进行中间结果传递: ```cypher MATCH (a:LabelA {name: "example"}) WITH a MATCH (b:LabelB)-[:RELATED_TO]->(a) RETURN a, b ``` 2. **使用 `OPTIONAL MATCH`** 如果两个模式之间可能存在连接,但并非总是存在,可以使用 `OPTIONAL MATCH` 来避免强制连接,同时避免笛卡尔积: ```cypher MATCH (a:LabelA) OPTIONAL MATCH (a)-[:RELATED]->(b:LabelB) RETURN a, b ``` 3. **优化查询结构** 检查查询逻辑是否可以重新构造,以减少不必要的多模式匹配。例如,如果某些模式之间没有逻辑上的关联,可以考虑将其拆分为多个独立查询,并在应用层进行结果合并。 4. **使用 `CALL` 子查询** Neo4j 支持使用 `CALL` 来执行子查询,从而隔离不同的匹配模式,避免笛卡尔积: ```cypher MATCH (a:LabelA) CALL { WITH a MATCH (b:LabelB)-[:CONNECTED_TO]->(a) RETURN b } RETURN a, b ``` 5. **索引优化** 确保在查询中涉及的属性上建立了适当的索引,以加快节点匹配和连接的速度。例如: ```cypher CREATE INDEX FOR (n:LabelB) ON (n.id) ``` 6. **限制匹配范围** 在查询中使用 `LIMIT` 或 `WHERE` 子句来限制匹配的节点数量,以减少笛卡尔积带来的性能影响: ```cypher MATCH (a:LabelA) WHERE a.category = "important" MATCH (b:LabelB) RETURN a, b LIMIT 100 ``` ### 总结 出现笛卡尔积警告时,应优先检查查询中是否存在多个没有连接的模式,并通过引入显式关系、使用 `OPTIONAL MATCH`、优化查询结构等方式来解决。同时,合理使用索引和限制匹配范围也能有效提升查询性能。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值