2. 程式人生 > >程式設計技巧--位運算的巧妙運用（1）

程式設計技巧--位運算的巧妙運用（1）

阿新 • • 發佈：2019-01-24

 作者:yunyu5120

             這是我的這一系列文章的第一篇，主要講述我學習過程中積累的一些程式設計技巧，由於我也是一個初學者，高手莫笑。這一篇主要講解位運算的基礎知識魚與其簡單應用，我主要以C/C++語言講述，其他語言可以類推。如果你已經對位運算基礎和應用十分熟悉，那麼本文並不適合你。

             我相信還是有一部分人對位運算還不是很瞭解，我希望你在看了本博文之後能對位運算有深刻的瞭解，並運能夠用自如，能夠體會到程式設計的樂趣。

            “寫程式，位運算是必要的嗎？”

             這個問題問的好，其實位運算並不是必要的，有什多方法可以可以代替位運算，但是位運算其特有的對程式的優化特點是無法替代的！當然如果你在寫Windows應用程式，其中呼叫的一些Windows APi 你就必須用到位運算，如最簡單的MessageBox。當然其中牽扯到的位運算過於簡單，就是簡單的或運算。想想當初寫的第一個windows程式用到MessageBox竟然出現了一個windows視窗，而不是那黑糊糊的Console，讓我興奮了還一段時間！可是當時的我也不知道這裡面牽扯的很多知識，甚至什麼是API都不知道！

             我們在學習C/C++的時候書本上對位運算的相關知識講得很少，就是簡單的“或與非”。如果你的記性好那麼你還會記得在位運算中還有一個運算叫做 “異或”運算和移位運算。不知道你現在對位運算的基礎是否還清楚，我在這裡假設我們都忘了位運算的基礎，所以下面我們對位運算進行復習一下。

C/C++語言提供的位運算子有：

運算子 含義 功能
& 按位與 如果兩個相應的二進位制位都為１，則該位的結果值為１；否則為０。
| 按位或 兩個相應的二進位制位中只要有一個為１，該位的結果值為１。
∧ 按位異或 若參加運算的兩個二進位制位同號則結果為０（假）異號則結果為１（真）
～ 取反 ～是一個單目（元）運算子，用來對一個二進位制數按位取反，即將０變１，將１變０。
<< 左移 左移運算子是用來將一個數的各二進位制位全部左移N位，右補０。
>> 右移 表示將a的各二進位制位右移N位，移到右端的低位被捨棄,對無符號數,高位補0。

位運算的結果演示：

位運算 或 “|” or 與 “&”and 非 “~” not 異或 “^” xor
運算元1 01010101 11010101 10101010 10000001
運算元2 00101010 10101010 (無) 01111111
也能算結果 01111111 10000000 01010101 11111110

               好了看了上面的兩個表格，相信你已經對位運算有所瞭解了，那麼接下來，我們就來講講位運算的應用。

1、  用於整數的奇偶性判斷

               想想，我們要判斷一個數的奇偶性，在沒用位運算之前我們可以用下列的程式碼來實現：

[cpp] view plain copy print?
  1. template<class Type>  
  2. bool Parity(Type value)  
  3. {  
  4.     if(value % 2 == 0)  
  5.         returnfalse;  
  6.     else
  7.         returntrue;  
  8. }  
  9. //加以優化 
  10. template<class Type>  
  11. inlinebool Parity(Type value)  
  12. {  
  13.     return (value % 2 != 0);  
  14. }  
template<class Type>
bool Parity(Type value)
{
	if(value % 2 == 0)
		return false;
	else
		return true;
}
//加以優化 
template<class Type>
inline bool Parity(Type value)
{
	return (value % 2 != 0);
}

             要知道，上面的程式碼我們使用的是對2取餘，如果運算元value是小數的話，還勉強行得通，但是value是一個上百萬的大數，那麼這就白白浪費了CPU的大量時間，程式的效率和效能就很差。我們知道任何數在計算機儲存中都是以二進位制儲存的，細心的你就會發現在二進位制的最小一位有個特點，為0就是偶數，為1就是奇數，按照這個原理我們根本沒必要讓我們的CPU大哥白白做那麼多的工作，只要一步判斷就可以了。接下來就讓我們看看位運算的精妙之處！

             那麼我們的目的就是判斷最小位是0還是1，可是我們怎麼判斷呢？我們要用位運算阿里判斷，就是與或非。在上面的複習之中我們只說了位運算的計算方法，並沒有說其用處。那麼在這裡我們用到的就是“與”！與運算特有的一個功能就是判斷指定位上的值（0或1）。我們來看下面的表格（與運算）。

