1、大律法
                      大津法又称最大类间方差法。对图像，记t为前景与背景的分割阈值，前景点数占图像比例为 w0， 平均灰度为u0；背景点数占图像比例为w1，平均灰度为u1。图像的总平均灰度为：u=w0*u0+w1*u1。从最小灰度值到最大灰度值遍历t，        当t使 得值      g=w0*(u0-u)2 +w1*(u1-u)2 最大时t即为分割的最佳阈值。阈值t分割出的前景和背景两部分构成了整幅图像，而前景取值u0，概率为w0，背景取值u1，概率为w1，总均值为u，根据
 方差的定义即得该式。因方差是灰度分布均匀性的一种度量，方差值越大，说明构成图像的两部分差别越大，当部分目标错分为背景或部分背景错分为目标都会导致 两部分差别变小，因此使类间方差最大的分割意味着错分概率最小。直接应用大津法计算量较大，因此我们在实现时采用了等价的公式g=w0*w1*(u0- u1)2 。
实现的代码：
               BOOL OSTUThreshold(unsigned char *image1,   LONG   lWidth,   LONG   lHeight)   

 {
int a;
//得到灰度直方图，灰度的最大值和最小值
int i,j,t;
long lCount[256];                //各个灰度值的计数
int lMaxgrayvalue=0;
int lMingrayvalue=255;
int lThreshold; //阈值
long lLineBytes; //图像每行的字节数
lLineBytes=WIDTHBYTES(lWidth);
for(a=0;a<256;a++)
{ 
lCount[a]=0;
}
for(i=0;i<lHeight;i++)
{
for(j=0;j<lWidth;j++)
{
    //各个灰度值的计数
lCount[image1[i*lLineBytes+j]]++;
}
}
for(i=0;i<256;i++)
{
if (lCount[i]!=0)
{
lMingrayvalue=i;
break;
} 
}
for(i=255;i>=0;i--)
{
if(lCount[i]!=0)
{
lMaxgrayvalue=i;
break;
}
}


       //通过所有的灰度值找到阈值
float lMeangrayvalue1,lMeangrayvalue2;     //两个区域的平均灰度值
float w1,w2;       //前后两区灰度的百分比
float G;    //方差
float tempG=0;
int lP1,lP2,lS1,lS2;    //前景，后景点数
for(t=lMingrayvalue;t<=lMaxgrayvalue;t++)
{
lP1=0;
lP2=0;
lS1=0;
lS2=0;
for(a=lMingrayvalue;a<=t;a++)
{
lP1+=lCount[a]*a;
lS1+=lCount[a];
}
lMeangrayvalue1=(float) lP1/lS1;
w1=(float) lS1/(lHeight*lWidth);
for(a=t;a<lMaxgrayvalue;a++)
{
lP2+=lCount[a]*a;
lS2+=lCount[a];
}

      lMeangrayvalue2=(float) lP2/lS2;
w2=1-w1;
G=w1*w2*(lMeangrayvalue1-lMeangrayvalue2)*(lMeangrayvalue1-lMeangrayvalue2);
if(G>tempG)
{
tempG=G;
lThreshold=t;
}
}
for(i=0;i<lHeight;i++)
{
for (j=0;j<lWidth;j++)
{
if (image1[i*lLineBytes+j]>lThreshold)
{
image1[i*lLineBytes+j]=255;
}
else
{
image1[i*lLineBytes+j]=0;
}
}
}
return TRUE;

 }


2、迭代法
     
