我对一个小程序的两次重构过程

源于CSDN上一位网友提出的一个问题：

 

算法实验题1.2 等式数量
★问题描述
集合是基本的数学概念，集合中的元素是互不相同的。
表示相等关系的式子叫做等式。
给你一个包含有N个整数的集合，如果从集合中找到三个不同的整数a,b,c， 使得
a+b=c，那么我们说这个集合包含一个等式。
★编程任务
计算集合中所包含的等式数量。
★数据输入
第一行为一个整数N (3 <=N <=5,000)，表示集合中有N个不同的整数。第二行有N个整
数，表示集合中的元素，元素的整数值大小为-10000000~10000000。
★数据输出
输出一行一个整数，表示该集合的等式数量。
输入文件示例输出文件示例
input.txt output.txt
4        2
3125
http://topic.csdn.net/u/20090828/10/f41bc15e-339c-4b55-b1a6-2f4b3383a107.html?seed=547430668&r=59420060#r_59420060

 

他的算法是用三重循环来做。算法复杂度为n*n*n。

 

我能想到的就是改进为n*n*log(n)了，将其中的一层改进为二叉树结构。

 

初始程序：

我首先想到的是利用STL的map，它是基于树的。

#include <iostream> #include <sstream> #include <fstream> #include <cstdlib> #include <bitset> #include <vector> #include <map> #include <algorithm> namespace { const int LOW_VAL_BOUND = -10000000; const int HIGH_VAL_BOUND = 10000000; const size_t LOW_SIZE_BOUND = 3; const size_t HIGH_SIZE_BOUND = 5000; typedef std::vector<std::pair<int, int> > Vecpii; typedef std::map<int, Vecpii> Mapipii; } bool ReadInputFile(std::ifstream& in, Mapipii& judge, std::vector<int>& num) { using namespace std; size_t count; in >> count; if (!(LOW_SIZE_BOUND<=count && count<=HIGH_SIZE_BOUND)) return false; while(in.good()) { int n; in >> n; if (!(LOW_VAL_BOUND<=n && n<=HIGH_VAL_BOUND)) return false; for(vector<int>::iterator iter=num.begin(); iter != num.end(); ++iter) { Vecpii& addForm = judge[n+*iter]; addForm.push_back(pair<int, int>(n,*iter)); } num.push_back(n); } if(num.size()!=count) return false; return true; } std::ostream& operator<<(std::ostream& out, const Vecpii& aVector) { for(Vecpii::const_iterator cit=aVector.begin(); cit != aVector.end(); ++cit) { const std::pair<int, int>& aPair = *cit; out << aPair.first << '+' << aPair.second << '=' << aPair.first+aPair.second << std::endl; } return out; } int main ( ) { using namespace std; Mapipii judge; vector<int> num; ifstream in("input.txt"); if(!in.good() || !ReadInputFile(in, judge, num)) { cout << "error!/n"; in.close(); exit(1); } in.close(); int total=0; for(vector<int>::const_iterator cit=num.begin(); cit != num.end(); ++cit) { int n = *cit; if(judge.find(n) != judge.end()) { cout << judge[n]; ++total; } } ofstream out("output.txt"); out << total; cout << "/nTotal := " << total; out.close(); cout << endl; system("pause"); return 0; }

随后我用5000个数据做了压力测试，速度实在是慢42.001秒，内存占用729MB，受不了。。。

 

第一次重构：

鉴于LZ不要打印过程，我把map改成了set，则不需要添加map的vector了。