運算元1 10101010 01010101 11111111 11111110
運算元2 00000001 00000001 00000001 00000001
運算結果 00000000 00000001 00000001 00000000

            我們要注意一下這裡的 運算元2 ，它只有最低位是1，其餘位都是0，這就是關鍵所在，運算元1是隨機值。我們看看結果只會有兩種結果：0或1。這個結果就取決於運算元1的最低位，它為1時就為1，為0時就為0.

            “那麼我要判斷的是第二位呢？”

            好！那我們就把運算元2改為 00000010 那麼結果就只會有 00000000 或 00000010 其結果取決於第二位。

            有了這個基礎那麼我們來看看怎麼用位運算判斷奇偶性吧：
 

[cpp] view plain copy print?
  1. template<class Type>  
  2. bool Parity(Type value)  
  3. {  
  4.     if(value & 0x0001 == 0)  
  5.         returnfalse;  
  6.     else
  7.         returntrue;  
  8. }  
  9. //加以優化 
  10. template<class Type>  
  11. inlinebool Parity(Type value)  
  12. {  
  13.     return (value & 1 != 0);  
  14. }  
  15. //在簡化 
  16. #define PARITY(value) (value&1)
template<class Type>
bool Parity(Type value)
{
	if(value & 0x0001 == 0)
		return false;
	else
		return true;
}
//加以優化 
template<class Type>
inline bool Parity(Type value)
{
	return (value & 1 != 0);
}
//在簡化 
#define	PARITY(value) (value&1)

                    使用a%2來判斷奇偶性和a & 1是一樣的作用，但是a & 1要快好多。

2、  判斷n是否是2的整數冪

                所謂2的整數冪就是指 1(2的0次冪)，2，4，8，16，32，64，128，256，512，1024，2048.............等數字，若何判斷一個數是否是這樣的數呢？我們看看不用位運算的計算方法：

[cpp] view plain copy print?
  1. #include "math.h" 
  2. template<class Type>  
  3. bool IsPowerOfTwo(Type value)  
  4. {  
  5.     for(int i = 0,l = 8*sizeof(value); i < l ;i++)  
  6.     {  
  7.         if(pow(2,i) == value)  
  8.         {  
  9.             returntrue;  
  10.         }  
  11.     }   
  12.     returnfalse;  
  13. }  
#include "math.h" 

template<class Type>
bool IsPowerOfTwo(Type value)
{
	for(int i = 0,l = 8*sizeof(value); i < l ;i++)
	{
		if(pow(2,i) == value)
		{
			return true;
		}
	} 
	return false;
}

             在這個演算法中，我們使用了一個迴圈。其原理非常簡單就是一一的對比，但是其中還呼叫了數學函式庫，效率大大降低。接下來我們講講怎樣用位運算來判斷。我們首先要研究一下這些數的特性，請看下錶（與運算）：

2的冪 8 16 32 64
n 00001000 00010000 00100000 01000000
n-1 00000111 00001111 00011111 00111111
與結果 00000000 00000000 00000000 00000000

            我們發現 n &（n-1） =  0  我們可以 用邏輯非  !（n&（n-1）） =  1 。那是不是這樣就可以了呢，你會發現 !（0&（0-1）） =  1 但是 0並不是 2的正整數冪。我們可以用 邏輯與 （!（n&（n-1） &&  n） = 1;請看下面的程式碼：