(1)．  求出图象的最大灰度值和最小灰度值，分别记为Zl和Zk，令初始阈值为：
                               

    (2)．  根据阈值TK将图象分割为前景和背景，分别求出两者的平均灰度值Z0和ZB:
                                     
                                     


          式中，Z(i,j）是图像上(i,j)点的象素值，N(i,j)是(i,j)点的权值，一般取1。
(3)
                               

    (4)．  若TK=TK+1，则所得即为阈值，否则转2，迭代计算。
实现代码：
                 BOOL OSTUThreshold(unsigned char *image1,   LONG   lWidth,   LONG   lHeight)   

 {
int a;
//得到灰度直方图，灰度的最大值和最小值
int i,j,t;
long lCount[256];                //各个灰度值的计数
int lMaxgrayvalue=0;
int lMingrayvalue=255;
int lThreshold; //阈值
long lLineBytes; //图像每行的字节数
lLineBytes=WIDTHBYTES(lWidth);
for(a=0;a<256;a++)
{ 
lCount[a]=0;
}
for(i=0;i<lHeight;i++)
{
for(j=0;j<lWidth;j++)
{
    //各个灰度值的计数
lCount[image1[i*lLineBytes+j]]++;
}
}
for(i=0;i<256;i++)
{
if (lCount[i]!=0)
{
lMingrayvalue=i;
break;
} 
}
for(i=255;i>=0;i--)
{
if(lCount[i]!=0)
{
lMaxgrayvalue=i;
break;
}
}


       //通过所有的灰度值找到阈值
float lMeangrayvalue1,lMeangrayvalue2;     //两个区域的平均灰度值
float w1,w2;       //前后两区灰度的百分比
float G;    //方差
float tempG=0;
int lP1,lP2,lS1,lS2;    //前景，后景点数
for(t=lMingrayvalue;t<=lMaxgrayvalue;t++)
{
lP1=0;
lP2=0;
lS1=0;
lS2=0;
for(a=lMingrayvalue;a<=t;a++)
{
lP1+=lCount[a]*a;
lS1+=lCount[a];
}
lMeangrayvalue1=(float) lP1/lS1;
w1=(float) lS1/(lHeight*lWidth);
for(a=t;a<lMaxgrayvalue;a++)
{
lP2+=lCount[a]*a;
lS2+=lCount[a];
}

      lMeangrayvalue2=(float) lP2/lS2;
w2=1-w1;
G=w1*w2*(lMeangrayvalue1-lMeangrayvalue2)*(lMeangrayvalue1-lMeangrayvalue2);
if(G>tempG)
{
tempG=G;
lThreshold=t;
}
}
for(i=0;i<lHeight;i++)
{
for (j=0;j<lWidth;j++)
{
if (image1[i*lLineBytes+j]>lThreshold)
{
image1[i*lLineBytes+j]=255;
}
else
{
image1[i*lLineBytes+j]=0;
}
}
}
return TRUE;

 }


未完待续。。。。。

//二分查找总结：由于本人二分常年写成死循环
/*
简介：二分查找 == 折半查找
要求：线性表，有序表（注意升序与降序）
思想：
	设查找区间[L,R]
	取中点 mid = （L+R）/2
	判定mid是否符合要求：（如何判断：bool check(int mid); ）
		是：缩短区间求边界；直接返回；
		否：缩短区间
	最终结果val = R 或者val = L；
*/

//典型线性表查找数据
int er_search(int a[],int n, int key)
{
	const int inf = 0x3f3f3f3f;
	
	int L=0,R=n;
	while(L<R){
		int mid = (L+R)/2;
		if(key==a[mid]){
			return mid;
		}
		else if(key<a[mid]){
			R=mid-1;
		}
		else if(k>a[mid]){
			L=mid+1;
		}
	}
	return inf;
} 
//CSDN某博客对二分的64种分类
/*
*取整方式
	向下取整(最小值) 向上取整（最大值）
	
*区间开闭
	闭区间 左闭右开区间 左开右闭区间 开区间
	
*问题类型
	单增
	对于不下降序列a，求最小的i，使得a[i] = key 
	对于不下降序列a，求最大的i，使得a[i] = key 
	对于不下降序列a，求最小的i，使得a[i] > key 
	对于不下降序列a，求最大的i，使得a[i] < key 
	单减
	对于不上升序列a，求最小的i，使得a[i] = key 
	对于不上升序列a，求最大的i，使得a[i] = key 
	对于不上升序列a，求最小的i，使得a[i] < key 
	对于不上升序列a，求最大的i，使得a[i] > key
*/

//下面四个不下降的例子
//a[] = 1 2 3 4 5 6 6 6 7 9 
//min i,a[i] = key;  =>a[5]
    while(s < e){
        mid = (e+s)/2;// 向下取整
        if(key <= a[mid])
            e = mid;
        else
            s = mid + 1;
    }

//max i,a[i] = key =>a[7]
    while(s < e){
        mid = (e+s+1)/2;// 向上取整
        if(key >= a[mid])
            s = mid;
        else
            e = mid - 1;
    }

//min i, a[i] > key =>=>a[8]
    while(s < e){
        mid = (e+s)/2;//向下取整
        if(key < a[mid])
            e = mid;
        else
            s = mid + 1;
    }

// max i, a[i] < key =>a[4]
    while(s < e){
        mid = (e+s+1)/2;//向上取整
        if(key > a[mid])
            s = mid;
        else
            e = mid - 1;
    }

/*巧记，但不是完全正确
	循环：L<R 
	求mid时：求max :L+R+1  求min: L+R;
	if():真实值与猜测值的关系作为条件：max-真实大于猜测 min-真实小于猜测
	防死循环：调整if下的L或者R 另一个边界在else下注意+-1;
	
	总结：循环L<R mid注意1 else下防死循环
*/
//另一种简单分类:第一个大于v，第一个大于等于v，最后一个小于v，最后一个小于等于v
/*内容来自：http://www.cnblogs.com/xiaowuga/p/8604750.html
	第一个大于等于v:
		lower_bound(ForwardIterator first, ForwardIterator last,const T& val, Compare comp)
		
		我们假设L为当前区间的答案，R为当前区间的实际答案（因为R是第一个大于等于v的下标），
		我们每次二分的实际上是为了让L和R不断靠近，
		所以当L==R的时候，我们假设的答案等于实际的答案，那么就结束循环了，返回答案L。
		while(L<R){
            int M=(L+R)/2;
            if(a[M]>=v) R=M;//R是第一个大于等于v下标，那么R最大只能是m
            else L=M+1;//[M,R)区间内的下标都是小于v的，L作为最后的答案最小只能是M+1
        }
	
	第一个大于v:
		upper_bound(ForwardIterator first, ForwardIterator last,const T& val, Compare comp);
        
		我们假设L为当前区间的答案，R为当前区间的实际答案（因为R是第一个大于v的下标），
		我们每次二分的实际上是为了让L和R不断靠近，
		所以当L==R的时候，我们假设的答案等于实际的答案，那么就结束循环了，返回答案L。
		while(L<R){
            int M=(L+R)/2;
            if(a[M]>v) R=M;//R是第一个大于v下标，那么R最大只能是M
            else L=M+1;//[M,R)区间内的下标都是小于等于v的，L作为最后的答案最小只能是M+1
        }
			
	最后一个小于等于v	
	
		我们假设R为当前区间的答案，L为当前区间的实际答案（因为L是最后一个小于等于v的下标），
		我们每次二分的实际上是为了让L和R不断靠近，
		所以当L==R的时候，我们假设的答案等于实际的答案，那么就结束循环了，返回答案L。
		while(L<R){
            int M=(L+R+1)/2;
            if(a[M]<=v) L=M;//L是最后一个小于等于v下标，那么L最小只能是M。
            else R=M-1;//(L,M]区间内的下标都是大于v的，R作为最后的答案最大只能是M-1。
        }
			
	最后一个小于v
	
		我们假设R为当前区间的答案，L为当前区间的实际答案（因为L是最后一个小于v的下标），
		我们每次二分的实际上是为了让L和R不断靠近，
		所以当L==R的时候，我们假设的答案等于实际的答案，那么就结束循环了，返回答案L。
		while(L<R){
            int M=(L+R+1)/2;
            if(a[M]<v) L=M;//L是最后一个小于v下标，那么L最小只能是M。
            else R=M-1;//(L,M]区间内的下标都是大于等于v的，R作为最后的答案最大只能是M-1。
        }		
*/

//二分条件搜索的应用：最大化最小值，最小化最大值，最大化平均值
/*最大化最小值
	边界属性： 	正确答案ans
				满足条件但不是最大：ans-1
				不满足条件：ans+1
				
				二分类型：最后一个满足条件的ans值
					思路：	把条件看成具体的值
							求最后一个小于等于v
*/
/* 最小化最大值
	边界属性： 	正确答案ans
				满足条件但不是最小：ans+1
				不满足条件：ans-1		

				二分类型：第一个满足条件的值
					思路：	把条件看成具体的值
							求第一个大于等于v
*/	

/*最大化平均值：
模型构建：
有n个物品，每个物品分别对应一个重量w和价值v。要求选出k个，使得平均每单位重量的价值最大。

二分模型：搜索满足条件check(mid)的最大解
check()模型：
构建过程：
	单个物品:
		平均价值：v/w
		判断这个物品是否被挑选（是否满足单位价值mid） v/w>=mid
			化简得 v-wx>=0; 可记录c[i] = v-wx(第i个)
	多个物品：
		循环所有物品
		
	k个物品
		求和c[0]--c[k-1]
		如果这个和大于零，说明总体的平均值大于mid
	
模型：二分查找最大化平均值
int n;数据组数
int k;要求件数
bool check(double mid){
	
	c[i] = v[i]-mid*w[i];
	
	sort(c,c+n,cmp);//逆序
	
	double sum=0;
	sum+=c[0] ---c[k-1]
	
	return sum>=0;//sum = 0时候是正好满足条件
}

*/		

 

                    
$\sed{C_n^k}_{k=0}^n$ 而二项式系数, $A_n,G_n$ 分别表示它们的算术平均值与几何平均值. 试证: $$\bex \vlm{n}\sqrt[n]{A_n}=2,\quad \vlm{n}\sqrt[n]{G_n}=\sqrt{e}. \eex$$
 
证明: $$\bex A_n=\frac{C_n^0+C_n^1+\cdots+C_n^n}{n+1}=\frac{2^n}{n+1}\ra \vlm{n}\sqrt[n]{A_n}=2. \eex$$ $$\bex G_n=\sqrt[n+1]{C_n^0C_n^1\cdots C_n^n}\ra \sqrt[n]{G_n}=(C_n^0C_n^1\cdots C_n^n)^\frac{1}{n(n+1)}, \eex$$ $$\beex \bea \vlm{n}\sqrt[n]{G_n}&=\exp\sez{\vlm{n} \frac{\sum_{k=0}^n \ln C_n^k}{n(n+1)}}\\ &=\exp\sez{ \frac{\sum_{k=0}^{n+1} \ln C_{n+1}^k -\sum_{k=0}^n \ln C_n^k}{(n+1)(n+2)-n(n+1) }}\\ &=\exp\sez{ \ln \frac{\sum_{k=0}^n \ln \frac{n+1}{n+1-k}}{2(n+1)} }\quad\sex{C_{n+1}^k /C_n^k=\frac{n+1}{n+1-k}}\\ &=\exp\sez{ \frac{1}{2}\vlm{n} \sex{ \sum_{k=0}^{n+1}\ln \frac{n+2}{n+2-k} -\sum_{k=0}^n \ln \frac{n+1}{n+1-k} } }\\ &=\exp\sed{ \frac{1}{2} \vlm{n}\sez{\ln (n+2)+\sum_{k=0}^n \ln\sex{\frac{n+2}{n+2-k}\cdot \frac{n+1-k}{n+1}} }}\\ &=\exp\sed{\frac{1}{2}\vlm{n} \sez{\ln(n+2)+\ln \frac{(n+2)^{n+1}(n+1)!}{(n+2)!(n+1)^{n+1}}}}\\ &=\exp\sed{\frac{1}{2}\vlm{n}\ln \sez{\sex{1+\frac{1}{n+1}}^{n+1}}}\\ &=\sqrt{e}. \eea \eeex$$

        
        
                
    

                    
若 $u_1,u_2,\cdots,u_n\geq 0$, $u_1\cdot u_2\cdots u_n=1$, 则有 $u_1+u_2+\cdots+u_n\geq n$. 试证明这一结论, 并由它导出定理 3 (平均值定理).
证明: H\"older 不等式很容易推广为 $$\bex \sum_{i=1}^n \frac{1}{p_i}=1,\quad 1<p_i<\infty,\ a_i>0\ra \prod_{i=1}^n a_i\leq \sum_{i=1}^n \frac{a_i^{p_i}}{p_i}, \eex$$ 而 $$\bex 1=u_1^\frac{1}{n}\cdots u_n^\frac{1}{n}\leq \frac{1}{n}u_1+\cdots+\frac{1}{n}u_n. \eex$$ 也就有平均值定理了.