蓝桥杯 2019 研究生组 试题 H: 修改数组

并查集：

题目：
思路：
1.一直查询的方式，构造很多个循环
时间不允许

import java.util.Scanner;

public class 数组 {
    //复制一个数组，进行查询有没有重复的
    //记录最大整数进行替代
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int number = sc.nextInt();
        int[] A = new int[number];
        for(int i=0;i<number;i++){
            A[i] = sc.nextInt();
        }
        fun(A);
        for(int i=0;i<A.length;i++){
            System.out.print(A[i]+" ");
        }
    }
    public static int[] fun(int[] A ){
        int[] A2 = A.clone();
        int m =0;
        for(int i=1;i<A.length;i++){//需要判断的当前元素
            for(int j=0;j<i;j++){//从头到当前元素进行遍历查询
                if(A[i] == A[j]){
                    A[i] = A[i]+1;
                    for(int k=0;k<i;k++){
                        if(A[i]==A[k]){
                            A[i] = A[i]+1;
                        }
                    }
                }
            }
        }
        return A;
    }
}

思路2:
网上查询的使用并查集的方法，也就是边使用边构造一个图。
//构造一个并查集-在我看来就是构造一个树，一棵树，大到小或者小到大
//开始的时候父节点都是自己，查询的时候一点点进行更新集合
//如果一次都没有出现那就是自己本身也就是u=u
//如果已经出现过，那就需要考虑他的下一位或者至少下一位-也就是通过构造的树来进行返回最大值
//那么就需要每次在进行访问后进行更新数据
//

import java.util.Scanner;

public class 修改数组4 {
    //构造一个并查集-在我看来就是构造一个树，一棵树，大到小或者小到大
    //开始的时候父节点都是自己，查询的时候一点点进行更新集合
    //如果一次都没有出现那就是自己本身也就是u=u
    //如果已经出现过，那就需要考虑他的下一位或者至少下一位-也就是通过构造的树来进行返回最大值
    //那么就需要每次在进行访问后进行更新数据
    //
    static int macn = 100010;
    static int[] f= new int[macn];//存放树，也就是根节点的指向
    static int[] ans = new int[macn];//存放输入数据的答案

    //初始化跟节点，
    public static void init(){
        for(int i =0;i<macn;i++){
            f[i] = i;//所有的父节点都指向自己
        }
    }
    //查询
    public static int find(int s ){
        if(s==f[s]){return s;}//如果是指向自己，则返回自己本身，也就是没有被访问过
        else {return find(f[s]);}//如果被访问过，就一直往上查询树，一直插队相同的为值。相同的也就是一直更新
    }
    //合并数据
    public static void merge(int s,int y){
        //查表进行合并
        int g = find(s);
        int h = find(y);//在已经建立好集合的地方进行寻找
        //相等就不用更新，不相等的时候，让小的变成大的的下标
        if(g>h){
            f[h] = g;
        }
        if(h>g){
            f[g] = h;
        }

    }

    public static void main(String[] args) {
        //得到数据
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        init();//初始化数据
        //输入数据
        for(int i=0;i<n;i++){
            int s = sc.nextInt();//得到一个数据
            //查询集合
            ans[i] = find(s);
            //得到一个答案后进行合并数据
            //相当于是在f中进行树的再一次更新,也就是找寻下一次的树的顶点
            merge(ans[i],ans[i]+1);
        }
        //输出ans
        for(int j=0;j<n;j++){
            System.out.println(ans[j]+" ");
        }
    }
}

可是时间复杂度好像一直不过关

思路3
看了大神的讲解，发现更厉害的解决方式，也就跟上面的并查集相似度很大。更改了合并的操作，将合并改为数据在原位置加一

import java.util.Scanner;

public class 修改数组5 {

    static int N = 1100010;
    static int[] p = new int[N];
    static int[] ans = new int[N];

    //这个就是查询集合
    public static int find(int x){
        if(x != p[x]){
            p[x] = find(p[x]);
        }
        return p[x];
    }
    //主函数
    public static void main(String[] args) {
        int n;
        Scanner sc=new Scanner(System.in);
        n = sc.nextInt();
        //初始化
        for(int i = 0;i<N;i++){
            p[i] = i;
        }
        //并查集查询，查询之后进行
        for(int i =0;i<n;i++){
            int x = sc.nextInt();//这里是一个输入，为啥可以连续输入好几个
            x = find(x) ;
            ans[i] = x;
            p[x] = x+1;//最快的直接在原来的地方上加一下次找就直接找到
        }
        for(int i=0;i<n;i++){
            System.out.print(ans[i]+" ");
        }
    }
}