[cpp] view plain copy print?
  1. template<class Type>  
  2. inlinebool IsPowerOfTwo(Type n)  
  3. {  
  4.     if(((!(n&(n-1))) && n) == 1)  
  5.         returntrue;  
  6.     else
  7.         returnfalse;  
  8. }  
  9. //簡化 
  10. #define ISPOWEROFTWO(n) ((!(n&(n-1)) ) && n)
template<class Type>
inline bool IsPowerOfTwo(Type n)
{
	if(((!(n&(n-1))) && n) == 1)
		return true;
	else
		return false;
}
//簡化 
#define	ISPOWEROFTWO(n) ((!(n&(n-1)) ) && n)

3、  統計n在二進位制中1的個數

             樸素的統計辦法是：先判斷n的奇偶性，為奇數時計數器增加1，然後將n右移一位，重複上面步驟，直到移位完畢。

[cpp] view plain copy print?
  1. template<class Type>  
  2. inlinebool Parity(Type value)  
  3. {  
  4.     return (value % 2 != 0);  
  5. }  
  6. template<class Type>  
  7. inlineint CountOne(Type value)  
  8. {  
  9.     if(value != 0)  
  10.     {  
  11.         return Parity(value) + CountOne(value >> 1);  
  12.     }  
  13.     return 0;  
  14. }  
template<class Type>
inline bool Parity(Type value)
{
	return (value % 2 != 0);
}

template<class Type>
inline int CountOne(Type value)
{
	if(value != 0)
	{
		return Parity(value) + CountOne(value >> 1);
	}
	return 0;
}

             樸素的統計辦法是比較簡單的，那麼我們來看看比較高階的辦法。

              舉例說明，

                      考慮2位整數 n=11（十進位制為3），裡邊有2個1，先提取裡邊的偶數位10，奇數位01，把偶數位右移1位，然後與奇數位相加，因為每對奇偶位相加的和不會超過“兩位”，所以結果中每兩位儲存著數n中1的個數，那麼把 n 計算之後得到的值為：（10>>1）+01 = 01 + 01 = 10, 把10換成十進位制就是 2，2就代表 n(3)=11 中有兩個1！

                     相應的如果n是四位整數 n=0111(十進位制7)，先以“一位”為單位做奇偶位提取：偶數位 0010，奇數位0101。然後偶數位移位（右移1位）再相加：（0010>>1）+0101=0110；再用0110以“兩位”為單位做奇偶提取：偶數為0100，奇數位0010。偶數位移位（這時就需要移2位）再相加：（0100>>2）+0010=0011，因為此時每對奇偶位的和不會超過“四位”，所以結果中儲存著n中1的個數：（0100>>2）+0010=0011 把0011換成十進位制就是3，3就是n(7)=0111中有3個1。

                     依次類推可以得出更多位n的演算法。整個思想類似分治法。

  
在這裡就順便說一下常用的二進位制數：

二進位制數 二進位制值 用處
0xAAAAAAAA 10101010101010101010101010101010 偶數位為1，以1位為單位提取奇位
0x55555555 01010101010101010101010101010101 奇數位為1，以1位為單位提取偶位
0xCCCCCCCC 11001100110011001100110011001100 以“2位”為單位提取奇位
0x33333333 00110011001100110011001100110011 以“2位”為單位提取偶位
0xF0F0F0F0 11110000111100001111000011110000 以“8位”為單位提取奇位
0x0F0F0F0F 00001111000011110000111100001111 以“8位”為單位提取偶位
0xFFFF0000 11111111111111110000000000000000 以“16位”為單位提取奇位
0x0000FFFF 00000000000000001111111111111111 以“16位”為單位提取偶位
例如：32位無符 號數的1的個數可以這樣數：

