分塊演算法模板

⑴ c++的模板定義

找本C++的書看看，上面講的都比較詳細，而且還有例子。

C++模板概述

只有使用C++語言的少數用戶才努力嘗試去理解模板的基本原理。然而那些希望去探索更多高級用法的人往往發現自己需要努力去理解模板是如何被語言所支持的，因為缺乏明確的說明。一個很大的問題在於一些工具只實現了C++標準的一個子集。本文將指出它們共同的缺陷並深入剖析如何使用C++模板快速產生可重用和高效的代碼。
模板功能應用的典型是通過一系列模板類形成的完整類庫，特別是STL和ATL。標准C++庫(STL)提供了很多可重用和靈活的類及演算法，而ATL則是使用C++進行COM編程的事實標准。要掌握這些及其它的模板庫，理解模板是如何工作的這一基礎是非常重要的。

函數模板

int main()
{
0 cout<<add(2,3)<<endl;
1 cout<<add(2.1,3)<<endl;
2 cout<<add(2,3.2)<<endl;
3 cout<<add(2.2,3.3)<<endl;
4 cout<<add("hello eone ","world")<<endl;
return 0;
}

也可以通過宏定義#define add(a,b) ((a)+(b))來實現,但是指針(字元串)不能直接相加.對於2,3,4需要進行模板特化.
通過重載函數，我們能夠完成多種不同數據類型的相同操作。要實現兩個double數值的加法和兩個整數類型的加法，我們可以使用一個重載函數：

int add(const int x, const int y)
{
return x + y;
}

double add(const double x, const double y)
{
return x + y;
}

這時，編譯器將根據它們的參數正確地解決這一問題。

// 調用int add(const int, const int);
const int z1 = add(3, 2);
// 調用double add(const double, const double);
const double z2 = add(3.0, 2.0);
如果我們需要處理其它類型，我們就不得不提供其他函數重載。對每個不同的數據類型實現一個函數重載，它們都遵循相同的模式，每當我們需要調用針對某一數據類型的函數時，原則上編譯器為我們生成相應的代碼。而一個模板函數則以如下方式實現：

template<class T>
const T add(const T &t1, const T &t2)
{
return t1 + t2;
}

從概念上來說，編譯器通過模板關鍵字(後面跟隨著模板由一或多個模板參數構成的參數列表)來識別模板。當為某一具體類型調用add時，編譯器將根據模板定義並用給定的類型替換出現在模板中的參數。在這個例子中，模板參數列表由一個獨立的類型模板參數T構成。使用一個模板函數替代函數重載，編譯器可以自動為所需的新類型生成代碼
我們可以對任何擁有+操作符定義的類型使用add模板。假設一個自定義的String類提供了字元串連接並知道如何將自身寫入到std::ostream。因為String與該模板函數兼容，因此我們可以調用它來實現字元串相加：

// 示例字元串
const string strBook("book");
const string strWorm("worm");
// 顯示 "bookworm".
cout << add(strBook, strWorm) << endl;
Seeing that we intended to add two String values, the compiler will generate the appropriate add function on our behalf, which would look something like:
const String add(const String &t1, const String &t2)
{
return t1 + t2;
}

顯式實例化

調用模板函數時，編譯器將先把正確的類型實例化模板。雖然標准允許顯式模板實例化，然而並非所有廠商都能夠正確地實例它。例如，Visual C++ 6.0 會潛在地調用錯誤的函數：:
template<class T>
int getSize(void) {
return sizeof(T);
}
// 輸出4，應該為8
cout << "double: " << getSize<double>() << endl;
// 輸出4，正確
cout << "int: " << getSize<int>() << endl;
跨平台代碼設計者不希望依賴於顯式模板函數實例化，除非有更好的編譯器能夠對它提供有效的支持

⑵ c++排序演算法相關問題

排序演算法是一種基本並且常用的演算法。由於實際工作中處理的數量巨大，所以排序演算法對演算法本身的速度要求很高。
而一般我們所謂的演算法的性能主要是指演算法的復雜度，一般用O方法來表示。在後面我將給出詳細的說明。
對於排序的演算法我想先做一點簡單的介紹，也是給這篇文章理一個提綱。
我將按照演算法的復雜度，從簡單到難來分析演算法。
第一部分是簡單排序演算法，後面你將看到他們的共同點是演算法復雜度為O(N*N)（因為沒有使用word,所以無法打出上標和下標）。
第二部分是高級排序演算法，復雜度為O(Log2(N))。這里我們只介紹一種演算法。另外還有幾種演算法因為涉及樹與堆的概念，所以這里不於討論。
第三部分類似動腦筋。這里的兩種演算法並不是最好的（甚至有最慢的），但是演算法本身比較奇特，值得參考（編程的角度）。同時也可以讓我們從另外的角度來認識這個問題。
第四部分是我送給大家的一個餐後的甜點——一個基於模板的通用快速排序。由於是模板函數可以對任何數據類型排序（抱歉，裡面使用了一些論壇專家的呢稱）。

現在，讓我們開始吧：

