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

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

//code by indere 2017/6/16
//题目：
//当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对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、构建一个足够大的数组a[](***)，初始化都为0，测试数开始由0变2，然后进行（3n+1变换）
//2、途中计算得到的数，作为数组索引，将0变为1
//3、从第二个测试数开始，如果为0，变为2然后进行步骤一、步骤二，如果为1直接跳过
//4、最后遍历测试数，以它们为下标的索引值为2的即为关键数，提取出，并排序
//问题：
//1、如何选取数组的大小
//问题分析：数组的大小是不是必定在测试数组中最大值（奇数或偶数）变过过程中产生。或者说数组大小必定不超过最大
//数的某个关系
//比如3 5 6 7 8 11，最大值26是在7、11中变换中产生的

//理解，其实没必要把数组长度想得这么麻烦，判断的数只是给出的测试数据，只要找出测试数据中最大的数max，然后
//创建该max+1(+1是为了索引方便)的数组即可,分析过程中超过数组长度的数直接进行下一步(3n+1)运算，不改变数组数据。


#include<stdio.h>
#include<stdlib.h>

int getMax(int *test, int num);
void calcul(int *arr, int len,int *test,int num);
void callatz(int *arr, int len, int i);
int compareDec(const void *a, const void *b);

int main() {
    int num;
    scanf("%d", &num);
    int *test = (int *)malloc(sizeof(int) * num);
    for (int i = 0; i < num; i++) {
        scanf("%d", &test[i]);
    }
    int len = getMax(test, num) + 1;
    if (len <= 0)
        return 0;
    int *arr = (int *)calloc(len, sizeof(int));
    calcul(arr, len, test, num);
    free(test);
    free(arr);
    return 0;
}


int getMax(int *test, int num) {
    if (num <= 0)
        return -1;
    int result = test[0];
    for (int i = 1; i < num; i++) {
        if (result < test[i])
            result = test[i];
    }
    return result;
}

void calcul(int *arr, int len, int *test, int num) {
    for (int i = 0; i < num; i++) {
        if (arr[test[i]] == 0) {
            arr[test[i]] = 2;
            callatz(arr, len, test[i]);
        }else if(arr[test[i]] == 1)
            continue;
    }
    int n = 0;
    for (int i = 0; i < num; i++) {
        if (arr[test[i]] == 2)
            n++;
    }
    if(n == 0)      return ;
    int *result = (int *)malloc(sizeof(int)* n);
    int k = 0;
    for (int i = 0; i < num && k<n; i++) {
        if (arr[test[i]] == 2) {
            result[k++] = test[i];
        }
    }
    qsort(result, n, sizeof(int), compareDec);
    printf("%d", result[0]);
    for (int i = 1; i < n; i++)
        printf(" %d", result[i]);
    free(result);
}

void callatz(int *arr, int len, int i) {
    int n = i;
    while (n != 1) {
        if (n % 2 == 0) {
            n /= 2; 
            if (n < len) {
                if (arr[n] == 2) {
                    arr[n] = 1; break;
                }
                else if (arr[n] == 1) {
                    break;
                }
                arr[n] = 1;
            }
        }
        else {
            n = (n * 3 + 1) / 2;
            if (n < len) {
                if (arr[n] == 2) {
                    arr[n] = 1; break;
                }
                else if (arr[n] == 1) {
                    break;
                }
                arr[n] = 1;
            }
        }
    }
}

int compareDec(const void *a, const void *b) {
    return *(int *)b - *(int *)a;
}

1、指针数组初始化
extern void *malloc(unsigned int num_bytes);
int *test = (int )malloc(sizeof(int) * num);
如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。

void *calloc(size_t n, size_t size)；
int *arr = (int )calloc(len, sizeof(int));
calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据。一般使用后要使用 free(起始地址的指针) 对内存进行释放，不然内存申请过多会影响计算机的性能，以至于得重启电脑。如果使用过后不清零，还可以使用指针对该块内存进行访问。