[cpp] view plain copy print?
  1. int CountOne(unsigned int n)  
  2. {  
  3.     //0xAAAAAAAA，0x55555555分別是以“1位”為單位提取奇偶位
  4.     n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);  
  5.     //0xCCCCCCCC，0x33333333分別是以“2位”為單位提取奇偶位
  6.     n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);  
  7.     //0xF0F0F0F0，0x0F0F0F0F分別是以“4位”為單位提取奇偶位
  8.     n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F);  
  9.     //0xFF00FF00，0x00FF00FF分別是以“8位”為單位提取奇偶位
  10.     n = ((n & 0xFF00FF00) >> 8) + (n & 0x00FF00FF);  
  11.     //0xFFFF0000，0x0000FFFF分別是以“16位”為單位提取奇偶位
  12.     n = ((n & 0xFFFF0000) >> 16) + (n & 0x0000FFFF);  
  13.     return n;  
  14. }  
int CountOne(unsigned int n)
{
    //0xAAAAAAAA，0x55555555分別是以“1位”為單位提取奇偶位
    n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);
    //0xCCCCCCCC，0x33333333分別是以“2位”為單位提取奇偶位
    n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);
    //0xF0F0F0F0，0x0F0F0F0F分別是以“4位”為單位提取奇偶位
    n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F);
    //0xFF00FF00，0x00FF00FF分別是以“8位”為單位提取奇偶位
    n = ((n & 0xFF00FF00) >> 8) + (n & 0x00FF00FF);
    //0xFFFF0000，0x0000FFFF分別是以“16位”為單位提取奇偶位
    n = ((n & 0xFFFF0000) >> 16) + (n & 0x0000FFFF);

    return n;
}

                    看起來似乎採用位運算的程式碼比樸素方法程式碼要複雜的多，但是在效能上有著樸素方法無法比擬的優越性，只要四步簡單的運算就能達到目的，而樸素方法不是用迴圈就是遞迴，這大大降低了CPU的運算效能。

4、對於正整數的模運算（注意，負數不能這麼算）

先說下比較簡單的：

乘除法是很消耗時間的，只要對數左移一位就是乘以2，右移一位就是除以2，據說用位運算效率提高了60%。

乘2^k 眾所周知： n<<k。所以你以後還會傻傻地去敲2566*4的結果10264嗎？直接2566<<2就搞定了，又快又準確。

除2^k眾所周知： n>>k。

那麼 mod 2^k 呢？（對2的倍數取模）

n&((1<<k)-1)

用通俗的言語來描述就是,對2的倍數取模，只要將數與2的倍數-1做按位與運算即可。

好！方便理解就舉個例子吧。

思考：如果結果是要求模2^k時，我們真的需要每次都取模嗎？

在此很容易讓人想到快速冪取模法。

快速冪取模演算法

經常做題目的時候會遇到要計算 a^b mod c 的情況，這時候，一個不小心就TLE(演算法計算超時，ACM題目測試結果常見問題)了。那麼如何解決這個問題呢？位運算來幫你吧。

首先介紹一下秦九韶演算法：(數值分析講得很清楚)

把一個n次多項式f(x) = a[n]x^n+a[n-1]x^(n-1)+......+a[1]x+a[0]改寫成如下形式：

　　f(x) = a[n]x^n+a[n-1]x^(n-1))+......+a[1]x+a[0]

　　= (a[n]x^(n-1)+a[n-1]x^(n-2)+......+a[1])x+a[0]

　　= ((a[n]x^(n-2)+a[n-1]x^(n-3)+......+a[2])x+a[1])x+a[0]

　　=. .....

　　= (......((a[n]x+a[n-1])x+a[n-2])x+......+a[1])x+a[0].

　　求多項式的值時，首先計算最內層括號內一次多項式的值，即

　　v[1]=a[n]x+a[n-1]

　　然後由內向外逐層計算一次多項式的值，即

　　v[2]=v[1]x+a[n-2]

　　v[3]=v[2]x+a[n-3]

　　......

　　v[n]=v[n-1]x+a[0]

這樣，求n次多項式f(x)的值就轉化為求n個一次多項式的值。

好！有了前面的基礎知識，我們開始解決問題吧

由(a × b) mod c=( (a mod c) × b) mod c.

我們可以將 b先表示成就：

  b = a[t] × 2^t + a[t-1]× 2^(t-1) + …… + a[0] × 2^0.  (a[i]=[0,1]).