一、簡單排序演算法
由於程序比較簡單，所以沒有加什麼注釋。所有的程序都給出了完整的運行代碼，並在我的VC環境
下運行通過。因為沒有涉及MFC和WINDOWS的內容，所以在BORLAND C++的平台上應該也不會有什麼
問題的。在代碼的後面給出了運行過程示意，希望對理解有幫助。
1.冒泡法：
這是最原始，也是眾所周知的最慢的演算法了。他的名字的由來因為它的工作看來象是冒泡：
#include <iostream.h>
void BubbleSort(int* pData,int Count)
{
int iTemp;
for(int i=1;i<Count;i++)
{
for(int j=Count-1;j>=i;j--)
{
if(pData[j]<pData[j-1])
{
iTemp = pData[j-1];
pData[j-1] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
BubbleSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情況)
第一輪：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交換3次)
第二輪：7,10,9,8->7,10,8,9->7,8,10,9(交換2次)
第一輪：7,8,10,9->7,8,9,10(交換1次)
循環次數：6次
交換次數：6次
其他：
第一輪：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交換2次)
第二輪：7,8,10,9->7,8,10,9->7,8,10,9(交換0次)
第一輪：7,8,10,9->7,8,9,10(交換1次)
循環次數：6次
交換次數：3次
上面我們給出了程序段，現在我們分析它：這里，影響我們演算法性能的主要部分是循環和交換，
顯然，次數越多，性能就越差。從上面的程序我們可以看出循環的次數是固定的，為1+2+...+n-1。
寫成公式就是1/2*(n-1)*n。
現在注意，我們給出O方法的定義：
若存在一常量K和起點n0，使當n>=n0時，有f(n)<=K*g(n),則f(n) = O(g(n))。（呵呵，不要說沒
學好數學呀，對於編程數學是非常重要的！！！）
現在我們來看1/2*(n-1)*n，當K=1/2，n0=1，g(n)=n*n時，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n)
=O(g(n))=O(n*n)。所以我們程序循環的復雜度為O(n*n)。
再看交換。從程序後面所跟的表可以看到，兩種情況的循環相同，交換不同。其實交換本身同數據源的有序程度有極大的關系，當數據處於倒序的情況時，交換次數同循環一樣（每次循環判斷都會交換），復雜度為O(n*n)。當數據為正序，將不會有交換。復雜度為O(0)。亂序時處於中間狀態。正是由於這樣的原因，我們通常都是通過循環次數來對比演算法。

2.交換法：
交換法的程序最清晰簡單，每次用當前的元素一一的同其後的元素比較並交換。
#include <iostream.h>
void ExchangeSort(int* pData,int Count)
{
int iTemp;
for(int i=0;i<Count-1;i++)
{
for(int j=i+1;j<Count;j++)
{
if(pData[j]<pData[i])
{
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
ExchangeSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情況)
第一輪：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交換3次)
第二輪：7,10,9,8->7,9,10,8->7,8,10,9(交換2次)
第一輪：7,8,10,9->7,8,9,10(交換1次)
循環次數：6次
交換次數：6次
其他：
第一輪：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交換1次)
第二輪：7,10,8,9->7,8,10,9->7,8,10,9(交換1次)
第一輪：7,8,10,9->7,8,9,10(交換1次)
循環次數：6次
交換次數：3次
從運行的表格來看，交換幾乎和冒泡一樣糟。事實確實如此。循環次數和冒泡一樣也是1/2*(n-1)*n，所以演算法的復雜度仍然是O(n*n)。由於我們無法給出所有的情況，所以只能直接告訴大家他們在交換上面也是一樣的糟糕（在某些情況下稍好，在某些情況下稍差）。
3.選擇法：
現在我們終於可以看到一點希望：選擇法，這種方法提高了一點性能（某些情況下）這種方法類似我們人為的排序習慣：從數據中選擇最小的同第一個值交換，在從省下的部分中選擇最小的與第二個交換，這樣往復下去。
#include <iostream.h>
void SelectSort(int* pData,int Count)
{
int iTemp;
int iPos;
for(int i=0;i<Count-1;i++)
{
iTemp = pData[i];
iPos = i;
for(int j=i+1;j<Count;j++)
{
if(pData[j]<iTemp)
{
iTemp = pData[j];
iPos = j;
}
}
pData[iPos] = pData[i];
pData[i] = iTemp;
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
SelectSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情況)
第一輪：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交換1次)
第二輪：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交換1次)
第一輪：7,8,9,10->(iTemp=9)7,8,9,10(交換0次)
循環次數：6次
交換次數：2次
其他：
第一輪：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交換1次)
第二輪：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交換1次)
第一輪：7,8,10,9->(iTemp=9)7,8,9,10(交換1次)
循環次數：6次
交換次數：3次
遺憾的是演算法需要的循環次數依然是1/2*(n-1)*n。所以演算法復雜度為O(n*n)。
我們來看他的交換。由於每次外層循環只產生一次交換（只有一個最小值）。所以f(n)<=n
所以我們有f(n)=O(n)。所以，在數據較亂的時候，可以減少一定的交換次數。

