数学研发论坛

 找回密码
 欢迎注册
查看: 3285|回复: 8

[求助] 寻个 分解质因数V2.04破解版

[复制链接]
发表于 2011-2-24 13:20:23 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?欢迎注册

x
如题,如果谁有麻烦发我邮箱
1183812371@qq.com
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2011-2-24 16:49:29 | 显示全部楼层
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2011-2-24 17:00:44 | 显示全部楼层
网上的我找过了,下载不了。
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2011-2-24 18:20:01 | 显示全部楼层
3# 不穿男裤的酷男
很难下载吗?呵呵
v24.jpg
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2011-2-24 19:21:50 | 显示全部楼层
4楼的朋友麻烦发我邮箱,谢谢、
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2011-2-25 09:52:21 | 显示全部楼层
5# 不穿男裤的酷男
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2011-3-2 02:40:33 | 显示全部楼层
  1. #include <iostream>
  2. #include <cmath>
  3. using namespace std;

  4. unsigned int MPow(unsigned int factor, unsigned int n)
  5. {
  6.     unsigned int result = 1;
  7.     for (unsigned int i = 0; i < n; ++i)
  8.         result *= factor;
  9.     return result;
  10. }

  11. // common list declaration and implemention
  12. template <typename T>
  13. class SimpleList
  14. {
  15. private:
  16.     struct SimpleListNode
  17.     {
  18.         explicit SimpleListNode (const T &obj, SimpleListNode *pt = 0) : data(obj), next(pt) { }
  19.         T data;
  20.         SimpleListNode *next;
  21.     };
  22. public:
  23.     class Iterator
  24.     {
  25.     public:
  26.         explicit Iterator(SimpleListNode *pNode = 0) : node(pNode) { }
  27.         T &operator *() { return node->data; }
  28.         T *operator ->() const { return &(node->data); }
  29.         Iterator &operator ++()
  30.         {
  31.             node = node->next;
  32.             return *this;
  33.         }
  34.         friend bool operator == (const Iterator &it1, const Iterator &it2)
  35.         {
  36.             return it1.node == it2.node;
  37.         }
  38.         friend bool operator != (const Iterator &it1, const Iterator &it2)
  39.         {
  40.             return !(it1 == it2);
  41.         }
  42.     public:
  43.         SimpleListNode *node;
  44.     };

  45.     class ConstIterator
  46.     {
  47.     public:
  48.         explicit ConstIterator(const SimpleListNode *pNode = 0) : node(pNode) { }
  49.         const T &operator *() const { return node->data; }
  50.         const T *operator ->() const { return &(node->data); }
  51.         ConstIterator &operator ++()
  52.         {
  53.             node = node->next;
  54.             return *this;
  55.         }
  56.         friend bool operator == (const ConstIterator &it1, const ConstIterator &it2)
  57.         {
  58.             return it1.node == it2.node;
  59.         }
  60.         friend bool operator != (const ConstIterator &it1, const ConstIterator &it2)
  61.         {
  62.             return !(it1 == it2);
  63.         }
  64.     public:
  65.         const SimpleListNode *node;
  66.     };
  67.     SimpleList()
  68.         : head(0), tail(0) { }

  69.     SimpleList(const SimpleList &lst)
  70.         : head(0), tail(0)
  71.     {
  72.         append(lst);
  73.     }

  74.     ~SimpleList()
  75.     {
  76.         clear();
  77.     }

  78.     SimpleList & operator = (const SimpleList &lst)
  79.     {
  80.         clear();
  81.         append(lst);
  82.     }

  83.     ConstIterator begin() const { return ConstIterator(head); }
  84.     Iterator begin() { return Iterator(head); }
  85.     ConstIterator end() const { return ConstIterator(0); }
  86.     Iterator end() { return Iterator(0); }
  87.     ConstIterator last() const { return ConstIterator(tail); }
  88.     Iterator last() { return Iterator(tail); }

  89.     void append(const SimpleList &lst)
  90.     {
  91.         for (SimpleListNode *p = lst.head; p; p = p->next)
  92.             push_back(p->data);
  93.     }

  94.     void clear()
  95.     {
  96.         while(!empty())
  97.         {
  98.             SimpleListNode *p = head->next;
  99.             delete head;
  100.             head = p;
  101.         }
  102.     }

  103.     unsigned int size() const
  104.     {
  105.         unsigned int sz = 0;
  106.         for (const SimpleListNode *p = head; p; p = p->next)
  107.             ++sz;
  108.         return sz;
  109.     }

  110.     bool empty() const
  111.     {
  112.         return head == 0;
  113.     };

  114.     void push_front(const T &data)
  115.     {
  116.         head = new SimpleListNode(data, head);
  117.         if(!tail)
  118.             tail = head;
  119.     }

  120.     void push_back(const T &data)
  121.     {
  122.         if(tail)
  123.         {
  124.             tail->next = new SimpleListNode(data);
  125.             tail = tail->next;
  126.         }
  127.         else
  128.         {
  129.             head = tail = new SimpleListNode(data);
  130.         }
  131.     }

  132.     void pop_front()
  133.     {
  134.         SimpleListNode *tmp = head;
  135.         if(head == tail)
  136.             head = tail = 0;
  137.         else
  138.             head = head->next;
  139.         delete tmp;
  140.     }

  141.     void pop_back()
  142.     {
  143.         if(head == tail)
  144.         {
  145.             delete head;
  146.             head = tail = 0;
  147.         }
  148.         else
  149.         {  
  150.             SimpleListNode *tmp;
  151.             for(tmp = head; tmp->next != tail; tmp = tmp->next)
  152.                 ;
  153.             delete tail;
  154.             tail = tmp;
  155.             tail->next = 0;
  156.         }
  157.     }
  158. private:
  159.     SimpleListNode *head, *tail;
  160. };

  161. class MFactorCalulator
  162. {
  163. public:
  164.     typedef SimpleList<unsigned int> MPrimeList;
  165.    
  166.     struct MFactor
  167.     {
  168.         MFactor(unsigned int fct, unsigned rep = 0)
  169.             : factor(fct), repeat(rep) {}
  170.         unsigned int factor;
  171.         unsigned int repeat;
  172.     };
  173.     typedef SimpleList<MFactor> MFactorList;

  174.     struct MPerfectNumber
  175.     {
  176.         MPerfectNumber(unsigned int num, const MFactorList &factorList)
  177.             : number(num), factors(factorList) {}
  178.         unsigned int number;
  179.         MFactorList factors;
  180.     };
  181.     typedef SimpleList<MPerfectNumber> MPerfectNumberList;

  182. public:
  183.     MFactorCalulator(unsigned int upper)
  184.         : mUpper(upper) {}

  185.     const MPrimeList &PrimeList() const
  186.     {
  187.         return mPrimeChain;
  188.     }

  189.     const MPerfectNumberList &PerfectNumberList() const
  190.     {
  191.         return mPerfectNumberChain;
  192.     }

  193.     void DoCalculate()
  194.     {
  195.         FindPrimes(mUpper);
  196.         FindPerfectNumber(mUpper);
  197.     }
  198. private:
  199.     unsigned int mUpper;
  200.     MPrimeList mPrimeChain;
  201.     MPerfectNumberList mPerfectNumberChain;

  202.     void FindPrimes(unsigned int upper)
  203.     {
  204.         mPrimeChain.clear();
  205.         mPrimeChain.push_back(2);
  206.         mPrimeChain.push_back(3);
  207.         for (unsigned int i = 5; i <= upper; i += 2)
  208.         {
  209.             for (MPrimeList::Iterator it = ++mPrimeChain.begin(); it != mPrimeChain.end() && (i % *it); ++it)
  210.             {
  211.                 if (*it * *it > i)
  212.                 {
  213.                     mPrimeChain.push_back(i);
  214.                     break;
  215.                 }
  216.             }
  217.         }
  218.     }

  219.     void FindPerfectNumber(unsigned int upper)
  220.     {
  221.         for (unsigned int i = 2; i <= upper; ++i)
  222.             CheckPerfectNumber(i);
  223.     }

  224.     bool CheckPerfectNumber(unsigned int number)
  225.     {
  226.         unsigned int quotient = number;  
  227.         MFactorList factor_list;
  228.         for (MPrimeList::Iterator it = mPrimeChain.begin(); it != mPrimeChain.end(); ++it)
  229.         {
  230.             
  231.             if (*it * *it > quotient)
  232.             {
  233.                 MFactor factor1(quotient, 0);
  234.                 factor1.repeat = 1;
  235.                 factor_list.push_back(factor1);
  236.                 break;
  237.             }
  238.             MFactor factor(*it, 0);
  239.             while (quotient % *it == 0)
  240.             {
  241.                 ++factor.repeat;
  242.                 quotient /= *it;
  243.             }
  244.             if (factor.repeat > 0)
  245.                 factor_list.push_back(factor);
  246.         }
  247.         if (CalculateFactorSum(factor_list) == 2 * number)
  248.         {
  249.             mPerfectNumberChain.push_back(MPerfectNumber(number, factor_list));
  250.             return true;
  251.         }
  252.         return false;
  253.     }

  254.     unsigned int CalculateFactorSum(const MFactorList &chain)
  255.     {
  256.         unsigned int chainsize = chain.size();
  257.         MFactorList::ConstIterator *factor_arr = new MFactorList::ConstIterator[chainsize];
  258.         unsigned int* counter = new unsigned int[chainsize + 1]; // counter[chainsize] is to quit loop

  259.         MFactorList::ConstIterator p = chain.begin();
  260.         for (unsigned int i = 0; i < chainsize; ++i, ++p)
  261.         {
  262.             factor_arr[i] = p;
  263.             counter[i] = 0;
  264.         }
  265.         counter[chainsize] = 0;

  266.         unsigned int sum = 0;
  267.         while (!counter[chainsize]) // use the last element to quit loop
  268.         {
  269.             unsigned mix_product = 1;
  270.             for (unsigned j = 0; j < chainsize; ++j)
  271.                 mix_product *= MPow(factor_arr[j]->factor, counter[j]);
  272.             sum += mix_product;

  273.             ++counter[0];
  274.             for (j = 0; (j < chainsize) && (counter[j] > factor_arr[j]->repeat); ++j)
  275.             {
  276.                 counter[j] = 0;
  277.                 ++counter[j + 1];
  278.             }
  279.         }

  280.         delete []factor_arr;
  281.         delete []counter;
  282.         return sum;
  283.     }
  284. };

  285. int main()
  286. {
  287.     cout << "Input max number: ";
  288.     int upper;
  289.     cin >> upper;
  290.     MFactorCalulator calc(upper);
  291.     calc.DoCalculate();

  292.     for (MFactorCalulator::MPerfectNumberList::ConstIterator it = calc.PerfectNumberList().begin();
  293.         it != calc.PerfectNumberList().end(); ++it)
  294.     {
  295.         cout << it->number << " = ";
  296.         for (MFactorCalulator::MFactorList::ConstIterator itFactor = it->factors.begin();
  297.         (itFactor.node)->next != (it->factors.end()).node; ++itFactor)
  298.         {            
  299.             cout << itFactor->factor << '^' << itFactor->repeat;
  300.             cout << " * ";
  301.         }
  302.         cout << itFactor->factor << '^' << itFactor->repeat;
  303.         cout << endl;
  304.     }
  305.     return 0;
  306. }
复制代码
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2013-11-3 18:15:28 | 显示全部楼层
还有拿这个骗钱的东东????
叫PARI无地自容啊。。。。。
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2013-11-3 18:17:46 | 显示全部楼层
本来想去下载比较下跟PARI的差异,看到最大只能分解29位,我就笑了。。。。。


毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2022-5-19 00:11 , Processed in 0.087410 second(s), 19 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表