這樣我們由 a^b  mod  c = (a^(a[t] × 2^t  +  a[t-1] × 2^（t-1） + …a[0] × 2^0) mod c.

然而我們求  a^( 2^(i+1) ) mod c=( (a^(2^i)) mod c)^2 mod c .求得。

具體實現如下：

使用秦九韶演算法思想進行快速冪模演算法，簡潔漂亮

// 快速計算 (a ^ p) % m 的值 [cpp] view plain copy print?
  1. __int64 FastM(__int64 a, __int64 p, __int64 m)  
  2. {   
  3.     if (p == 0) return 1;  
  4.     __int64  r = a % m;  
  5.     __int64  k = 1;  
  6.     while (p > 1)  
  7.     {  
  8.         if ((p & 1)!=0)  
  9.         {  
  10.             k = (k * r) % m;   
  11.         }  
  12.         r = (r * r) % m;  
  13.         p >>= 1;  
  14.     }  
  15.     return (r * k) % m;  
  16. }  
__int64 FastM(__int64 a, __int64 p, __int64 m)
{ 
    if (p == 0) return 1;
    __int64  r = a % m;
    __int64  k = 1;
    while (p > 1)
    {
        if ((p & 1)!=0)
        {
            k = (k * r) % m; 
        }
        r = (r * r) % m;
        p >>= 1;
    }
    return (r * k) % m;
}

5、計算掩碼

什麼是掩碼？掩碼是一串二進位制程式碼對目標欄位進行位與運算，遮蔽當前的輸入位。用於從一個或多個位元組中選出的位的集合。

舉個例子：

我們有一個IP地址：192.168.1.111 對應二進位制：11000000.10101000.00000001.01101111。

我們讓這個IP位與：255.255.255.0 對應二進位制：11111111.11111111.11111111.00000000。

可以得到子網地址：192.168.1.0     對應二進位制：11000000.10101000.00000001.00000000。

在例子中我們通過觀察二進位制碼就知道，這個過程就是拿到IP的前三個位元組的資料資訊，這裡用到的255.255.255.0就是掩碼，也就是我們常說的子網掩碼。通過子網掩碼可以輕鬆的得到子網地址。那麼通過掩碼我們就可以輕鬆的得到多個位元組中指定的位的集合。

我們現在有一個需求：獲得數x的低n位的集合。

假設 x = 233 n= 6，我們就知道計算方法：233的二進位制是 11101001，所以結果集為 11101001&00111111 =00101001 十進位制為 41。在這個計算中233可以輕易改變，但是 00111111 已經指定 n = 6，要可以讓n也隨意改變怎麼辦呢？

我們用位運算的思維就可以得到 n = 6 時 00111111 可以表示為 (1 << 6) - 1 

那麼掩碼的計算公式就為：(1 << n) - 1 

現在根據需求可以寫出模版函式如下：

[cpp] view plain copy print?
  1. template<class Type>  
  2. inline Type LowByte(Type x, int n)  
  3. {  
  4.     return x & ((1 << n) - 1);  
  5. }  
  6. //簡化 
  7. #define LOWBYTE(x,n) x & ((x << n) - 1)
template<class Type>
inline Type LowByte(Type x, int n)
{
	return x & ((1 << n) - 1);
}
//簡化 
#define	LOWBYTE(x,n) x & ((x << n) - 1)

如果是高位集合呢？我們只需要把掩碼左移就可以了：n = 6 時 00111111<<2  公式為：((1 << 6) - 1)<<2

[cpp] view plain copy print?
  1. template<class Type>    
  2. inline Type HeightByte(Type x, int n)    
  3. {    
  4.     return x & (((1 << n) - 1) << (sizeof(x)-n));    
  5. }    
  6. //簡化  
  7. #define HEIGHTBYTE(x,n) x & (((1 << n) - 1) << (sizeof(x)-n))
template<class Type>  
inline Type HeightByte(Type x, int n)  
{  
    return x & (((1 << n) - 1) << (sizeof(x)-n));  
}  
//簡化  
#define HEIGHTBYTE(x,n) x & (((1 << n) - 1) << (sizeof(x)-n))


6、子集

假設我們有一個集合 mask =｛‘c’，‘b’，‘a’｝，要求列出集合的所有子集。我們可以使用位運算思想，把集合的元素的有無看成二進位制的0和1那麼我們展開舉例：

        ｛‘c’，‘b’，‘a’｝

            0     0     1                1                      ｛‘a’｝

            0     1     0                2                      ｛‘b’｝

            0     1     1                3                      ｛‘b’，‘a’｝

                  ...                      ...                          ...

            1     1     1                7                      ｛‘c’，‘b’，‘a’｝

              二進位制                十進位制                   對應子集

　　枚舉出一個集合的子集。設原集合為mask，則下面的程式碼就可以列出它的所有子集： 

　　for (i = mask ; i ; i = (i - 1) & mask) ; 

　　很漂很漂亮吧。

相關推薦

程式設計技巧--位運算的巧妙運用（1）

 作者:yunyu5120              這是我的這一系列文章的第一篇，主要講述我學習過程中積累的一些程式設計技巧，由於我也是一個初學者，高手莫笑。這一篇主要講解位運算的基礎知識魚與其簡單應用，我主要以C/C++語言講述，其他語言可以類推。如果你已經對位運算基礎和應用十分熟悉，那麼本文並不適

Java的位運算符—與（&）、非（~）、或（|）、異或（^）

ati 得出 rdquo 根據 有一個 關系 public 操作數 針對 位運算符主要針對二進制，它包括了：“與”、“非”、“或”、“異或”。從表面上看似乎有點像邏輯運算符，但邏

F() 表示式，這裡的F我理解是fast的意思，用它能節省讀寫資料庫的時間，在資料庫sql語言層面對欄位進行自增（+= 1）操作

1、F() 表示式，F我理解是fast的意思，用它能節省讀寫資料庫的時間，在資料庫sql語言層面對欄位進行自增（+= 1）操作，在Query Expressions章節介紹，這章沒讀過，趕緊收藏。 https://docs.djangoproject.com/en/2.1/ref/models/

201711671203《Java程式設計》第十二週（1）（合集版）

這周的學習報告分兩份，第一份是將過往偷懶的，沒整理全的知識點進行補充，順帶複習，第二份則針對Java網路程式設計、繪圖以及泛型與集合框架這三個大的點進行整理（可能寫不完拖到第十三週吧(#^.^#)） ------------------------------------------------

MVVM 與 ReactiveCocoa 的運用（1）

MVVM和資料繫結 MVVM模式依賴於資料繫結,能自動將物件屬性和UI controls相聯絡是其框架級的特性. 舉個例子,在微軟的WPF框架裡,ViewModel將TextField裡的Text屬性和Username屬性繫結,如下所示: Objective-C

Java併發程式設計系列之十：synchronized（1）

在多執行緒併發訪問資源（這類資源稱為臨街資源）的時候，由於割裂來了原子操作，所以會導致資料不一致的情況。為了避免這種情況，需要使用同步機制，同步機制能夠保證多執行緒併發訪問資料的時候不會出現資料不一致的情況。 一種同步機制是使用synchronized關鍵字，

JavaScript高階程式設計第3版學習心得（1）

語法 一、在html中加入JavaScript： 1.在html中嵌入JavaScript程式碼 <script type="text/javascript"> if(1<2){ alert('jjjj'); } </scri

二分查詢的巧妙運用（C++）

一、二分查詢 1、查詢無序陣列中的任意一個區域性最小值 區域性最小值：arr長度為1時，arr[0]是區域性最小。arr的長度為N(N>1)時，如果arr[0]<arr[1]，那麼arr[0]是區域性最小；如果arr[N-1]<arr[N-2]，那麼arr

C++抽象程式設計——字串（1）——字串運算

如今，我們雖然仍然把電腦稱為計算機，但是如今它處理的文字資訊卻遠遠多於我們的數字運算， 現代計算機處理文字資料的能力直接引領了簡訊，電子郵件，文書處理系統，線上參考庫（如百度百科），以及各種其他有用的應用程式的發展。這部分內容介紹了C++中的<string>庫，

hadoop程式設計小技巧（1）---map端聚合

測試hadoop版本：2.4 Map端聚合的應用場景：當我們只關心所有資料中的部分資料時，並且資料可以放入記憶體中。使用的好處：可以大大減小網路資料的傳輸量，提高效率；一般程式設計思路：在Mapper的map函式中讀入所有資料，然後新增到一個List（佇列）中，然後在clea

從頭認識Spring-1.15 對SpEl的值的操作（1）-數值運算

all import log lns public pos lov private details 這一章節我們來討論一下對SpEl的值的運算。1.domain烤爐類：（不變）package com.raylee.my_new_spring.my_new_spring.

形態學濾波：（1）腐蝕與膨脹 （2）開運算，閉運算，形態學梯度，頂帽，黑帽

來講 極小值 -h 明顯 基本 極限 元素 腐蝕 黑帽 一、形態學概述 　　圖像處理中的形態學一般指的是數學形態學。 　　數學形態學是一門建立在格論和拓撲學基礎之上的圖像分析學科，是數學形態學圖像處理的基本理論。其基本運算包括：二值腐蝕和膨脹，二值開閉運算，骨架抽取，極限腐

C# 《四》表達式和運算符（1）

center key 操作 mes string src ring mage ons 1、表達式 1、將變量和字面值（在使用運算符時，它們都稱作操作數）與運算符組合起來就得到了表達式，它是計算的基本構件。 2、簡單的操作包括所有的基本數學操作，如加減乘除；還有專門用於處理布

USGS-EROS項目espa-surface-reflectance中的LaSRC Version 1.3.0模塊利用vs2010編譯出windows64位版本的使用（三）

合成 ast mage files 關系 分享 一周 com window Landsat8大氣校正程序LaSRC是目前最好的，使用方式也夠傻瓜，輸入文件輸出結果。 但有一個限制，就是程序需要預先下載好的MODIS輔助文件來確定水汽、壓強等大氣參數。 如果待大氣校正的l

Python基礎（1）：基本運算符

src com .com strong images http es2017 image 1-1 1. 算數運算： 2. 比較運算 3. 賦值運算 4. 邏輯運算 5. 成員運算 Python基礎（1）：基本運算符

Codeforces Round #267 (Div. 2) B. Fedor and New Game【位運算/給你m+1個數讓你判斷所給數的二進制形式與第m+1個數不相同的位數是不是小於等於k，是的話就累計起來】

ons ecif 否則 ans contain rst rmi sum any After you had helped George and Alex to move in the dorm, they went to help their friend

Python基礎（二）之數據類型和運算（1）——數字

spa 發生 double類型 圖片 body poi 存在 discard 交互模式 數據類型初識 數字 2 是一個整數的例子。 長整數 不過是大一些的整數。 3.23和52.3E-4是浮點數的例子。E標記表示10的冪。在這裏，52.3E-4表示52.3 * 1

編程思考系列（1）使用條件運算符而不使用 if 語句的理由

定義 href class 運算 pos htm .html body gpo 使用條件運算符而不使用 if 語句的理由 變量的聲明和定義可以同時進行 減少臨時變量的使用 消除重復代碼 減少不必要的代碼塊 三項演算子を使うべき理由 編程思考系列（1）使用條件運算符而不使用

【AI基礎】python:openCV——圖像算術運算（1）

圖像算術運算圖像算術運算 1.圖像加法使用cv2.add()將兩幅圖像進行加法運算，也可以直接使用numpy，res=img1+img2.兩幅圖像的大小，類型必須一致，或者第二個圖像可以是一個簡單的標量值。openCV的加法是一種飽和操作，而numpy的加法是一種模操作。OpenCV的結果會更好 import

優化Join運算的系列方法（1）

target 容易 style one groups 用戶數 準備 要求 自然 轉載自http://c.raqsoft.com.cn/article/1535868803095?r=niu JOIN是關系數據庫中常用運算，用於把多個表進行關聯，關聯條件一般是判斷某個關聯字段