1005 继续(3n+1)猜想

2024年2月24日

卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里，情况稍微有些复杂。

当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4 个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。我们称一个数列中的某个数 n 为“关键数”，如果 n 不能被数列中的其他数字所覆盖。

现在给定一系列待验证的数字，我们只需要验证其中的几个关键数，就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字，并按从大到小的顺序输出它们。

输入格式：

每个测试输入包含 1 个测试用例，第 1 行给出一个正整数 K (<100)，第 2 行给出 K 个互不相同的待验证的正整数 n (1<n≤100)的值，数字间用空格隔开。

输出格式：

每个测试用例的输出占一行，按从大到小的顺序输出关键数字。数字间用 1 个空格隔开，但一行中最后一个数字后没有空格。

输入样例：

6
3 5 6 7 8 11

输出样例：

7 6

/*
题目初解:
题目给定一个数列，要找出其中的关键数，关键数指卡拉兹猜想中
能够覆盖数列中其他数而自己不被覆盖的数
比如一下数列：
3 5 6 7 8 11
演示一下变为1的过程：
3->5->8->4->2->1
5->8->4->2->1;
6->3->5->8->4->2->1
7->11->17->26->13->20->10->5->8->4->2->1
8->4->2->1;
11->17->26->13->20->10->5->8->4->2->1
那么我们可以发现3之后是5，也就是5是被3覆盖的数;那么我们怎么
在给定的数列中体现覆盖呢，如果3覆盖了5，那么其实5后面的8421
这一系列的数也是被覆盖的，我们可以将被覆盖的数设置为失效，也就
是非关键数可以不用保留，可以将他设置为0或是负数，比如：
3 5 6 7 8 11
我们知道了3的下一个数是5，我们在数组中找是否含有5这个数，发现下一个
也就是5，5就确定不是关键数;于是新数组：
3 0 6 7 8 11 
然后3经过5的下一步是8，再在数组中寻找是否可以被覆盖的8，遍历发现有8
于是进行覆盖，新数组：
3 0 6 7 0 11
我们从第一个数开始，再他变为1的过程中用当前的数去数组中查看是否有能被
覆盖的数，如果有则进行覆盖，最后留下的也就是关键数。
然后留下的数进行排序然后输出即可;这里给定的数是不会有重复的数的.
*/
#include<iostream>
using namespace std;
int main(){
    int K;
    cin>>K;    //输入数字个数;
    int Data[K];
    for(int i=0;i<K;i++){
        cin>>Data[i];    //输入每个数字;
    }
    //逐个数进行卡拉兹操作，用当前获得的数检查数组中是否有可覆盖的数;
    int x=0;    //x赋值为当前操作数，避免更改数据;
    for(int i=0;i<K;i++){    //第一层循环时是每个数都要进行操作;
        x=Data[i];    //将Data中的值赋值给x;
        if(x){        //这里被覆盖的数不用参加循环;
            while(x!=1){        //这层循环是当前x变为1的操作;
                if(x%2==0){
                    x/=2;    //x为偶数;
                }
                else if(x%2==1){
                    x=(3*x+1)/2;    //x为奇数的情况;
                }
                for(int j=0;j<K;j++){    //这层循环去检查数组是否有可被覆盖的数;
                    if(Data[j]==x){
                        Data[j]=0;        //覆盖操作，将被覆盖的数置零;
                        break;
                    }
                }
            }
        }
    }
    /*
    //将覆盖之后的数组进行排序;
    int exchange=0;    //存放交换过程中其中一个数;
    for(int i=0;i<K;i++){
        for(int j=0;j<K-1;j++){
            if(Data[j]<Data[j+1]){
                exchange=Data[j];
                Data[j]=Data[j+1];
                Data[j+1]=exchange;
            }
        }
    }
    */
    //找出关键数;
    int count=0;    //记录关键数数量;
    for(int i=0;i<K;i++){
        //第一步数个数;
        if(Data[i]!=0){count++;}
    }
    //建立小数组并排序;
    int key[count];
    int j=0;
    for(int i=0;i<K;i++){
        if(Data[i]!=0){
            key[j++]=Data[i];
        }
    }
    //排序;
    int exchange=0;
    for(int i=0;i<count;i++){
        for(int k=0;k<count-1;k++){
            if(key[k]<key[k+1]){
                exchange=key[k];
                key[k]=key[k+1];
                key[k+1]=exchange;
            }
        }
    }
    //输出;
    for(int i=0;i<count-1;i++){    //这里最后一个数字没有空格，最后一个关键数后面是0或者没有数字(比如数列6 7)
        cout<<key[i]<<" ";
    }
    cout<<key[count-1];
    return 0;
}
/*
解题反思:
本题一共运行了两次超时，在三重循环也就是卡拉兹检验这一部分，时间复杂度是在n*n*n的，我以为K不超过
100是不会超时的，但是幂函数确实非常的厉害，很容易就超时了，我刚开始写的排序也是整个排序，后面就找
数出来排序，然后就是被覆盖的数不需要在进行卡拉兹验证，若x==0，这里陷入了死循环，导致运行超时.
*/