C++博客-kenwell-随笔分类-算法

Three Inverters From Two

c++ 学习 — Sat, 11 Oct 2008 10:17:00 GMT

Construct a circuit which takes three binary inputs, a, b, c, and creates as outputs their complements, a', b', c', (NOT a, NOT b, NOT c) with the restriction that you may only use two inverters (NOT gates). You are allowed as many AND and OR gates as you wish, but no other gates, besides these and the two inverters, can be used.

A neat generalization of this problem is "how many inverters do you need to compute the complements of N inputs", but I do not know the answer to this (I don't even know if the answer is known).

the firs question's answer:
In black below is a circuit for the 3 with 2 case. Its not the smallest possible such circuit but is written as a hint toward the more general case.

Its written in C code for easy verification.

1 #include <stdio.h>
2 void main(){
3  int a,b,c,x,y,z,g,h,a1,b1,c1,x1,y1,z1;
4  int i;
5  for(i=0;i<8;i++){
6   // set up all possible inputs a,b,c
7   a = i & 1;
8   b = (i & 2) >> 1;
9   c = (i & 4) >> 2;
10
11   x = a & b & c;
12   y = a & b | a & c | b & c;
13   z = a | b | c;
14
15   //Here are our 2 inverters
16   g = !(y);
17   h = !(x | g & z);
18
19   x1 = g | h;
20   y1 = g;
21   z1 = g & h;
22   a1 = b & c & x1 | (b | c) & y1 | z1;
23   b1 = a & c & x1 | (a | c) & y1 | z1;
24   c1 = b & a & x1 | (b | a) & y1 | z1;
25
26   //print outputs to verify
27   printf("%d-->%d   %d-->%d   %d-->%d\n",a,a1,b,b1,c,c1);
28  }
29 }

c++ 学习 2008-10-11 18:17 发表评论

约瑟夫环的解决方案

c++ 学习 — Tue, 07 Oct 2008 11:16:00 GMT

题目：n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。当一个数字删除后，从被删除数字的下一个继续删除第m个数字。求出在这个圆圈中剩下的最后一个数字。
分析：既然题目有一个数字圆圈，很自然的想法是我们用一个数据结构来模拟这个圆圈。在常用的数据结构中，我们很容易想到用环形列表。我们可以创建一个总共有m个数字的环形列表，然后每次从这个列表中删除第m个元素。
在参考代码中，我们用STL中std::list来模拟这个环形列表。由于list并不是一个环形的结构，因此每次跌代器扫描到列表末尾的时候，要记得把跌代器移到列表的头部。这样就是按照一个圆圈的顺序来遍历这个列表了。
这种思路需要一个有n个结点的环形列表来模拟这个删除的过程，因此内存开销为O(n)。而且这种方法每删除一个数字需要m步运算，总共有n个数字，因此总的时间复杂度是O(mn)。当m和n都很大的时候，这种方法是很慢的。
接下来我们试着从数学上分析出一些规律。首先定义最初的n个数字（0,1,…,n-1）中最后剩下的数字是关于n和m的方程为f(n,m)。
在这n个数字中，第一个被删除的数字是m%n-1，为简单起见记为k。那么删除k之后的剩下n-1的数字为0,1,…,k-1,k+1,…,n-1，并且下一个开始计数的数字是k+1。相当于在剩下的序列中，k+1排到最前面，从而形成序列k+1,…,n-1,0,…k-1。该序列最后剩下的数字也应该是关于n和m的函数。由于这个序列的规律和前面最初的序列不一样（最初的序列是从0开始的连续序列），因此该函数不同于前面函数，记为f’(n-1,m)。最初序列最后剩下的数字f(n,m)一定是剩下序列的最后剩下数字f’(n-1,m)，所以f(n,m)=f’(n-1,m)。
接下来我们把剩下的的这n-1个数字的序列k+1,…,n-1,0,…k-1作一个映射，映射的结果是形成一个从0到n-2的序列：
k+1 -> 0
k+2 -> 1
…
n-1 -> n-k-2
0 -> n-k-1
…
k-1 -> n-2
把映射定义为p，则p(x)= (x-k-1)%n，即如果映射前的数字是x，则映射后的数字是(x-k-1)%n。对应的逆映射是p-1(x)=(x+k+1)%n。
由于映射之后的序列和最初的序列有同样的形式，都是从0开始的连续序列，因此仍然可以用函数f来表示，记为f(n-1,m)。根据我们的映射规则，映射之前的序列最后剩下的数字f’(n-1,m)= p-1 [f(n-1,m)]=[f(n-1,m)+k+1]%n。把k=m%n-1代入得到f(n,m)=f’(n-1,m)=[f(n-1,m)+m]%n。
经过上面复杂的分析，我们终于找到一个递归的公式。要得到n个数字的序列的最后剩下的数字，只需要得到n-1个数字的序列的最后剩下的数字，并可以依此类推。当n=1时，也就是序列中开始只有一个数字0，那么很显然最后剩下的数字就是0。我们把这种关系表示为：
0 n=1
f(n,m)={
[f(n-1,m)+m]%n n>1
尽管得到这个公式的分析过程非常复杂，但它用递归或者循环都很容易实现。最重要的是，这是一种时间复杂度为O(n)，空间复杂度为O(1)的方法，因此无论在时间上还是空间上都优于前面的思路。
思路一的参考代码：

///////////////////////////////////////////////////////////////////////
// n integers (0, 1,  n - 1) form a circle. Remove the mth from
// the circle at every time. Find the last number remaining
// Input: n - the number of integers in the circle initially
//        m - remove the mth number at every time
// Output: the last number remaining when the input is valid,
//         otherwise -1
///////////////////////////////////////////////////////////////////////
int LastRemaining_Solution1(unsigned int n, unsigned int m)
{
      // invalid input
      if(n < 1 || m < 1)
            return -1;
      unsigned int i = 0;
      // initiate a list with n integers (0, 1,  n - 1)
      list<int> integers;
      for(i = 0; i < n; ++ i)
            integers.push_back(i);
      list<int>::iterator curinteger = integers.begin();
      while(integers.size() > 1)
      {
            // find the mth integer. Note that std::list is not a circle
            // so we should handle it manually
            for(int i = 1; i < m; ++ i)
            {
                  curinteger ++;
                  if(curinteger == integers.end())
                        curinteger = integers.begin();
            }

            // remove the mth integer. Note that std::list is not a circle
            // so we should handle it manually
            list<int>::iterator nextinteger = ++ curinteger;
            if(nextinteger == integers.end())
                  nextinteger = integers.begin();
            -- curinteger;
            integers.erase(curinteger);
            curinteger = nextinteger;
      }

      return *(curinteger);
}

思路二的参考代码：

void circile(int n, int m)
{
    int num = 0;
    for(int i = 2; i <= n; i++)
        num = (num + m) % i;

    num += 1;

    cout << num << endl;
}

c++ 学习 2008-10-07 19:16 发表评论

一个n!的数后面有多少个0

c++ 学习 — Thu, 26 Jun 2008 06:23:00 GMT

前一段时间看到一个往年程序竞赛的题解, 有一个题目说的是求 100 的阶乘末尾有多少个 0. 题解中给出的讲解提到, 一个数 n 的阶乘末尾有多少个 0 取决于从 1 到 n 的各个数的因子中 2 和 5 的个数, 而 2 的个数是远远多余 5 的个数的, 因此求出 5 的个数即可. 题解中给出的求解因子 5 的个数的方法是用 n 不断除以 5, 直到结果为 0, 然后把中间得到的结果累加. 例如, 100/5 = 20, 20/5 = 4, 4/5 = 0, 则 1 到 100 中因子 5 的个数为 (20 + 4 + 0) = 24 个, 即 100 的阶乘末尾有 24 个 0. 其实不断除以 5, 是因为每间隔 5 个数有一个数可以被 5 整除, 然后在这些可被 5 整除的数中, 每间隔 5 个数又有一个可以被 25 整除, 故要再除一次, ... 直到结果为 0, 表示没有能继续被 5 整除的数了.

今天无意间看到有人问 1000 的阶乘有几位数, 上来就用上面的方法算了一下, 249, 又读一遍题目, 才发现是求所有的位数, 想了好久也没有思路, 无奈用 Python 算了一把, 结果有 2568 位, 可是依然不知道如何计算 1000 阶乘的位数, 还好通过结果验证了末尾有 249 个 0 是正确的...

c++ 学习 2008-06-26 14:23 发表评论

1000 的阶乘有几位数? - 后续, 求解

c++ 学习 — Thu, 26 Jun 2008 06:22:00 GMT

这是在 2006 年 11 月 17 日浏览小百合时得到的，当时上不来，就暂存在我的信箱里了。

南京大学小百合站，Algorithm 版，x->18->1 和 x->18-2。

x->18->1:(两处红色标记是我个人加上的，怀疑原文有误，即若有 10 和 100，则前面不应有 90 和 1800)

令结果为 x
x=log2+log3+...+log9
+90+log1.1+log1.2+...+log9.9
+1800+log1.01+log1.02+...+log9.99
+3
=∫logx dx (从2到10)
+90+10∫logx dx(从1.1到9.9)
+1800+ 100∫logx dx (从1.01到9.99)
+3
= ...
后两次积分上限的不同是考虑到修正

x->18->2:

x=(∫log(x)dx(2--1001)+∫log(x)dx(1--1000))/2
=((x*log(x)-∫xdlog(x))(2--1001)+(x*log(x)-∫xdlog(x))(1---1000))/2
=2567.857000.....

我个人的想法：

经过上述两个方法，我猜想求解一个数的位数可以求解该数对其基数的对数（此处是以 10 为基数的），找了几个数写了写，发现可以：

一个以 b 为基数的数 N，在以 b 为基数的计数系统中的位数 l，可以通过求 N 对 b 的对数求得。
具体为：l=floor[log b (N) + 1]，即求对数，结果加 1 后向下取整。

例如：

length(123456789)10=floor[lg(123456789)+1]=floor[8.091514977+1 ]=9
length(100000000)10=floor[lg(100000000)+1]=floor[8+1]=9
length(10101)2=floor[log 2 (23) + 1]=floor[4.523561956+1]=5 (10101)2=(23)10

再回到求解 1000 的阶乘的位数上，则根据上面的说明，有：(设 1000 的阶乘结果为 N)

length(N)10=floor[lg(N)+1]
           =floor[lg(1*2*3*...*999*1000)+1]
           =floor[lg1+lg2+lg3+...+lg999+lg1000+1]
           =floor[lg2+lg3+...lg999+lg1000+1]    <= lg1=0

这时问题转到了求解 lg2+lg3+...+lg999+lg1000 的累加上面。

对于这一方面我不是很清楚(高等数学基本都不记得了...)，不过根据前面两篇文章，好像有：

∑(N=2..1000)lgN = ∫lgxdx (x=2..1000)

如果成立的话，则根据 lgx = lnx/ln10 有：

∫lgxdx (x=2..1000) = (1/ln10)*∫lnxdx (x=2..1000)

= (1/ln10)*[x*lnx - ∫xd(lnx)] (x=2..1000)

= (1/ln10)*[x*lnx - ∫dx] (x=2..1000)

= (1/ln10)*[x*lnx - x] (x=2..1000)

= x*(lnx - 1)/ln10 (x=2..1000)

然后由牛顿-莱伯尼茨公式可以得到：(也不知道是否能在此处应用...)

∫lgxdx (x=2..1000) = 1000*(ln1000 - 1)/ln10 - 2*(ln2 - 1)/ln10

= [1000*(6.907755279 - 1) - 2*(0.693147181 - 1)]/ln10

= [1000* 5.907755279 - 2*(-0.306852819)]/2.302585093

= [5907.755279 - (- 0.613705639)]/2.302585093

= 5908.368984639/2.302585093

= 2565.97204707

将结果代回前面的式子：

length(N)10 = floor[2565.97204707 + 1] = 2566

原先通过 Python 计算过 1000 的阶乘，位数为 2568 位。

考虑前面推算的过程中把 x=1 时 lg1 略掉了，理论上不应产生区别，但若要是不略掉该项时，则结果变成：

∫lgxdx (x=2..1000) = 1000*(ln1000 - 1)/ln10 - 1*(ln1 - 1)/ln10

= [1000*( 6.907755279 - 1) - 1*(0 - 1)]/ln10

= [1000*5.907755279 - 1*(-1)]/2.302585093
= [5907.755279 + 1]/2.302585093

= 5908.755279/2.302585093

= 2566.13981258

length(N)10 = floor[2566.13981258 + 1] = 2567

可见结果略有不同，但都与正确结果有一点小偏差，个人认为思路是正确的，方法还有待改进。同时看到第二篇引文的结果非常接近，不过我还不理解，还需在琢磨琢磨。

还要再好好看看高等数学...

posted on 2007-01-11 12:14 ScorpioLove 阅读(1261) 评论(4) 编辑收藏所属分类: 数据结构与算法

Comments

#1楼

蔡晖 [未注册用户]

把求lgN(N=2.3.4....1000)转换为积分，这个思路就有误差吧。
积分是连续的，而这里的N是离散的，所以这里的转换不合理。

Posted @ 2007-04-18 09:25 回复引用查看

#2楼

wqx [未注册用户]

你红字加的内容不对，不应该乘10和100；
楼上的说的也不对，把不可直接求职的离散转为积分是基本的方法，只要误差允许接受就可以，具体可以看CLRS的附录A

Posted @ 2007-04-24 10:07 回复引用查看

#3楼 [楼主]

ScorpioLove

谢谢各位回复，同时希望能原谅我不能及时的回复各位。

@ 蔡晖

事实上这个问题，我在计算前也考虑过，确实有误差，不过就像 wqx 说的，只要误差可接受就可以了，像这里的误差相对于实际结果而言是比较小的，可以接受。

@ wqx

关于红字部分，我在算式前面的括号里注明了，10 和 100 是原来算式里就有的，但我觉得不该加，所以就用红色标记了一下，可能导致你误以为是我强调要加上的...

关于 CLRS，我目前正在读，不过感觉好难啊，好多课后题都不会...
如果可能，希望能和你交流一下^_^。

Posted @ 2007-04-24 13:26 回复引用查看

#4楼

foobar

居然看到了牛顿莱布尼茨公式。。。。。

Posted @ 2007-09-18 17:53 回复引用查看

c++ 学习 2008-06-26 14:22 发表评论