百度松果泡泡 (数组模拟 TLE)

原创已于 2022-10-01 10:27:23 修改 · 1.3k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #图论

于 2022-10-01 10:26:45 首次发布

牛客刷题专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一个模拟泡泡碰撞融合过程的算法实现。通过一系列碰撞规则，实现了多个泡泡环碰撞后的序列重组，并确保输出结果遵循字典序最小的原则。文章提供了详细的C++代码实现。

题目描述

小码哥一开始吹出的泡泡被母体记为1，2，。。。，n，而泡泡的碰撞融合实际是数字的拼接(有序)。
母体会通过模拟得知两个泡泡环碰撞的情况(用x->y表示)
例如，有一个为1-2的泡泡环与3-4-5的泡泡环碰撞，碰撞的点为1->4(后一个数字接在前一个数字下面)，则会形成1-4-5-3-2的泡泡环
一开始所有泡泡环都只有一个数字，母体演算出了泡泡之后的碰撞点，现在请你输出泡泡碰撞完后的所有泡泡的情况。

输入格式

第一行两个正整数n,m，表示一开始泡泡的数量和泡泡碰撞的次数
接下来m行，每行两个数字x,y，表示泡泡碰撞的两个点

输出格式

输出所有泡泡的情况，一行表示一个泡泡的情况
要求按照字典序最小的方式按顺序输出

输入样例

输出样例

1 2 4 6 8 5 
3 
7 9

解释
$1≤m<n≤10^6$ , $1 < x, y < n$ 保证x，y属于不同的泡泡环
BUBBLE

分析

本题目的一个基本操作a->b，即以b为首元素的序列插入到a所在泡泡的a的位置的后面。
每一个泡泡的融合都需要找到a和b在各自泡泡中的位置。

C++ 代码

#pragma GCC optimize(2)
#include<bits/stdc++.h> 
using namespace std;
const int N = 1e6+10;
int n,m,a,b,idx=1;
bool st[N];
vector<int> v[N];
unordered_map<int,int> mp;
int main( )
{
    scanf("%d%d",&n,&m);
    //刚开始每个泡泡都是独立的
    for(int i=1;i<=n;i++)
    {
        mp[i]=i;
        v[mp[i]].push_back(i);
    }
    
    for(int i=0;i<m;i++)
    {
            cin>>a>>b;
            //找到a在自己泡泡中的位置
            int t1=mp[a],insertp;
            for(insertp=0;insertp<v[t1].size();insertp++)
            {
                if(v[t1][insertp]==a) break;
            }
            
            //找到b在自己泡泡中的位置
            int t2=mp[b],j,l=10000001;
            for(j=0;j<v[t2].size();j++)
            {
                if(v[t2][j]==b)
                {
                    l=j;
                    break;
                }
            }
            
            //以b为首元素将其后的元素插入到a泡泡中
            for(j=l;j<v[t2].size();j++)
            {
                insertp=min(insertp+1,(int)v[t1].size());
                v[t1].insert(v[t1].begin()+insertp,v[t2][j]);
                mp[v[t2][j]]=mp[v[t1][0]];
            }
            
            //将b所在泡泡中剩下的元素插入到a泡泡中
            for(j=0;j<l;j++)
            {
                insertp=min(insertp+1,(int)v[t1].size());
                v[t1].insert(v[t1].begin()+insertp,v[t2][j]);
                mp[v[t2][j]]=mp[v[t1][0]];
            }
    }
    
    for(int i=1;i<=n;i++)
    {
        if(!st[i])
        {
            //找到泡泡中最小的一个元素
            int t=mp[i],j;
            for(j=0;j<v[t].size();j++)
            {
                if(v[t][j]==i)
                {
                    break;
                }
            }
            
            //以该元素为首输出泡泡即可保证字典序最小
            for(int k=j;k<v[t].size();k++)
            {
                st[v[t][k]]=1;
                cout<<v[t][k]<<" ";
            }
            for(int k=0;k<j;k++)
            {
                st[v[t][k]]=1;
                cout<<v[t][k]<<" ";                
            }
            puts("");
            
            
        }
    }

    
    return 0;
}