板栗说算法 之 PAT 乙级 1005 继续(3n+1)猜想 (全方面解析）

一、题目

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

 

二、思路

  例如对 n=3 进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4 个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。

也就是说，我们在验证一个数列的数是否为卡拉兹猜想时，验证过的数后，后面的数可能在之前验证过的数中计算过了

  在使用3进行卡拉兹猜想时，跟其他进行验证过的数进行比较发现，这个数列中再次出现了3的身影（6），所以3是被覆盖的。

  在使用5进行卡拉兹猜想时，跟其他进行验证过的数进行比较发现，这个数列中多次出现了5的身影（3，6，7，11），所以5是被覆盖的。

  在使用6进行卡拉兹猜想时，跟其他进行验证过的数进行比较发现，这个数列中没有再次出现6的身影，那么我们就可以判定6位关键数。

  在使用7进行卡拉兹猜想时，跟其他进行验证过的数进行比较发现，这个数列中没有再次出现7的身影，那么我们就可以判定6位关键数。

  在使用8进行卡拉兹猜想时，跟其他进行验证过的数进行比较发现，这个数列中多次出现了8的身影（3、5、6、7、11），所以我们判定8被覆盖。

  在使用11进行卡拉兹猜想时，跟其他进行验证过的数进行比较发现，这个数列中多次出现了11的身影（7），所以我们判定11被覆盖。  

  最后就是6和7为关键数了。

从中找寻规律发现，其实就是先记录每个数进行卡拉兹猜想时计算过的数，之后循环遍历进行查询，每个数在其他数验证时是否出现过，出现过则被覆盖，没出现过，则这个数就是关键数。

1.分析使用结构体，要有一个动态数组（vector）和一个能判定是否为关键字的变量（bool）

//每个数都有计算过的数记录在vetor里面，is_true默认为真，用来判断是否为关键数
struct str{
    vector<int>num;
    bool is_true = true;
};

2.根据用户输入创建数组

    int max;
    cin >> max;
    
    //根据数量来创建数组
    str * array = new str[max];

3.循环录入并记录计算过的数

    for(int i = 0; i < max; i++)
    {
        
        int num;
        cin >> num;
        
        //录入第一个数字
        array[i].num.push_back(num);
        
        //录入验证过的数
        while(num != 1)
        {
            num % 2 == 0 ? num /= 2 : num = (num*3 +1) /2;
            array[i].num.push_back(num);
        }
    }

4.验证一下（可选可不选，我调试用的）

    //测试
    for(int i = 0; i < max; i++)
    {
        for(vector<int>::iterator it = array[i].num.begin(); it < array[i].num.end(); it++)
        {
            cout << *it << " ";
        }
        cout << endl;
    }

5.进行遍历循环进行比较

    //开始进行比较
    for(int i = 0; i < max; i++)
    {
        //第一个是录入的数
        int temp = array[i].num[0];
        //cout << i << endl;
        //循环遍历这个数有几个
        for(int j = 0; j < max; j++)
        {
            //跳过
            if(j == i)
            {
                continue;
            }
            
            //进行遍历查询
            for(vector<int>::iterator it = array[j].num.begin(); it < array[j].num.end(); it++)
            {
                //如果出现了相同的就判定为被覆盖
                if(*it == temp)
                {
                    array[i].is_true = false;
                }
            }
        }
    }

6.创建数组录入关键字

    vector<int> put_array;
    for(int i = 0 ; i < max; i++)
    {
       //判断是否为关键字
        if(array[i].is_true == true)
        {
            put_array.push_back(array[i].num[0]);
        };
    }

7.进行排序并输出

    //从小到大p进行排序
    sort(put_array.begin(),put_array.end());
    
    //打印
    for(vector<int>::reverse_iterator it = put_array.rbegin(); it < 
    put_array.rend(); it++)
    {
        cout << *it;
        if(it != put_array.rend() - 1)
        {
            cout << " ";
        }
    }

三、代码实现

#include <iostream>
using namespace std;

#include <vector>

#include <algorithm>

struct str{
    vector<int>num;
    bool is_true = true;
};

int main()
{
    //几个数
    int max;
    cin >> max;
    
    //根据数量来创建数组
    str * array = new str[max];
    
    //循环录入
    for(int i = 0; i < max; i++)
    {
        
        int num;
        cin >> num;
        
        //录入第一个数字
        array[i].num.push_back(num);
        
        //录入验证过的数
        while(num != 1)
        {
            num % 2 == 0 ? num /= 2 : num = (num*3 +1) /2;
            array[i].num.push_back(num);
        }
    }
    
    //开始进行比较
    for(int i = 0; i < max; i++)
    {
        //第一个是录入的数
        int temp = array[i].num[0];
        //cout << i << endl;
        //循环遍历这个数有几个
        for(int j = 0; j < max; j++)
        {
            //跳过
            if(j == i)
            {
                continue;
            }
            
            //进行遍历查询
            for(vector<int>::iterator it = array[j].num.begin(); it < array[j].num.end(); it++)
            {
                if(*it == temp)
                {
                    array[i].is_true = false;
                }
            }
        }
    }

    //遍历如果是关键字就写入数组
   vector<int> put_array;
    for(int i = 0 ; i < max; i++)
    {
       //判断是否为关键字
        if(array[i].is_true == true)
        {
            put_array.push_back(array[i].num[0]);
        };
    }
    
    //从小到大p进行排序
    sort(put_array.begin(),put_array.end());
    
    //打印
    for(vector<int>::reverse_iterator it = put_array.rbegin(); it < put_array.rend(); it++)
    {
        cout << *it;
        if(it != put_array.rend() - 1)
        {
            cout << " ";
        }
    }
    
    return 0;
}