4.插入法：
插入法較為復雜，它的基本工作原理是抽出牌，在前面的牌中尋找相應的位置插入，然後繼續下一張
#include <iostream.h>
void InsertSort(int* pData,int Count)
{
int iTemp;
int iPos;
for(int i=1;i<Count;i++)
{
iTemp = pData[i];
iPos = i-1;
while((iPos>=0) && (iTemp<pData[iPos]))
{
pData[iPos+1] = pData[iPos];
iPos--;
}
pData[iPos+1] = iTemp;
}
}

void main()
{
int data[] = {10,9,8,7,6,5,4};
InsertSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情況)
第一輪：10,9,8,7->9,10,8,7(交換1次)(循環1次)
第二輪：9,10,8,7->8,9,10,7(交換1次)(循環2次)
第一輪：8,9,10,7->7,8,9,10(交換1次)(循環3次)
循環次數：6次
交換次數：3次
其他：
第一輪：8,10,7,9->8,10,7,9(交換0次)(循環1次)
第二輪：8,10,7,9->7,8,10,9(交換1次)(循環2次)
第一輪：7,8,10,9->7,8,9,10(交換1次)(循環1次)
循環次數：4次
交換次數：2次
上面結尾的行為分析事實上造成了一種假象，讓我們認為這種演算法是簡單演算法中最好的，其實不是，
因為其循環次數雖然並不固定，我們仍可以使用O方法。從上面的結果可以看出，循環的次數f(n)<=
1/2*n*(n-1)<=1/2*n*n。所以其復雜度仍為O(n*n)（這里說明一下，其實如果不是為了展示這些簡單
排序的不同，交換次數仍然可以這樣推導）。現在看交換，從外觀上看，交換次數是O(n)（推導類似
選擇法），但我們每次要進行與內層循環相同次數的『=』操作。正常的一次交換我們需要三次『=』
而這里顯然多了一些，所以我們浪費了時間。
最終，我個人認為，在簡單排序演算法中，選擇法是最好的。