#include <iostream> #include <fstream> #include <vector> //#include <map> #include <set> #include <ctime> //#include <algorithm> namespace { const int LOW_VAL_BOUND = -10000000; const int HIGH_VAL_BOUND = 10000000; const size_t LOW_SIZE_BOUND = 3; const size_t HIGH_SIZE_BOUND = 5000; } bool ReadInputFile(std::ifstream& in, std::set<int>& judge, std::vector<int>& num) { using namespace std; size_t count; in >> count; if (!(LOW_SIZE_BOUND<=count && count<=HIGH_SIZE_BOUND)) return false; num.assign(count, 0); size_t i=0; while(in.good()) { int n; in >> n; if (!(LOW_VAL_BOUND<=n && n<=HIGH_VAL_BOUND)) return false; num[i++]=n; } if(i!=count) return false; for(vector<int>::iterator ita=num.begin(); ita != num.end(); ++ita) { for(vector<int>::iterator itb=num.begin(); itb != num.end(); ++itb) { if(ita != itb) judge.insert(*ita + *itb); } } return true; } int main ( ) { clock_t start = clock(); using namespace std; set<int> judge; vector<int> num; ifstream in("input.txt"); if(!in.good() || !ReadInputFile(in, judge, num)) { cout << "error!/n"; in.close(); exit(1); } in.close(); int total=0; for(vector<int>::const_iterator cit=num.begin(); cit != num.end(); ++cit) { if(judge.find(*cit) != judge.end()) ++total; } ofstream out("output.txt"); out << total; cout << "Total := " << total; cout << endl; cout << "Time using: "<< (double)(clock()-start)/CLOCKS_PER_SEC << endl; system("pause"); return 0; }

重构之后，内存占用降到322M，时间为30.01秒。算法复杂度不变。
当时我还说：不过对于LZ的要求应该是达到了，一般的数据量也能接受。

第二次重构：

晚上回去想想，这占内存也太大了，我想到用vector <bool>，这是vector的一个特化版本，主要是空间上的节约（大概省了30左右吧），另外不用动态new，时间也省了不少，而且查找是常数时间，而不是对数时间。

 #include <iostream> #include <fstream> #include <vector> #include <bitset> #include <ctime> #include <algorithm> namespace { const int LOW_VAL_BOUND = -10000000; const int HIGH_VAL_BOUND = 10000000; const size_t LOW_SIZE_BOUND = 3; const size_t HIGH_SIZE_BOUND = 5000; const size_t OFFSET = HIGH_VAL_BOUND-LOW_VAL_BOUND; } bool ReadInputFile(std::ifstream& in, std::vector<bool>& judge, std::vector<int>& num) { using namespace std; size_t count; in >> count; if (!(LOW_SIZE_BOUND<=count && count<=HIGH_SIZE_BOUND)) return false; num.assign(count, 0); size_t i=0; while(in.good()) { int n; in >> n; if (!(LOW_VAL_BOUND<=n && n<=HIGH_VAL_BOUND)) return false; num[i++]=n; } if(i!=count) return false; sort(num.begin(), num.end()); judge.assign(*(num.end()-1)+OFFSET, false); size_t tmp; for(size_t i=0; i < num.size(); ++i) { for(size_t j=i+1; j<num.size(); ++j) { tmp = num[i] + num[j] + OFFSET; if(tmp <= judge.size()) judge[tmp-1]=true; } } return true; } int main ( ) { clock_t start = clock(); using namespace std; vector<bool> judge; vector<int> num; ifstream in("input.txt"); if(!in.good() || !ReadInputFile(in, judge, num)) { cout << "error!/n"; in.close(); exit(1); } in.close(); int total=0; for(vector<int>::const_iterator cit=num.begin(); cit != num.end(); ++cit) { if(judge[*cit-1+OFFSET]) ++total; } ofstream out("output.txt"); out << total; cout << "Total := " << total; out.close(); cout << endl; cout << "Time using: "<< (double)(clock()-start)/CLOCKS_PER_SEC << endl; system("pause"); return 0; }

我还是用昨晚的5000个数据做压力测试，内存占用降到4M，时间为1.306秒（Release，P4 3.0G，1G内存）。我已经很满意了。算法复杂度不变。

 

我从这次重构中学到两点：

1. 算法复杂度不变，不代表没有优化的空间了，正如上面如得，第三个程序比第一个空间上优化150多倍，时间上优化40多倍。

2.STL的容器空间分配子只能针对大部分情况是好的，对于某些情况还是得用自己的分配子，例如，如果我一定用map，那么我可以自己做一个分配子，使得内存集中存放，这样就不用那么多的new操作。