[C++]PAT乙级1005. 继续(3n+1)猜想 (25/25)

/*
1005. 继续(3n+1)猜想 (25)

卡拉兹(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
*/

/*
    思路：
        1.降序排序(选择排序)：原因-要按从大到小的顺序输出关键数字
        2.依次对元素计算Callatz猜想步骤(递归法)：
            0.对元素的Callatz猜想执行步骤进行统计count_steps，先初始化为0；
            1.若count_steps == 0,则说明为元素本身，不属于被覆盖其它元素之列；若count_steps>0，进行元素覆盖标记；
            1.判断当前数值是否为1，若为1，返回步数值，算法终止，结束；反之，进入步骤2；
            2.判断当前数值奇偶性，若为偶数，n折半，步数+1，进入步骤3；若为奇数，(3n+1)折半，步数+1，进入步骤3；
        3.输出所有未被标记的元素值。

    注意事项：
        字符串与数值相互转换（详情见博客：http://www.cnblogs.com/johnnyzen/p/8835132.html）
            #include <stdio.h>//sprintf
                int sprintf( char *buffer, const char *format, [ argument] … );
                    buffer：char型指针，指向将要写入的字符串的缓冲区。
                    format：格式化字符串。
                    [argument]...：可选参数，可以是任何类型的数据。
            #include <stdlib.h>//atof,atol,strtod,strtol
*/

#include<stdio.h>
#include<string.h>
#include<string>
using namespace std;

int count_steps = 0;
int *elements;//元素数组
int *elements_tags;//标记元素是否被覆盖过
int elements_length;

//step1:降序排序(选择排序法)
void Sort(int *elements){
    int flag,tmp;
    for(int i=0;i<elements_length;i++){
        flag = i;
        for(int j=i+1;j<elements_length;j++){
            if(elements[j]>elements[flag]){//每一趟，从第i+1开始，找最大值
                flag = j;
            }
        }
        if(flag != -1){
            tmp = elements[i];
            elements[i] = elements[flag];
            elements[flag] = tmp;
        }
    }
}

//标记元素
void TagElement(int value){
    for(int i=0;i<elements_length;i++){
        if(elements[i] == value){
            elements_tags[i] = 1;
        }
    }
}

//step2:对数组元素依次进行卡拉兹猜想验证
int Callatz(int num){
    if(count_steps != 0){
        TagElement(num);//对除了当期运算的本身元素以外的(被覆盖)元素进行标记
    }
    if(num == 1)
        return count_steps;
    count_steps++;
    if(num % 2 == 0){
        return Callatz(num / 2);
    } else {
        return Callatz( (3 * num + 1) / 2);
    }
}

void Input(int *elements){
    for(int i=0;i<elements_length;i++){
        scanf("%d", elements+i);
        elements_tags[i] = 0;//初始化标记数组
    }
}

//test
void print(int *elements, int length){
    for(int i=0;i<length;i++){
        printf("%d ", elements[i]);
    }
    printf("\n");
}

int main(){
    char output_str[1000];
    output_str[0]='\0';//注意：记得初始化被处理字符串，否则，可能出现字符串乱码！！！
    char tmp[10];
    scanf("%d", &elements_length);
    elements = new int [elements_length];
    elements_tags = new int [elements_length];

    Input(elements);
    Sort(elements);
    //print(elements, elements_length);//test
    for(int i=0;i<elements_length;i++){
        count_steps = 0;//初始化
        Callatz(elements[i]);
    }

    //print(elements_tags, elements_length);//test
    for(int i=0;i<elements_length;i++){
        if(elements_tags[i] == 0){
            sprintf(tmp, "%d", elements[i]);//将数值转字符串
            strcat(output_str, tmp);
            strcat(output_str, " ");
        }

    }
    output_str[strlen(output_str)-1] = '\0';
    printf("%s", output_str);
    return 0;
}
/*
6
3 5 6 7 8 11
*/