二、高級排序演算法：
高級排序演算法中我們將只介紹這一種，同時也是目前我所知道（我看過的資料中）的最快的。
它的工作看起來仍然象一個二叉樹。首先我們選擇一個中間值middle程序中我們使用數組中間值，然後
把比它小的放在左邊，大的放在右邊（具體的實現是從兩邊找，找到一對後交換）。然後對兩邊分別使
用這個過程（最容易的方法——遞歸）。
1.快速排序：
#include <iostream.h>
void run(int* pData,int left,int right)
{
int i,j;
int middle,iTemp;
i = left;
j = right;
middle = pData[(left+right)/2]; //求中間值
do{
while((pData[i]<middle) && (i<right))//從左掃描大於中值的數
i++;
while((pData[j]>middle) && (j>left))//從右掃描大於中值的數
j--;
if(i<=j)//找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果兩邊掃描的下標交錯，就停止（完成一次）
//當左邊部分有值(left<j)，遞歸左半邊
if(left<j)
run(pData,left,j);
//當右邊部分有值(right>i)，遞歸右半邊
if(right>i)
run(pData,i,right);
}
void QuickSort(int* pData,int Count)
{
run(pData,0,Count-1);
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
QuickSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
這里我沒有給出行為的分析，因為這個很簡單，我們直接來分析演算法：首先我們考慮最理想的情況
1.數組的大小是2的冪，這樣分下去始終可以被2整除。假設為2的k次方，即k=log2(n)。
2.每次我們選擇的值剛好是中間值，這樣，數組才可以被等分。
第一層遞歸，循環n次，第二層循環2*(n/2)......
所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n
所以演算法復雜度為O(log2(n)*n)
其他的情況只會比這種情況差，最差的情況是每次選擇到的middle都是最小值或最大值，那麼他將變
成交換法（由於使用了遞歸，情況更糟）。但是你認為這種情況發生的幾率有多大？？呵呵，你完全
不必擔心這個問題。實踐證明，大多數的情況，快速排序總是最好的。
如果你擔心這個問題，你可以使用堆排序，這是一種穩定的O(log2(n)*n)演算法，但是通常情況下速度要慢於快速排序（因為要重組堆）。
三、其他排序
1.雙向冒泡：
通常的冒泡是單向的，而這里是雙向的，也就是說還要進行反向的工作。
代碼看起來復雜，仔細理一下就明白了，是一個來回震盪的方式。
寫這段代碼的作者認為這樣可以在冒泡的基礎上減少一些交換（我不這么認為，也許我錯了）。
反正我認為這是一段有趣的代碼，值得一看。
#include <iostream.h>
void Bubble2Sort(int* pData,int Count)
{
int iTemp;
int left = 1;
int right =Count -1;
int t;
do
{
//正向的部分
for(int i=right;i>=left;i--)
{
if(pData[i]<pData[i-1])
{
iTemp = pData[i];
pData[i] = pData[i-1];
pData[i-1] = iTemp;
t = i;
}
}
left = t+1;
//反向的部分
for(i=left;i<right+1;i++)
{
if(pData[i]<pData[i-1])
{
iTemp = pData[i];
pData[i] = pData[i-1];
pData[i-1] = iTemp;
t = i;
}
}
right = t-1;
}while(left<=right);
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
Bubble2Sort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
2.SHELL排序
這個排序非常復雜，看了程序就知道了。
首先需要一個遞減的步長，這里我們使用的是9、5、3、1（最後的步長必須是1）。
工作原理是首先對相隔9-1個元素的所有內容排序，然後再使用同樣的方法對相隔5-1個元素的排序
以次類推。
#include <iostream.h>
void ShellSort(int* pData,int Count)
{
int step[4];
step[0] = 9;
step[1] = 5;
step[2] = 3;
step[3] = 1;
int iTemp;
int k,s,w;
for(int i=0;i<4;i++)
{
k = step[i];
s = -k;
for(int j=k;j<Count;j++)
{
iTemp = pData[j];
w = j-k;//求上step個元素的下標
if(s ==0)
{
s = -k;
s++;
pData[s] = iTemp;
}
while((iTemp<pData[w]) && (w>=0) && (w<=Count))
{
pData[w+k] = pData[w];
w = w-k;
}
pData[w+k] = iTemp;
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4,3,2,1,-10,-1};
ShellSort(data,12);
for (int i=0;i<12;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
呵呵，程序看起來有些頭疼。不過也不是很難，把s==0的塊去掉就輕松多了，這里是避免使用0
步長造成程序異常而寫的代碼。這個代碼我認為很值得一看。
這個演算法的得名是因為其發明者的名字D.L.SHELL。依照參考資料上的說法：「由於復雜的數學原因
避免使用2的冪次步長，它能降低演算法效率。」另外演算法的復雜度為n的1.2次冪。同樣因為非常復雜並
「超出本書討論范圍」的原因（我也不知道過程），我們只有結果了。

四、基於模板的通用排序：
這個程序我想就沒有分析的必要了，大家看一下就可以了。不明白可以在論壇上問。
MyData.h文件
///////////////////////////////////////////////////////
class CMyData
{
public:
CMyData(int Index,char* strData);
CMyData();
virtual ~CMyData();
int m_iIndex;
int GetDataSize(){ return m_iDataSize; };
const char* GetData(){ return m_strDatamember; };
//這里重載了操作符：
CMyData& operator =(CMyData &SrcData);
bool operator <(CMyData& data );
bool operator >(CMyData& data );
private:
char* m_strDatamember;
int m_iDataSize;
};
////////////////////////////////////////////////////////
MyData.cpp文件
////////////////////////////////////////////////////////
CMyData::CMyData():
m_iIndex(0),
m_iDataSize(0),
m_strDatamember(NULL)
{
}
CMyData::~CMyData()
{
if(m_strDatamember != NULL)
delete[] m_strDatamember;
m_strDatamember = NULL;
}
CMyData::CMyData(int Index,char* strData):
m_iIndex(Index),
m_iDataSize(0),
m_strDatamember(NULL)
{
m_iDataSize = strlen(strData);
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember,strData);
}
CMyData& CMyData::operator =(CMyData &SrcData)
{
m_iIndex = SrcData.m_iIndex;
m_iDataSize = SrcData.GetDataSize();
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember,SrcData.GetData());
return *this;
}
bool CMyData::operator <(CMyData& data )
{
return m_iIndex<data.m_iIndex;
}
bool CMyData::operator >(CMyData& data )
{
return m_iIndex>data.m_iIndex;
}
///////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//主程序部分
#include <iostream.h>
#include "MyData.h"
template <class T>
void run(T* pData,int left,int right)
{
int i,j;
T middle,iTemp;
i = left;
j = right;
//下面的比較都調用我們重載的操作符函數
middle = pData[(left+right)/2]; //求中間值
do{
while((pData[i]<middle) && (i<right))//從左掃描大於中值的數
i++;
while((pData[j]>middle) && (j>left))//從右掃描大於中值的數
j--;
if(i<=j)//找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果兩邊掃描的下標交錯，就停止（完成一次）
//當左邊部分有值(left<j)，遞歸左半邊
if(left<j)
run(pData,left,j);
//當右邊部分有值(right>i)，遞歸右半邊
if(right>i)
run(pData,i,right);
}
template <class T>
void QuickSort(T* pData,int Count)
{
run(pData,0,Count-1);
}
void main()
{
CMyData data[] = {
CMyData(8,"xulion"),
CMyData(7,"sanzoo"),
CMyData(6,"wangjun"),
CMyData(5,"VCKBASE"),
CMyData(4,"jacky2000"),
CMyData(3,"cwally"),
CMyData(2,"VCUSER"),
CMyData(1,"isdong")
};
QuickSort(data,8);
for (int i=0;i<8;i++)
cout<<data[i].m_iIndex<<" "<<data[i].GetData()<<"\n";
cout<<"\n";
}

⑶ 圖像拼接技術的圖像拼接技術分類

圖像拼接技術主要包括兩個關鍵環節即圖像配准和圖像融合。對於圖像融合部分，由於其耗時不太大，且現有的幾種主要方法效果差別也不多，所以總體來說演算法上比較成熟。而圖像配准部分是整個圖像拼接技術的核心部分，它直接關繫到圖像拼接演算法的成功率和運行速度，因此配准演算法的研究是多年來研究的重點。
目前的圖像配准演算法基本上可以分為兩類:基於頻域的方法(相位相關方法)和基於時域的方法。 基於時域的方法又可具體分為基於特徵的方法和基於區域的方法。基於特徵的方法首先找出兩幅圖像中的特徵點(如邊界點、拐點)，並確定圖像間特徵點的對應關系，然後利用這種對應關系找到兩幅圖像間的變換關系。這一類方法不直接利用圖像的灰度信息，因而對光線變化不敏感，但對特徵點對應關系的精確程度依賴很大。這一類方法採用的思想較為直觀，大部分的圖像配准演算法都可以歸為這一類。基於區域的方法是以一幅圖像重疊區域中的一塊作為模板，在另一幅圖像中搜索與此模板最相似的匹配塊，這種演算法精度較高，但計算量過大。
按照匹配演算法的具體實現又可以分為直接法和搜索法兩大類，直接法主要包括變換優化法，它首先建立兩幅待拼接圖像間的變換模型，然後採用非線性迭代最小化演算法直接計算出模型的變換參數，從而確定圖像的配准位置。該演算法效果較好，收斂速度較快，但是它要達到過程的收斂要求有較好的初始估計，如果初始估計不好，則會造成圖像拼接的失敗。搜索法主要是以一幅圖像中的某些特徵為依據，在另一幅圖像中搜索最佳配准位置，常用的有比值匹配法，塊匹配法和網格匹配法。比值匹配法是從一幅圖像的重疊區域中部分相鄰的兩列上取出部分像素，然後以它們的比值作模板，在另一幅圖像中搜索最佳匹配。這種演算法計算量較小，但精度較低;塊匹配法則是以一幅圖像重疊區域中的一塊作為模板，在另一幅圖像中搜索與此模板最相似的匹配塊，這種演算法精度較高，但計算量過大;網格匹配法減小了塊匹配法的計算量，它首先要進行粗匹配，每次水平或垂直移動一個步長，記錄最佳匹配位置，然後在此位置附近進行精確匹配，每次步長減半，然後循環此過程直至步長減為0。這種演算法較前兩種運算量都有所減小，但在實際應用中仍然偏大，而且粗匹配時如果步長取的太大，很可能會造成較大的粗匹配誤差，從而很難實現精確匹配。

⑷ 土建模板工程量怎麼計算柱，梁，板，都怎麼算求詳細點的演算法，公式…

土建模板工程量為柱，梁，板等構件量的總和。計算公式：墊層模板：S=1*4*0.1*2=0.8m2(周長 X 高 X 個數)，基礎模板：S=0.8*4*0.45*2=2.89m2（周長 X 高 X 個數）。

基礎柱模板：S=（0.4*4*0.6-0.4*0.3*2）*2=1.44m2（（周長 X 高 - 梁頭接觸部位面積）X 個數），梁模板：S=(0.3+0.4*2)*(4-0.2*2)=3.96m2（（底面 + 側面 X 2) X 梁凈長）。

在計算板底肋梁的時候，板底肋梁的模板計算高度為：梁截面高度--現澆板高度，故而出現樓主所說的同學在計算梁的模板的時候，扣除120（這個扣除的高度要看現澆板的厚度）。

著重一點：在現澆板外圍的梁模板要計算全高，比如上面的，外圍梁模板高度為0.4m，靠梁內側高度為0.4-0.12=0.28m。

(4)分塊演算法模板擴展閱讀：

建築模板是一種臨時性支護結構，按設計要求製作，使混凝土結構、構件按規定的位置、幾何尺寸成形，保持其正確位置，並承受建築模板自重及作用在其上的外部荷載，進行模板工程的目的，是保證混凝土工程質量與施工安全、加快施工進度和降低工程成本。

參考資料來源：網路-建築模板

⑸ 線性代數c++模板庫 eigen如何使用

http://blog.csdn.net/abcjennifer/article/details/7781936
正好剛在研究這個
多看看博客，仔細研究下

⑹ 大學的數學建模競賽怎麼准備

我在大二的時候就和室友一起參加過全國大學生數學建模競賽，學校里也上過這方面的專業課，可以說對此有點自己的見解和建議。下面我想分享一下自己當時做的一些准備供你參考。

首先，肯定要學習數學模型方面的知識。

數學建模，顧名思義就是建立數學模型，需要你去了解一下常用的數學模型。有些同學可能會疑問，數學還有什麼模型呢？不就是套套公式嗎。其實不然，對於國賽，最常用的莫過於概率論與數理統計了。

當然，如果你學有餘力的話，可以去學SPSS這種專業的統計軟體，或者像Visio這樣的繪圖軟體，在統計或者繪圖等方面，用起來更加方面，圖案也更加精美。

總而言之，對於大學的數學建模競賽，還是需要好好准備的，無論是數學的專業知識還是演算法的設計實現。如果能找到合適的隊友，那麼合作起來還是很輕松的，希望你能得到一個好成績！

⑺ 網路螞蟻的特點

網路螞蟻的作者洪以容1973年7月一個不是很熱的夏天出生在上海，1991年進入上海交通大學計算機系。95年畢業隨後進入上海華騰軟體有限公司，開始了自己正式的軟體開發生涯。1998年考入上海交通大學計算機系系統結構專業，目前正在攻讀研究生。在他拿到研究生錄取通知書以後的那段時間里，他嘗試開發出了現在著名的下載軟體精品--網路螞蟻。網路螞蟻獲得了巨大的成功，相繼被國內外的軟體下載站點和權威媒體評為優秀軟體，得到了廣大網民的認可和支持。

東東包第一次采訪洪以容是在去年的10月底，當時是就軟體作者之間的合作問題向洪先生詢問看法。話筒里傳過來的聲音沉穩而冷靜，一如波瀾不興的湖水。我知道那一定是一個出色的程序員不可或缺的素質，只有沉靜的性情才能在枯燥乏味的程序編寫過程中擁有擺脫外界誘惑的定力。第一次的印象浮光掠影，但是我的心裡認為他是一個對技術有著宗教般虔誠的狂熱愛好者。對於網路螞蟻的發展和升級之路我進行了足夠的關注。當另一個國產精品JETCAR(現在已經改名為Flashget)從眾多的下載軟體脫穎而出的時候，我們很多人都覺得這是一場棋逢對手的好戲。也許競爭帶給螞蟻了些許壓力，不過螞蟻的正式版還是拖到了今年的2月。正式版推出之日，東東包和夥伴們拍了拍手，大家眼神里都有著相同的看法：「終於出來了。」

螞蟻的成功為洪帶來了一筆可觀的廣告收入，還為他帶來了良好的聲譽和影響。但是出名的人往往會面對著巨大的壓力和無數挑剔的目光。於是螞蟻在成長的過程中開始要承受許多的批評和指責，尤其是網路螞蟻的中文版問題和廣告條問題，大家的批評甚至上升到了一個道德品格和民族感情的層面。面對責難，洪的心裡有著不被常人所了解的痛苦和困惑，一種難以表白的抑鬱。幸虧他的身邊還有著深愛著他，支持著他的女友，還有著一大幫熱情仗義的朋友。他咬著牙熬過了那段異常艱辛的時光。今天的他在繁重的課題研究之餘，還在做著網路螞蟻的維護工作和升級准備。他希望能把網路螞蟻做成一個國產軟體的精品，而且想把它推到國外去，讓老外也用上我們中國人做的軟體。

在逐漸的交往和了解的過程中，東東包感覺到應該把網路螞蟻的作者的另一面呈現給大家。讓大家了解到一個優秀的中國程序員的生活和思想，一些鮮為人知的小事情，一些不被人了解的酸甜苦辣，從而真正的認識而不是膚淺的臆測我們的軟體精英們，他們的一切一切。我希望大家能夠給他們多點鼓勵和支持，多點寬容和善意，多點體貼和贊美，因為他們是我們走向世界的希望。(東東包)

（下面的文字由洪以容的女友Nunu和東東包共同完成，包括了洪以容自己的故事，他和女友的故事，他和妹妹的故事，他和朋友們的故事，希望大家喜歡。當然有些事情我現在還不能寫，估計要五年之後才能寫出來。：））

網路螞蟻的成長過程其實也是網路螞蟻作者洪以容個人的一個成長過程。在寫網路螞蟻之前洪以容在同事們的眼裡只是一個比較高手的程序員，在父母眼裡只是一個對計算機痴迷的兒子，如果不是在那一霎那他想到了多點續傳的點子，如果不是他的好朋友婉拒了替他把這個主意寫成代碼（我先要說一句，他之所以想讓別人寫這個程序，是因為他比較「懶」，這是洪以容的一個鮮明的特點，在接下來的事情中很多對網路螞蟻的意見都取決於它的這個特點），如果不是他正好在家裡等著考研的結果，那也許到現在他也還是老樣子。但是這三個條件都成立了，於是中國最好的下載軟體 = 網路螞蟻 = 洪以容這個等式就誕生了。

98年6月份第一個測試版本的網路螞蟻出現在電腦之家的下載區。由於它的短小精悍和快速的下載功能，很快就在網路中散布開來。很快洪以容收到第一個用戶的來信，於是從此開始了漫漫的升級之路。每天n次撥號，收email，回信，找bug，增加新功能，這些事情幾乎成了他每天的工作。他的潛意識當中意識到他的新的一種生活方式到了，和以前的截然不同的一種生活。一個偉人曾經說過：站在巨人的肩上才能看得更遠，他正是站在了Internet這個巨人的肩上才看到了那片天地。可是不懂電腦的父母難以理解兒子一天十幾個小時坐在電腦前面，父母希望兒子能像別人家的孩子一樣到社會上去為生活打拚，而不是夜以繼日的和電腦相處。得不到理解的洪以容也很苦悶，因為這個時候網路螞蟻也已經到了一個沒有什麼突破的地步，每天的用戶來信越來越多，問的問題也大多數很簡單，為了負責，他不得不化很多時間去回答用戶的問題，而在開發方面，也只能對螞蟻增加一些小的功能，修改一些小的bug。 顯然這個時候的洪以容需要一些新的動力。

於是這個時候他的生命中出現了兩個轉折。

第一個轉折當然就是我的出現。我，一個小小的女網蟲，我們認識了，我們走到一起了。我也是一個程序員，所以有的時候還能提出一些很不錯的建議，不過我最重要的功能就是可以幫他回信。網路螞蟻的發展可以從我回信的這個側面看出。剛開始的時候也就是98年12月份開始每天大概有十幾封信，到99年年底，每天就要回四五十封，到2000年2月份網路螞蟻1.0正式版推出的第一天， 回了100多封email,以後大概就保持在七十幾封，這里我還要感謝Becky的作者（不管他是否看得到），他的email程序有模板的功能，我針對大多數用戶都會提到的問題作了很多的模板，這就大大節省了我的回信時間。每次我們見面的時候，總是要討論螞蟻。可以增加一些什麼功能啊，那些地方操作不方便啊。有一次我們在一起看Getright有什麼新功能，見到它的readme裡面的一段話：感謝為我錄制聲音的我的妹妹。我們聽了一下，發現在增加任務，任務完成，出錯的時候，都會出現一個小女孩的聲音提示。我們都覺得這個功能很有趣，就決定自己也做一個，由我來讀。翻箱倒櫃的找出那個劣質的麥克風，然後錄了「File added」「job compete」「something wrong」這三句話，簡簡單單的三句話，我們幾乎錄了一個小時，他總說我的發音不標准，為了滿足他的要求，只能一遍遍重復，就象歌手在錄音棚里遇到一個苛刻的製作人一樣，等總算pass以後，我發覺我忘了中文怎麼說了。：-）洪以容把這個功能加到新版本中去了，第一個版本很平靜的過去了，沒發生什麼問題。第二個版本中他增加了批量下載的功能，就是按照一定規律一下子可以增加幾百個任務的功能。這下問題來了，他寫完代碼，然後讓我做測試，我在我的電腦上試了一下，就覺得速度奇慢，好幾分鍾以後才全部加入任務。我馬上向洪以容報告，他找了半天也沒有發覺問題在哪裡。後來只能歸咎於我的機器有問題。新版本發布了，問題卻馬上找到了，原來是開啟了聲音提示的功能，就是說每加入一個功能，我的聲音「file added」就播放一邊，幾百個任務就會播放幾百遍，能不慢嗎？而我電腦上的喇叭關著，所以沒有發覺問題。我們知道緣由，大笑之後，洪以容馬上就進行了修改。

因為洪以容在讀研究生，而我的工資也不高，所以我們的開銷一向比較節省的。去年情人節，他只送了一塊幾塊錢的巧克力，由此可見，我們的物質生活多麼清平。：-（ 我們第一筆通過網路螞蟻的收入是一個公司要出一張光碟，其中收錄了網路螞蟻，這個公司就象徵性的付了2000元作為回報。我們都開心的不得了，還列了一個計劃怎麼去花這些錢，而我們的計劃中包括了我們所有的親人，他的父母妹妹，我的父母，於是每個人都得到了一件小小的禮物，這總算也是讓他們知道了洪以容和我工作的一點價值把。但是錢很快就用完了，我們面臨著新的問題，每個月高額的電話費和上網費。上海的ISP的速度之慢，還有收費之高是世人所皆知的問題。網路螞蟻的開發過程中需要上網調試，才能找到問題所在，而且還需要到國外專門的站點去找技術資料，於是洪以容就想到了一個生財之道，仿照其他下載軟體，在界面上放一個廣告。這種做法遭到了很多網友的反對，有的乾脆寫信來問我們怎麼破解這個廣告條，於是我就告訴了他們我們的苦衷，還問他們如果他們了解我們處境以後還是想知道破解的辦法，請再給我來信，我會告訴他們的。收到我的回信後，大多數網友都對我們的做法表示了理解。於是我們有了一筆固定的收入。第一筆的錢用於了網路螞蟻的網站的建設，包括域名的注冊，虛擬主機的租借，頁面的製作。這就是大家現在看到的網路螞蟻的那個網站。

在我眼中，洪以容是一個不折不扣的程序員，他對技術的追求幾乎到了痴迷的程度，他的機器上裝滿了各種下載軟體，每個軟體的主要特色和實現方法他都了如指掌。他對自己寫的程序的要求幾乎是苛刻的，用幾個小時或者幾天寫的程序只要稍微有些瑕疵，都會被他毫不留情的delete,他也會花很長時間用滑鼠慢慢的點出一個符合他要求的小圖標出來，只為了讓他的程序看上去更精緻、更專業。他對於Go!zilla的那套特製的圖標簡直到了垂涎的地步。幸好，他身邊還有一個小助手，他的妹妹，他妹妹是一個美術編輯，大家看到螞蟻的那個Icon了嗎？這就是他妹妹的傑作，也是用滑鼠慢慢點出來的。不過也真難為了他妹妹，從來都是用筆繪的她硬是在洪以容的威逼利誘之下，點出了一個小螞蟻。有個用戶來信，說道：現在下載軟體很多，多點續傳已經不再是網路螞蟻的特色了，而且其它軟體的下載文件管理，搶帶寬能力都超過了網路螞蟻。而他之所以還一直使用網路螞蟻，就是覺得這個程序非常專業，每個細微之處都想的非常周到。關於這點洪以容自己也說過：我寫的程序一般不會出什麼大的錯誤，我考慮一個問題會想的非常全面。的確是這樣的，當他想到要增加一個新功能，就會先化上很多時間把所有的改動，各方面要注意到的事情都在腦子里仔細想清楚，然後才會動手去做。就因為這樣，網路螞蟻遇上了誕生以來的第一件麻煩的事情。

這當然就是關於中文版的事情。洪以容其實是一個對自己的技術水平很驕傲的人，他覺得自己的程序完全可以和國外的一些知名的下載軟體相比。而且他非常不能理解現在很多軟體動不動就打著國產軟體的牌子到處招搖這種情況,要用就要用好的軟體，在這點上國產軟體應該和國外的軟體是平等的。 他希望用戶是真的覺得他的軟體好才使用的，而不僅僅因為寫軟體的作者是中國人。抱著這個思想，網路螞蟻推出第一個版本的時候就是全英文的界面，當時很多用戶也沒有意識到這是個國產軟體，所以也沒什麼事情發生。可是電腦報第一次采訪了洪以容，第一次讓大家知道網路螞蟻其實是中國人的作品。於是事情就復雜了。一篇名為「別了，假洋鬼子」在網友中迅速傳播著。文章中猛烈的批評網路螞蟻採用全英文界面的現象。我記得很多熱心的網友把這篇文章寄來，我看了以後覺得很氣憤，洪以容為了寫網路螞蟻犧牲了那麼多，付出了那麼多，幾乎每天他都要為網路螞蟻作一些事情，不是改錯誤就是加功能。而且當時這個軟體是完全免費的。作了那麼多事情，還要被別人罵，我實在想不通，可是我把這件事情告訴洪以容以後，他卻笑著說：「沒什麼啊，會提出這樣的問題很正常，但是不能說我不愛國，英文界面和愛不愛國完全沒有關系，要是說我懶，這點我倒是承認的。我寫程序的時候採用的是單位元組的處理方式，要改成雙位元組的，需要對程序作很大的修改。而且很大程度上是工作量的事情，不是技術上的，我還有很多新的功能沒有做，所以一直懶的去做中文版。」後來雖然洪以容和那篇文章的作者取得了聯系，並達成了共識，但是網路上這個問題還是鬧得沸沸揚揚的。

這個時候，第二個轉折點出現了，就是洪以容的朋友們：歪歪，關子等。歪歪是原電腦報軟體版的主編，是電腦報采訪洪以容的時候認識他的。兩個都想為中國軟體業做些事情的人，一聯繫上就成了好朋友。歪歪聽說了這件事情，馬上寫了一篇文章幫洪以容澄清這個問題，而中國漢化同盟的關子也馬上替洪以容做了中文版本。兩個朋友一起替洪以容過了這關。其實在整個螞蟻的成長過程中很多熱心的網友也提供了很多的幫助，以前網路螞蟻的網頁就是一個網友川川替我們免費做的，日常的維護也都是他來完成的。還有一個網友建立了一個網路螞蟻收藏館（http://dzc.126.com），收藏了螞蟻發布以來的所有版本，大家有空可以去光顧一下。有一個網友經常寫信來提一些非常實用的建議，報告一些問題，我們一直以為是一個計算機水平很高的年輕人，就想和他聯系一下，他來信告訴了電話，還說一般白天晚上都在家的，我們覺得很奇怪，打了電話過去，原來是一個已經退休的老者，怪不得總是在家呢。這位博學的老者幫了我們很多的忙，網路螞蟻詳細的幫助手冊就是他製作的。

網路螞蟻的發展並不是一帆風順的，有些困難在我的幫助在朋友們的幫助下，就克服過去了，可是有些困難就一定要洪以容自己來面對了。其中最明顯的例子就是網路螞蟻的競爭對手FlashGet的出現。作為一個可以採用更多線程數、全中文的界面、方便的文件管理系統的下載軟體，他一出現就給網路螞蟻帶來了很大的威脅，因為他幾乎繼承並發揚了網路螞蟻所有的優點，而補充了網路螞蟻最大的缺點。面臨這樣的局面，我們都幫不上忙了，只能看洪以容了。還好這個時候他還是有很強的自信，他說：這個軟體的出現很正常，現在的世界就需要競爭，看著吧，我的網路螞蟻才不會落後呢。從此這兩個作者就暗暗的較上了勁，你出個新版本我也出一個，你加了一個新功能我也要加上，你沒有的功能我也要加上，於是在競爭中這兩個軟體就一起變得成熟起來。這時候，洪以容又開始不滿足了，現在不是流行強強聯手嗎？互聯網的另一個精神不就是合作嗎？所以他找到了Flashget的作者，兩個作者一拍即合，想共同探索一條中國共享軟體作者的合作之路出來。具體的結果如何？只能告訴大家一句話：預知後事如何，且聽下回分解。

現在洪以容最大的心願就是把網路螞蟻重新寫一遍，因為第一次寫的時候沒有經驗，很多問題都沒有考慮到，現在也很難修改， 最關鍵的地方是想重新寫一個更加完善穩定的下載API，採用更加高效的分塊演算法，總之是為將來的升級發展打下堅實的基礎。另外是要實現與第三方軟體的介面，使得其他軟體可以向網路螞蟻加入新任務，獲得下載任務的動態信息等。等這個時候，網路螞蟻就真的可以超越國外的下載軟體，從而走出國門，走向世界。