欧美久久久久久,性高朝久久久久久久久久,久久av免费天堂小草播放

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 發表評論