2019蓝桥杯C++A组——修改数组

问题描述

给定一个长度为N的数组A = [A1, A2,…,AN]，数组中有可能有重复出现的整数。
现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改A2, A3, …, AN。
当修改Ai时，小明会检查Ai是否在A1~ Ai-1中出现过。
如果出现过，则小明会给Ai加上1；
如果新的Ai仍在之前出现过，小明会持续给Ai加1，直到Ai 没有在A1~Ai-1中出现过。
当AN也经过上述修改之后，显然A数组中就没有重复的整数了。
现在给定初始的A数组，请你计算出最终的A数组。

【输入】

第一行包含一个整数N(1<=N<=100000)
第二行包含N个整数A1,A2,…,AN(1<=Ai<=1000000)

【输出】

输出N个整数，依次是最终的A1,A2,…,AN

【样例输入】

5
2 1 1 3 4

【样例输出】

2 1 3 4 5

题目解析

1.暴力解法

题目看起来很简单，每次查一下前面是否存在相同数据即可。每读入一个新的数，就检查前面是否出现过，每一次需要检查前面所有的数。

但是，因为共有n个数，每个数检查O(n)次，所以总复杂度是O(n^2)的，超时。

2.Hash查找法

容易想到一个改进的方法：用hash。定义vis[]数组，vis[i]表示数字i是否已经出现过。这样就不用检查前面所有的数了，基本上可以在O(1)的时间内定位到。然而，本题有个特殊的要求：“如果新的Ai 仍在之前出现过，小明会持续给Ai 加1 ，直到Ai没有在A1~A(i−1) 中出现过。”这导致在某些情况下，仍然需要大量的检查。以5个9为例：A[]={9, 9, 9, 9, 9}。

1. 第一次检查A[1]=9，设置vis[9]=1；

2. 第二次检查A[2]=9，先查到vis[9]=1，则把A[2]加1，变为a[2]=10，设置vis[10]=1；

3. 第三次检查A[3]=9，先查到vis[9]=1，则把A[3]加1得A[3]=10；再查到vis[10]=1，再把A[3]加1得A[3]=11，设置vis[11]=1；

3.并查集解法

并查集简介

并查集在算法竞赛中极为常见。是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并问题。经典的应用有：连通子图、最小生成树Kruskal算法和最近公共祖先（Least Common Ancestors, LCA）等。

并查集：将编号分别为1~n的n个对象划分为不相交集合，在每个集合中，选择其中某个元素代表所在集合。在这个集合中，并查集的操作有：初始化、合并、查找。

并查集基本操作

1. 初始化
   定义数组int s[]是以结点i为元素的并查集，开始的时候，还没有处理点与点之间的朋友关系，所以每个点属于独立的集，并且以元素i的值表示它的集s[i]，例如元素1的集s[1]=1。

s[i]	1	2	3	4	5
i	1	2	3	4	5

2. 合并①，如加入第一个朋友关系(1, 2)，在并查集中把结点1合并到结点2，也就是把结点1的集1改成结点2的集2。

s[i]	2	2	3	4	5
i	1	2	3	4	5

3. 合并②，加入第二个朋友关系(1, 3)。查找结点1的集，是2，再递归查找元素2的集是2，然后把元素2的集2合并到结点3的集3。此时，结点1、2、3都属于一个集。右图中，为简化图示，把元素2和集2画在了一起。

s[i]	2	3	3	4	5
i	1	2	3	4	5

4. 查找。
   上面步骤中已经有查找操作。查找元素的集，是一个递归的过程，直到元素的值和它的集相等，就找到了根结点的集。从上面的图中可以看到，这棵搜索树的高度，可能很大，复杂度是O(n)的，变成了一个链表，出现了树的“退化”现象。

并查集例题

有n个人一起吃饭，有些人互相认识。认识的人想坐在一起，而不想跟陌生人坐。例如A认识B，B认识C，那么A、B、C会坐在一张桌子上。给出认识的人，问需要多少张桌子。

//并查集的实例操作
const int maxn=10;
int s[maxn];
int height[maxn];
void init_set() //初始化
{
    for(int i=1;i<=maxn;i++)
    {
        s[i]=i;
        height[i]=0; //树的高度
    }
}
int find_set(int x) //查找
{
    if(x!=s[x]) s[x] = find_set(s[x]); //路径压缩
    return s[x];
}
void merge_set(int x,int y)
{
    x = find_set(x);
    y = find_set(y);
    if(height[x]==height[y])
    {
        height[x] = height[x]+1; //合并，树的高度加一
        s[y] = x;
    }
    else //把矮树并到高树上，高树的高度保持不变
    {
        if(height[x]<height[y]) s[x] = y;
        else s[y] = x;
    }
}
int main()
{
    int t,n,m,x,y;
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        init_set();
        for(int i=1;i<=m;i++)
        {
            cin>>x>>y;
            merge_set(x,y);
        }
        int ans=0;
        for(int i=1;i<=n;i++) //统计有多少个集
            if(s[i]==i) ans++;
        cout<<ans<<endl;
    }
    return 0;
}

C++代码

暴力代码

#include<bits/stdc++.h>
using namespace std;
#define MAXA 1100005
int N,a[MAXA];
bool check(int x,int n) //检查当前数是否已经出现过
{
    for(int i=0;i<n;i++)
        if(a[i]==x) return true;
    return false;
}
int main()
{
    cin>>N;
    for(int i=0;i<N;i++)
    {
        cin>>a[i]; //输入数组
        while(check(a[i],i)) a[i]++;
        cout<<a[i]<<' ';
    }
    return 0;
}

并查集代码

#include<bits/stdc++.h>
using namespace std;
#define MAXA 1100005
int a,N,fa[MAXA],vis[MAXA];
int get_father(int x) //查找祖先
{
    if(x==fa[x]) return x;
    return fa[x] = get_father(fa[x]);
}
int main()
{
    cin>>N;
    for(int i=1;i<MAXA;i++) fa[i] = i; //并查集初始化
    for(int i=0;i<N;i++)
    {
        cin>>a;
        int ans=vis[a]?get_father(a)+1:a; //判断是否已被访问，已访问的话占取下一个位置
        cout<<ans<<' '; //输出ans
        vis[ans] = 1; //ans为已访问
        if(ans!=1&&vis[ans-1]) fa[ans-1] = ans; //表示ans-1的父亲是ans
        if(vis[ans+1]) fa[ans] = ans+1; //表示ans的父亲是ans+1
    }
    return 0;
}

本文到此结束，如有错误欢迎大家批评指正。