编程珠玑第二章

编程珠玑第二章

A题

给定一个最多包含40亿个随机排列的32位整数的顺序文件，找出一个不在文件中一32位整数。

1、在文件中至少存在这样一个数？

2、如果有足够的内存，如何处理？

3、如果内存不足，仅可以用文件来进行处理，如何处理？

答案：

1、32位整数，包括-2146473648~~2146473647，约42亿个整数，而文件中只有40亿个，必然有整数少了。

2、如果采用位数思想来存放，则32位整数最多需要占用43亿个位。约512MB的内存空间。

    可以采用前一章的位处理方法。然后判断每个int是否等于-1。因为-1的二进制表示是全1的。如果不等于-1。那么说明某一位没有置位。需要进行处理。

3、内存不足，可以采用如下思想：

    1、按最高位分为两段，没有出现的那个数，肯定在比较小的段里面。

        如果比较少的段最高位为1，那么缺少的那个数的最高位也为1.

       如果比较少的段最高位为0，那么少的那个数的最高位也是0.

       依次按以上方法去处理每个位。

       算法复杂度为O(n)。每次处理的部分都是上一次的一半。累加之后是O(n).

      思想与找第K小数的思想是一样的。只不过在这里是有一个自动分割的过程。而找第k小数的时候，是随机找一个数。

      为了验证思想这里写了段C代码。

 

[cpp] view plaincopy
 
  1. int get_lost(int *a, int *b, int *c, int alen, int bit)  
  2. {  
  3.     int re = 0, v = 0, biter = 0, *t, citer, i = 0;  
  4.     if (!a || !b || alen ==(unsigned long)( (1<< bit))) return -1;  //哪个数与最多可能拥有个数相等的时候，直接返回了。  
  5.   
  6.     while (bit--)  
  7.     {  
  8.         v = (1 << bit);  
  9.         for (biter = citer = i = 0; i < alen; ++i)  
  10.         {  
  11.             if (a[i] & (1 << bit)) b[biter++] = a[i];  
  12.             else c[citer++] = a[i];  
  13.         }  
  14.         if (biter <= citer)  
  15.         {  
  16.             re += v;  
  17.             t = a; a = b; b = t;  
  18.             alen = biter;  
  19.         }  
  20.         else  
  21.         {  
  22.             t = a; a = c; c = t;  
  23.             alen = citer;  
  24.         }  
  25.     }  
  26.     return re;  
  27. }  
a, b, c,都是三个等长的数组，alen表示其长度。bit表示位数。比如32位。bit=32.

 

re表示最后缺少的那个数。

 

B题

字符串循环移位

比如abcdef 左移三位,则变成defabc

基本还是按照书上的算法，

_rev(0, i)

_rev(i, len)

_rev(0, len)

 

[cpp] view plaincopy
 
  1. static void _res(char *a, int n)  
  2. {  
  3.     int i = 0, j = n - 1;  
  4.     char t;  
  5.     while (i < j)  
  6.     {  
  7.         t = a[i]; a[i] = a[j]; a[j] = t;  
  8.         ++i; --j;  
  9.     }  
  10. }  
  11. char *rever(char *a, int n, int len)  
  12. {  
  13.     int i, j;  
  14.     if (!a || !n) return a;  
  15.     _res(a, n);  
  16.     _res(a + n, len - n);  
  17.     _res(a, len);  
  18.     return a;  
  19. }  

C 题

 

给定一个单词集合，找出可以相互转换的集合。

比如abc bca cba都可以相互转换。

算法如下

把由于每个单词可以进行唯一性标识，把这个单词按照字母进行排序，可以相互转换的单词都有同样的标识。

这里用C++来写了。 

 

[cpp] view plaincopy
 
  1. void gen_label(vector<string> &dict, map<string, vector<string> >&rec)  
  2. {  
  3.     for (int i = 0; i < dict.size(); ++i)  
  4.     {  
  5.         string line = dict[i];  
  6.         sort(line.begin(), line.end());  
  7.         rec[line].push_back(dict[i]);  
  8.     }  
  9.   
  10.     for (map<string, vector<string> >::iterator iter = rec.begin();  
  11.         iter != rec.end(); ++iter)  
  12.     {  
  13.         copy((iter->second).begin(), (iter->second).end(), ostream_iterator<string>(cout , " "));  
  14.         cout << endl;  
  15.     }  
  16. }  

2.6习题

1 、如果没有时间进行预处理，那么可以找到这个单词的标识符，然后扫描这个字典，标识符相同的输出。

  如果可以预处理，那么可以先预处理，用gen_label函数进行预处理则可。

 

2、把原来的程序取较大的部分则可。实际上如果要形成严格地每次下降一半，那么需要如下处理。

    如果最多有max个整数，比如对于有4个bit位的整形数。最多有16个数。

    如果给了32个数，实际上只需要取前面17个数就可以了，后面的不要了。

    把这17个数按首位分为两堆，按理说一边是8，一边是9。如果发现分的一边比9还要多出几个。多出来的也不用看了。

    接下来处理9个的情况。

    通过这种策略，可以保证最终可以找到那个重复的数。

3、略过。这里涉及了一个效率不是那么高效的算法，不看也罢。

4、略过

5、如果是自己写函数那么就是前面所写的_rev函数。

    如果是要调用rever()函数。那么方法如下。

  

[cpp] view plaincopy
 
  1. int main(void)  
  2. {  
  3.     int n, len;  
  4.     char *c = NULL;  
  5.     while (scanf("%s", a) != EOF)  
  6.     {  
  7.         len = strlen(a);   
  8.         c = a;  
  9.         ++len;  
  10.         while (len--)  
  11.         {  
  12.             rever(c, len - 1, len);  
  13.             ++c;  
  14.         }  
  15.         printf("%s\n", a);  
  16.     }  
  17.     return 0;  
  18. }  

6、把名字对应的按键形成一个唯一的标识符，可以先对名字进行预处理。

    用hash,

    hash_map<int, hash_set<string> > rec;

7、 略过，记住按列再按行排序则可。

8、把最小的K个数找到O(nlogk),然后看这个K个数的和是否小于t.

9、搜索次数C > nlgn/ (n - lgn)

10、放到水中。

 

转自：http://blog.csdn.net/ju136/article/details/6839100

posted @ 2015-07-19 21:44  imKirin  阅读(264)  评论(0)  编辑  收藏  举报