av不卡在线播放,欧美日韩综合一区,蝌蚪视频在线播放

求两个数或多个数的最大公�U�数��法及其实现

Sat, 15 Dec 2007 07:40:00 GMT

一�Q�两个数的最大公�U�数�Q?br />
1、欧几里��L��?

�Ƨ几里�d��法又称辗�{盔R��法，用于计算两个整数a,b的最大公�U�数。其计算原理依赖于下面的定理�Q?

定理�Q�gcd(a,b) = gcd(b,a mod b)

证明�Q�a可以表示成a = kb + r�Q�则r = a mod b
假设d是a,b的一个公�U�数�Q�则�?
d|a, d|b�Q�而r = a - kb�Q�因此d|r
因此d�?b,a mod b)的公�U�数

假设d �?b,a mod b)的公�U�数�Q�则
d | b , d |r �Q�但是a = kb +r
因此d也是(a,b)的公�U�数

因此(a,b)�?b,a mod b)的公�U�数是一��L��Q�其最大公�U�数也必然相�{�，得证

�Ƨ几里�d��法��是�Ҏ��q�个原理来做的，其算法用C++语言描述为：

void swap(int & a, int & b){ int c = a; a = b; b = c; } int gcd(int a,int b){ if(0 == a ){ return b; } if( 0 == b){ return a; } if(a > b){ swap(a,b); } int c; for(c = a % b ; c > 0 ; c = a % b){ a = b; b = c; } return b; }

2、Stein��法
�Ƨ几里�d��法是计��两个数最大公�U�数的传�l�算法，它无��Z��理论�q�是从效率上都是很好的。但是有一个致命的�~�陷�Q�这个缺陷只有在大素数时才会昄��出来�?

考虑现在的硬件��^収ͼ�一般整数最多也��是64位，对于�q�样的整敎ͼ�计算两个��C��间的模是很简单的。对于字长�ؓ32位的�q�_��Q�计��两个不��过32位的整数�? 模，只需要一个指令周期，而计��?4位以下的整数模，也不�q�几个周期而已。但是对于更大的素数�Q�这��L��计算�q�程��׃��得不��q��h��设计�Q��ؓ了计��两个超�q? 64位的整数的模�Q�用户也�怸�得不采用�c�M��于多位数除法手算�q�程中的试商法，�q�个�q�程不但复杂�Q�而且消耗了很多CPU旉��。对于现代密码算法，要求计算 128位以上的素数的情冉|��比皆是，设计�q�样的程序迫切希望能够抛弃除法和取模�?

Stein��法由J. Stein 1961�q�提出，�q�个�Ҏ��也是计算两个数的最大公�U�数。和�Ƨ几里�d��法 ��法不同的是�Q�Stein��法只有整数的移位和加减法，�q�对于程序设计者是一个福韟�?

��Z��说明Stein��法的正��性，首先必须注意��C��下结论：

gcd(a,a) = a�Q�也��是一个数和它自��n的公�U�数是其自��n
gcd(ka,kb) = k gcd(a,b)�Q�也��是最大公�U�数�q�算和倍乘�q�算可以交换�Q�特�D�的�Q�当k=2�Ӟ��说明两个偶数的最大公�U�数必然能被2整除

C++/java 实现
// c++/java stein ��法 int gcd(int a,int b){ if(a<b){//arrange so that a>b int temp = a; a = b; b=temp; } if(0==b)//the base case return a; if(a%2==0 && b%2 ==0)//a and b are even return 2*gcd(a/2,b/2); if ( a%2 == 0)// only a is even return gcd(a/2,b); if ( b%2==0 )// only b is even return gcd(a,b/2); return gcd((a+b)/2,(a-b)/2);// a and b are odd }


二，多个数的最大公�U�数�Q?python实现�Q�取出数�l�a中最���的�Q�从2到最���的循环�Q�找出其中最大的能被数组中所有数整除的那个数�Q�就是最大公�U�数)

def gcd(a):

    a.sort()

    min = a[0]

    result = 1

    for i in range(2, min+1):

        flag = True

        for j in a:

            if j % i != 0:

                flag = False

        if flag == True:

            result = i

    return result



保尔�?/a> 2007-12-15 15:40 发表评论



Fri, 16 Nov 2007 10:07:00 GMT
Catalan敎ͼ�(for http://acm.pku.edu.cn/JudgeOnline/problem?id=2084)



C_n =
ΣC_i*C_(n-i)�Q�其�?≤i
C_n = C(2n,n) / (n+1)�Q?其中C(2n, n) 表示�l�合敎ͼ�公式为：C(n, k) = n! / (k!(n-k)!)

C_n=C_(n-1)*(4n-2)/(n+1)�?br />


它的意义有很多，例如�Q�n+1边�Ş用对角线划分�?
三角形的�Ҏ��敎ͼ�n�?1和n�?1满��所有部分和不小于零的排列数�Q�具有n个节点的二叉树的数量……



�Q�详�l�说明参考：http://hi.baidu.com/kikoqiu/blog/item/81d792015ab13e01738da51d.html�Q?br />


保尔�?/a> 2007-11-16 18:07 发表评论


Tue, 06 Mar 2007 09:17:00 GMT

		
				
				
				/**/
				
						/*
						
								

								 * 题目�Q?br /> * �~�写一个截取字�W�串的函敎ͼ�输入��Z��个字�W�串和字节数�Q�输��Zؓ按字节截取的字符丌Ӏ� 但是要保证汉字不被截半个，如“我ABC�?�Q�应该截为“我AB”，输入“我ABC汉DEF”，6�Q�应该输��Zؓ“我ABC”而不是“我ABC+汉的半个”。�?br /> * 
 * 解释�Q?br /> * 此处的编码方式应该是操作�pȝ��默认的GB�~�码�Q�即汉字�?个字节且�W�一个字节的最高位�?�Q?br /> * 如果理解为有�W�号数的话，���是负数�Q�而英文占1个字节，�W�合ASC2码�?br /> 
						*/
				
				
						

						
				
				class
				 SplitString 

				
						
				
				
						{
 
						private
						 String str;
 
						private
						 
						int
						 byteNum;

 
						public
						 SplitString()
						
								
						
						
								{}
						
						
								

								
								

								 
						public
						 SplitString(String str,
						int
						 byteNum)
 
						
								
						
						
								{
  
								this
								.str
								=
								str;
  
								this
								.byteNum
								=
								byteNum;

 }
						
						
								

								 
 
						public
						 
						void
						 splitIt()
 
						
								
						
						
								{

  
								byte
								 bt[]
								=
								str.getBytes();
  System.out.println(
								"
								Length of this String ===>
								"
								+
								bt.length);
  
								if
								(byteNum
								>=
								1
								)
  
								
										
								
								
										{
   
										if
										(bt[byteNum]
										<
										0
										)
   
										
												
										
										
												{
    String substrx
												=
												new
												 String(bt,
												0
												,
												--
												byteNum);
    System.out.println(substrx);
   }
										
										else
										
												

												
												   
										
												
										
										
												{
    String substrex
												=
												new
												 String(bt,
												0
												,byteNum);
    System.out.println(substrex);
   }
										
										
												

												  }
								
								else
								
										

										
										  
								
										
								
								
										{ 
   System.out.println(
										"
										输入错误�Q�！�Q�请输入大于零的整数�Q?/span>
										"
										);
  }
								
								
										

										 }
						
						
								

								}
				
				
						

						
						

						
				
				public
				 
				class
				 TestSplitString

				
						
				
				
						{
 
						public
						 
						static
						 
						void
						 main(String args[])
 
						
								
						
						
								{
  String str
								=
								"
								我ABC汉DEF
								"
								;
  
								int
								 num
								=
								6
								;
  SplitString sptstr 
								=
								 
								new
								 SplitString(str,num);
  sptstr.splitIt();
 }
						
						
								

								}
				
		


保尔�?/a> 2007-03-06 17:17 发表评论


Mon, 05 Mar 2007 07:50:00 GMT

		
				
				
				/**/
				
						/*
						
								

								 求两个字�W�串的最大公共子�?br /> String s1 = "abcdefghigj";
 String s2 = "xyzabcdeigj";
 则输出abcde

						*/
				
				 

				public
				 
				class
				 Test

				
						
				
				
						{
  
						public
						 String search(String s1,String s2)
  
						
								
						
						
								{
  String max 
								=
								 
								""
								;
  
								for
								(
								int
								 i 
								=
								 
								0
								; i 
								<
								 s1.length(); i
								++
								)
  
								
										
								
								
										{
    
										for
										(
										int
										 j 
										=
										 i
										+
										1
										; j 
										<=
										 s1.length(); j
										++
										)
    
										
												
										
										
												{
      String sub 
												=
												 s1.substring(i,j);
      
												if
												((s2.indexOf(sub)
												!=
												 
												-
												1
												)
												&&
												 sub.length() 
												>
												 max.length())
      
												
														
												
												
														{
        max 
														=
														 sub;
      }
												
												
														

														    }
										
										
												

												  }
								
								  
  
								return
								 max;
  }
						
						
								

								  
  
						public
						 
						static
						 
						void
						 main(String[] args)
  
						
								
						
						
								{
    String s1 
								=
								 
								"
								abedafghigj
								"
								;
    String s2 
								=
								 
								"
								xyzabfddfigj
								"
								;
    String output 
								=
								 
								new
								 Test().search(s1,s2);
    System.out.println(output);
  }
						
						
								

								}
				
		


保尔�?/a> 2007-03-05 15:50 发表评论


Mon, 05 Mar 2007 07:29:00 GMT

		1 术语定义
		在字�W�串匚w��问题中，我们期待察看串T中是否含有串P�?br />其中串T被称为目标串�Q�串S被称为模式串�?/p>
		
2 朴素匚w�����法
		�q�行字符串匹配，最���单的一个想法是�Q?/p>
		

				
				
				public
				 
				class
				 SimpleMatch 
				
						
				
				
						{
  
						public
						 
						int
						 StringMatch(String target,String patten) 
						
								
						
						
								{
      
								int
								 tl 
								=
								 target.length();
      
								int
								 pl 
								=
								 patten.length();
      
								int
								 i 
								=
								 
								0
								;
      
								int
								 j 
								=
								 
								0
								;
      
								while
								(i 
								<
								 tl 
								-
								 pl 
								&&
								 j 
								<
								 pl) 
								
										
								
								
										{
          
										if
										(patten.charAt(j) 
										==
										 target.charAt(i
										+
										j))
              j
										++
										;
          
										else
										 
										
												
										
										
												{
              j 
												=
												 
												0
												;
              i
												++
												;
          }
										
										
												

												      }
								
								
										

										      
								if
								(j 
								==
								 pl)
          
								return
								 i;
      
								return
								 
								-
								1
								;
  }
						
						
								

								  
  
						public
						 
						static
						 
						void
						 main(String[] args)
						
								
						
						
								{
      String t 
								=
								 
								"
								123456789
								"
								;
      String p 
								=
								 
								"
								456
								"
								;
      SimpleMatch sm 
								=
								 
								new
								 SimpleMatch();
      System.out.println(sm.StringMatch(t, p));
  }
						
						
								

								}
				
		
		可以看见�Q�这个算法（假定m>>n�Q�的复杂度是O(mn)�Q�其中m是T的长度，n是P的长度。这�U�算法的�~�陷是匹配过�E�中带有回溯——准���地说是T串存在回溯，也就是当匚w��不成功的时候，之前�q�行的匹配完全变为无用功�Q�所有的比较需要重新开始�?/p>
		
3 KMP���法
		KMP���法是D.E.Knuth、J.H.Morris和V.R.Pratt提出的无回溯的字�W�串匚w�����法�Q�算法的核心思想���是设法在匹配失败的时候，���量利用之前的匹配结果，消除T串的回溯问题。那么如何消除回溯呢�Q�请看下面的例子�Q?/p>
		
假设P=abacd�Q�如果T=abax...�Q�当从头开始匹配到字符c�Ӟ��若c=x�Q�显�Ӟ��匚w���q�程�l�箋�Q�当c≠x�Ӟ��按照朴素的匹配算法，T串会发生回溯�Q�之后T串会从第2个字�W�b开始重新匹配，而不是从匚w����p�|的字�W�x开始���l�。但是显�Ӟ��对于上述的匹配过�E�，T串不需要从b开始重新匹配，它只需要从x开始和P的b字符�l�箋匚w��卛_��。如下：
匚w���q�程�Q?br />P=abacd
T=abax....
     ^----比较到此处时发生匚w����p�|
朴素匚w�����法�Q?br />P= abacd
T=abax...
   ^----回溯到b�Q�重新开始和P的匹�?br />KMP���法�Q?br />P=  abacd
T=abax...
     ^----T串不回溯�Q�从x处���l�匹�?/p>
		
现在的问题是�Q�按照KMP���法�Q�匹配失败的时候，P串需要重新调整位�|�，但是调整的依据是什么？Knuth�{��h发现�Q�P调整位置的依据和P的构造有养I��和T无关。具体来��_��定义失效函数�Q�f(j)=k�Q�其�?<=k<=j�Q�且k是��得p₀p₁...p_k-1 = p_j-k+1p_j-k+2...p_j成立的最大整数。徏立失效函数的���法如下�Q?br />public void Build() {
 if(pattern == null)
  throw new Exception("KMP Exception : null pattern");
 array = new int[pattern.Length];
 int i = 0, s = pattern.Length;
 if(s > 1)
  array[0] = 0;
 for(i = 1; i < s; i++) {
  if(pattern[i] == pattern[array[i - 1]])
   array[i] = array[i - 1] + 1;
  else
   array[i] = 0;
 }
}
		匚w���q�程如下�Q?br />public int Match(String target, int start) {
 if(array == null || pattern == null || target == null)
  return -1;
 int target_index = start;
 int pattern_index = 0;
 int token_length = target.Length;
 int pattern_length = pattern.Length;
 while(target_index < token_length && pattern_index < pattern_length) {
  if(target[target_index] == pattern[pattern_index]) {
   target_index++;
   pattern_index++;
  } else {
   if(pattern_index == begin)
    target_index++;
   else
    pattern_index = array[pattern_index - 1];
  }
 }
 if(pattern_index == pattern_length)
  return target_index - pattern_length;
 return -1;
}
		4 支持通配�W?�?的KMP���法
		KMP���法虽然能够�q�行字符串匹配，但是�Q�在实践中字�W�串匚w��往往�q�要支持通配�W�，MS�pȝ��中最常见的通配�W�是?�?。其中，?可以代表一个字�W�（不能没有�Q�，*可以代表��L��多个字符�Q�可以�ؓ�I�）。经典的KMP���法针对通配�W�是无能为力的，但是�l�过���单的攚w��，KMP���法也可以识别通配�W��?/p>
		
首先�?�Q�根�?的功能，?表示��L��字符�Q�也���是说在匚w���q�程中，?永远匚w��成功。因此对匚w��函数的修改十分简单：
...
 while(target_index < token_length && pattern_index < pattern_length) {
  if(target[target_index] == pattern[pattern_index]|| pattern[pattern_index] == '?') {
   target_index++;
   pattern_index++;
  } else {
...
建立失效函数的过�E�和匚w���q�程�c�M���Q�修改如下：
...
 for(i = 1; i < s; i++) {
  if(pattern[i] == pattern[array[i - 1]]|| pattern[i] == '?' || pattern[array[i - 1]] == '?')
   array[i] = array[i - 1] + 1;
...
		本质上，?�q�没有修改算法，而仅仅修改了匚w��规则——遇�?则一定匹配。然�?与此不同�Q?的作用是匚w����L��多个字符�Q�显然我们不能简单的修改匚w���q�程而满������求。如果我们重新思�?的作用，我们会发�?的另一个作用就是分割P�Ԍ��卛_��果P=P₁*P₂�Q�那么与其说*代表匚w����L��多个字符�Q�不如说P的匹配条件是在匹配P₁子串后再匚w��P₂子串�?/p>
		
现在回顾失效函数的作用，如果当匹配到P的j+1位时匚w����p�|�Q�那么重新开始匹配的时候，P串的位置调整到f(j)位，直到P串的位置调整�?�Q�则匚w��重新开始。但当P=P₁*P₂�Q�假如P₁已经匚w��成功�Q�而在P₂中发生匹配失败，那么P串要需要调整位�|�，但P串无论如何调��_��此时也不应该调整�?�Q�最多调整到P₂的开始处�Q�因为P₁已经匚w���Q�只需匚w��P₂卛_��。假如P=abcab*abcab�Q�失效函数应该是�Q�注意之前提�?的作用）�Q?br />a b c a b * a b c a b
0 0 0 1 2 - 6 6 6 7 8
		因此�Q�要惌���KMP支持*�Q�那么关键是要重新设计失效函数的建立���法�Q�如下：
public void Build() {
 if(pattern == null)
  throw new Exception("KMP Exception : null pattern");
 array = new int[pattern.Length];
 int i = 0, s = pattern.Length;
 if(s > 1)
  array[0] = 0;
 int begin = 0;
 for(i = 1; i < s; i++) {
  if(pattern[i] == '*') {
   array[i] = i;
   begin = i + 1;
  } else if(pattern[i] == pattern[array[i - 1]] || pattern[i] == '?' || pattern[array[i - 1]] == '?')
   array[i] = array[i - 1] + 1;
  else
   array[i] = begin;
 }
} 
		���法中begin表示每段字符串的开始位�|�。此外，匚w���q�程也应该进行相应的修改�Q�因为字�W?对于匚w��没有��M��帮助�Q�它属于占位�W�，因此需要蟩�q�，匚w�����法如下�Q?br />public int Match(String target, int start) {
 if(array == null || pattern == null || target == null)
  return -1;
 int target_index = start;
 int pattern_index = 0;
 int token_length = target.Length;
 int pattern_length = pattern.Length;
 int begin = 0;
 while(target_index < token_length && pattern_index < pattern_length) {
  if(pattern[pattern_index] == '*') {
   begin = pattern_index + 1;
   pattern_index++;
  } else if(target[target_index] == pattern[pattern_index] || pattern[pattern_index] == '?') {
   target_index++;
   pattern_index++;
  } else {
   if(pattern_index == begin)
    target_index++;
   else
    pattern_index = array[pattern_index - 1];
  }
 }
 if(pattern_index == pattern_length)
  return target_index - pattern_length + begin;
 return -1;
}
		5 正则语言和确定状态自动机
		一个数字逻辑的问题：设计一个识�?1011的电路，解这个问题的关键���是设计�����个电路的DFA�Q�如下：
500){this.resized=true;this.style.width=500;}" />
		仔细看看�q�个状态机�Q�是不是和KMP的算法有几分�c�M��呢？�q��ƈ不是巧合�Q�因为KMP���法中的失效函数��d��以等��L��转化��Z��个DFA。当然KMP的DFA�q�比识别11011的DFA要复杂，原因在于KMP接受的输入是全体字符集合�Q�识�?1011的DFA只接�?�?�q�两个输入。我们知道，一个正则语�a�和一个DFA是等��L���Q�而KMP计算失效函数的算法，实际上等价于求DFA的过�E�，f(j)的值实际上表明状态j+1接受��C��正确的字�W�时应该回溯到的状态（注意此时输入����ƈ没有前进�Q�。普通的字符串都能看成是一个正则语�a��Q�含有通配�W?�?的字�W�串也可以等��L��转换��Z��个正则表辑ּ�。但是，正则语言的集合远比KMP���法所能支持的模式集合的更大，期间原因�q�是刚才提过的输入问题。试想P=p₁p₂...p_n�Q�当匚w��到p_j的时候，如果下一个输入字�W�正是p_j�Q�那么状态机�q�入下一个状态，如果不是p_j�Q�那么状态机按照实效函数的指�C���{�U�d��状态f(j-1)�Q�也���是说KMP状态机的每个状态只能根据输入是否�ؓp_j来进行�{�U�R��而正则表辑ּ�所对应的状态机则有所不同�Q�如果正则语�a�L=l₁l₂...l_n�Q�假设这些都是字母，当匹配到l_j位的时候，如果下一个输入字�W�正是l_j�Q�那么状态机�q�入下一个状态，否则它还可以�Ҏ��输入的��D��行�{�U�，例如l_j=c₁时�{换到状态x�Q�l_j=c₂时状态�{换到y�{�等�?/p>
		
6 �l�语
		字符串匹配问题是老问题了�Q��ƈ没有太多新意可言�Q�只不过虽然KMP���法十分���单，但它的内在含义还是十分深�ȝ��。横向比较KMP、DFA和正则语�a�、正则表辑ּ�我们会发玎ͼ�它们之间存在很多的关联，而这�U�比较也有利于我们更好的理解�q�些���法�Q�或者改�q�这些算法。最后说一句，试图利用目前的框架��得KMP���法支持全部�U�类的通配�W�（对应于正则表辑ּ����是x?、x*、x+、{m,n}�{�等�Q�是不可能，而我们也不需要这么做�Q�因为我们还有正则表辑ּ�嘛�?/p>


保尔�?/a> 2007-03-05 15:29 发表评论


Mon, 05 Mar 2007 02:40:00 GMT

		
				
				
				/**/
				
						/*
						
								

								 * 整�Ş数组�q����炚w��题：�q�����Ҏ��左边的整数和�{�于双���的整数和�Q?br /> * 求出�q����点位�|�，要求输入的数�l�可能是GB�U?br /> * 
 * 本题要求扑և�整型数组的一个��^衡点�Q�如果要扑և�所有��^衡点的话�Q�按此方法需要把每一个��^衡点都存��h���Q?br /> 
						*/
				
				
						

						
						

						
						
				
				public
				 
				class
				 Test 
				
						
				
				
						{

    
						public
						 
						int
						 findBalanceableNod(
						int
						[] a)
						
								
						
						
								{
        
								if
								(a 
								==
								 
								null
								)
								
										
								
								
										{
            
										return
										 
										-
										1
										;
        }
								
								
										

										        
								long
								 sum 
								=
								 
								0l
								;
        
								long
								 subSum 
								=
								 
								0l
								;
        
								for
								(
								int
								 i 
								=
								 
								0
								; i 
								<
								 a.length; i
								++
								)
								
										
								
								
										{
            sum 
										+=
										 a[i];
        }
								
								
										

										
										        
								for
								(
								int
								 i 
								=
								 
								0
								; i 
								<
								 a.length; i
								++
								)
								
										
								
								
										{
            
										if
										(subSum 
										==
										 sum 
										-
										 subSum 
										-
										 a[i])
										
												
										
										
												{
                
												return
												 i;
            }
										
										else
										
												
										
										
												{
                subSum 
												+=
												 a[i];
            }
										
										
												

												        }
								
								
										

										        
								return
								 
								-
								1
								;
    }
						
						
								

								    
    
						public
						 
						static
						 
						void
						 main(String[] args) 
						
								
						
						
								{
        
								//
								���试用例�Q���^衡点�?位，为n-1位，��Z��间位�Q�a的每个�ؓ存了Integer.MAX_VALUE(所以用sum,subSum用long�?
								
										

										
										
								
								        
								int
								[] a 
								=
								 
								
										
								
								
										{
										-
										1
										}
								
								;
        Test t 
								=
								 
								new
								 Test();
        System.out.println(t.findBalanceableNod(a));
    }
						
						
								

								}
				
		


保尔�?/a> 2007-03-05 10:40 发表评论


java字符串全排列问题�Q�经典）
Fri, 02 Mar 2007 09:37:00 GMT

		
				
				
				/**/
				
						/*
						
								

								 * 原题如下�Q�用1�?�?�?�?�?�q�六个数字，用java写一个main函数�Q�打印出所有不同的排列�Q?br /> * 如：612234�?12346�{�，要求�Q?4"不能在第三位�Q?3"�?6"不能相连. 
 * 
 * 1 把问题归�l��ؓ囄���构的遍历问题。实际上6个数字就是六个结点，把六个结点连接成无向�q�通图�Q�对于每一个结�Ҏ���q�个囑�Ş的遍历�\径，
 * 所有结点的遍历路径���是最后对�q?个数字的排列�l�合�l�果集。�?br /> * 2 昄����q�个�l�果集还未达到题目的要求。从以下几个斚w��考虑�Q��?br /> * 1. 3�Q?不能相连�Q�实际要求这个连通图的结�?�Q?之间不能�q��? 可在构造图�l�构时就满���Ҏ���Ӟ��然后再遍历图。�?br /> * 2. 不能有重�? 考虑到有两个2�Q�明显会存在重复�l�果�Q�可以把�l�果集放在TreeSet中过滤重复结果�?br /> * 3. 4不能在第三位: 仍旧在结果集中去除满���x��条�g的结果�?br /> 
						*/
				
				
						

						
						

						
				
				import
				 java.util.Iterator;

				import
				 java.util.TreeSet;


				public
				 
				class
				 Test 
				
						
				
				
						{

 
						private
						 String[] b 
						=
						 
						new
						 String[] 
						
								
						
						
								{ 
								"
								1
								"
								, 
								"
								2
								"
								, 
								"
								2
								"
								, 
								"
								3
								"
								, 
								"
								4
								"
								, 
								"
								6
								"
								 }
						
						;

 
						private
						 
						int
						 n 
						=
						 b.length;

 
						private
						 
						boolean
						[] visited 
						=
						 
						new
						 
						boolean
						[n];

 
						private
						 
						int
						[][] a 
						=
						 
						new
						 
						int
						[n][n];

 
						private
						 String result 
						=
						 
						""
						;

 
						private
						 TreeSet set 
						=
						 
						new
						 TreeSet();

 
						public
						 
						static
						 
						void
						 main(String[] args) 
						
								
						
						
								{
  
								new
								 Test().start();
 }
						
						
								

								
								

								
								 
						private
						 
						void
						 start() 
						
								
						
						
								{

  
								//
								 Initial the map a[][]
								
										

										
										
								
								  
								for
								 (
								int
								 i 
								=
								 
								0
								; i 
								<
								 n; i
								++
								) 
								
										
								
								
										{
   
										for
										 (
										int
										 j 
										=
										 
										0
										; j 
										<
										 n; j
										++
										) 
										
												
										
										
												{
    
												if
												 (i 
												==
												 j) 
												
														
												
												
														{
     a[i][j] 
														=
														 
														0
														;
    }
												
												 
												else
												 
												
														
												
												
														{
     a[i][j] 
														=
														 
														1
														;
    }
												
												
														

														   }
										
										
												

												  }
								
								
										

										
										

										  
								//
								 3 and 5 can not be the neighbor.
								
										

										
								
								  a[
								3
								][
								5
								] 
								=
								 
								0
								;
  a[
								5
								][
								3
								] 
								=
								 
								0
								;

  
								//
								 Begin to depth search.
								
										

										
										
								
								  
								for
								 (
								int
								 i 
								=
								 
								0
								; i 
								<
								 n; i
								++
								) 
								
										
								
								
										{
   
										this
										.depthFirstSearch(i);
  }
								
								
										

										
										

										  
								//
								 Print result treeset.
								
										

										
								
								  Iterator it 
								=
								 set.iterator();
  
								while
								 (it.hasNext()) 
								
										
								
								
										{
   String string 
										=
										 (String) it.next();
   System.out.println(string);
  }
								
								
										

										 }
						
						
								

								
								

								
								 
						private
						 
						void
						 depthFirstSearch(
						int
						 startIndex) 
						
								
						
						
								{
  visited[startIndex] 
								=
								 
								true
								;
  result 
								=
								 result 
								+
								 b[startIndex];
  
								if
								 (result.length() 
								==
								 n) 
								
										
								
								
										{

										//
										   "4" can not be the third position.
										
												

												
												
										
										   
										if
										 (result.indexOf(
										"
										4
										"
										) 
										!=
										 
										2
										) 
										
												
										
										
												{

												//
												    Filt the duplicate value.
												
														

														
												
												    set.add(result);
   }
										
										
												

												  }
								
								
										

										
										  
								for
								 (
								int
								 j 
								=
								 
								0
								; j 
								<
								 n; j
								++
								) 
								
										
								
								
										{
   
										if
										 (a[startIndex][j] 
										==
										 
										1
										 
										&&
										 visited[j] 
										==
										 
										false
										) 
										
												
										
										
												{
    depthFirstSearch(j);
   }
										
										
												

												  }
								
								
										

										
										

										  
								//
								 restore the result value and visited value after listing a node.
								
										

										
								
								  result 
								=
								 result.substring(
								0
								, result.length() 
								-
								 
								1
								);
  visited[startIndex] 
								=
								 
								false
								;
 }
						
						
								

								}
				
				
						

						
						

						
				
		
		只要�q�样定义图，�Ҏ��不用在代码中写IF ELSE语句�?
实际上基于图的算法好处在于，只要你能定义好满���题目要求的囄���构，遍历的结果就是你要的�l�果�Q�不用�Q何对遍历�l�果做�Q何处理。包括本题中的：4不能在第三位�|�，3�Q?不能相连�Q�唯一性要求，其实都可以在体现在构造的囑�Ş�l�构里，然后直接遍历囑֏�得自��p��的结果。而不用再�ơ处理结果集。只是说�q�里实际上对其它要求要体现在囄���构里有困难（理论上是可以的）�Q�但��L��3�Q?不能相接是很好构造的�Q�就是上面的代码�D�|��解释的�?/p>
		
关于囑�Ş数据�l�构�����先看看数据结构的书，主要是将如何利用二维数组描述囄���构，再看看图的深度遍历实现原理。最后再应用到这个问题上来，自然��׃��难明白了�?/p>


保尔�?/a> 2007-03-02 17:37 发表评论


Tue, 27 Feb 2007 09:10:00 GMT

		�Q��{自：http://chinavery.100steps.net/chengxuyuan/4759.html�Q?br />动态规划是本书介绍的五�U�算法设计方法中隑ֺ�最大的一�U�，它徏立在最优原则的基础上。采用动态规划方法，可以优雅而高效地解决许多用贪婪算法或分而治之算法无法解决的问题。在介绍动态规划的原理之后�Q�本章将分别考察动态规划方法在解决背包问题、图象压�~�、矩阵乘法链、最短�\径、无交叉子集和元件折叠等斚w��的应用�?/p>
		
3.1 ���法思想
		和贪婪算法一��P��在动态规划中�Q�可���一个问题的解决�Ҏ��视�ؓ一�p�d��决策的结果。不同的是，在贪婪算法中�Q�每采用一�ơ贪婪准则便做出一个不可撤回的决策�Q�而在动态规划中�Q�还要考察每个最优决�{�序列中是否包含一个最优子序列�?/p>
		
�?-1 [最短�\�l�] 考察�? 2 - 2中的有向图。假设要��L��一条从源节点s= 1到目的节点d= 5的最短�\径，即选择此�\径所�l�过的各个节炏V��第一步可选择节点2�Q?�?。假��N��择了节�?�Q�则此时所要求解的问题变成�Q�选择一条从3�?的最短�\径。如�?�?的�\径不是最短的�Q�则�?开始经�q?�?的�\径也不会是最短的。例如，若选择的子路径�Q�非最短�\径）�?�Q?�Q? (耗费�? )�Q�则1�?的�\径�ؓ1�Q?�Q?�Q? (耗费�?1 )�Q�这比选择最短子路径3�Q?�Q?而得到的1�?的�\�?�Q?�Q?�Q? (耗费�?) 耗费更大�?/p>
		
所以在最短�\径问题中�Q�假如在的第一�ơ决�{�时到达了某个节点v�Q�那么不���v 是怎样���定的，此后选择从v 到d 的�\径时�Q�都必须采用最优策略�?/p>
		
�?-2 [0/1背包问题] 考察1 3 . 4节的0 / 1背包问题。如前所�q�ͼ�在该问题中需要决定x1 .. xn的倹{��假设按i = 1�Q?�Q?�Q�n 的次序来���定xi 的倹{��如果置x1 = 0�Q�则问题转变为相对于其余物品�Q�即物品2�Q?�Q?�Q�n�Q�，背包定w��仍�ؓc 的背包问题。若�|�x1 = 1�Q�问题就变�ؓ关于最大背包容量�ؓc-w1 的问题。现设r?{c�Q�c-w1 } 为剩余的背包定w���?/p>
		
在第一�ơ决�{�之后，剩下的问题便是考虑背包定w��为r 时的决策。不���x1 �?或是1�Q�[x2 �Q?�Q�xn ] 必须是第一�ơ决�{�之后的一个最优方案，如果不是�Q�则会有一个更好的�Ҏ��[y2�Q?�Q�yn ]�Q�因而[x1�Q�y2�Q?�Q�yn ]是一个更好的�Ҏ���?/p>
		
假设n=3, w=[100,14,10], p=[20,18,15], c= 11 6。若设x1 = 1�Q�则在本�ơ决�{�之后，可用的背包容量�ؓr= 116-100=16 。[x2�Q�x3 ]=[0,1] �W�合定w��限制的条�Ӟ��所得��gؓ1 5�Q�但因�ؓ[x2�Q�x3 ]= [1�Q?] 同样�W�合定w��条�g且所得��gؓ1 8�Q�因此[x2�Q�x3 ] = [ 0�Q?] �q����最优策略。即x= [ 1�Q?�Q?] 可改�q��ؓx= [ 1�Q?�Q? ]。若设x1 = 0�Q�则对于剩下的两�U�物品而言�Q�容量限制条件�ؓ11 6。��M���Q�如果子问题的结果[x2�Q�x3 ]不是剩余情况下的一个最优解�Q�则[x1�Q�x2�Q�x3 ]也不会是��M��的最优解�?/p>
		
�?-3 [航费] 某航�U��h��D��为：从亚特兰大到�U�约或芝加哥�Q�或从洛杉矶��C��特兰大的费用�? 1 0 0�Q�从芝加哥到�U�约����h$ 2 0�Q�而对于�\�l�亚特兰大的旅客�Q�从亚特兰大到芝加哥的费用仅�? 2 0。从�z�杉矶到�U�约的航�U�涉及到对中转机场的选择。如果问题状态的形式为（��L���Q�终点）�Q�那么在选择从洛杉矶��C��特兰大后�Q�问题的状态变为（亚特兰大�Q�纽�U�）。从亚特兰大到纽�U�的最便宜航线是从亚特兰大直飞�U�约�Q�票�? 1 0 0。而��用直飞方式时�Q�从�z�杉矶到�U�约的花费�ؓ$ 2 0 0。不�q�，从洛杉矶到纽�U�的最便宜航线为洛杉矶-亚特兰大-芝加�?�U�约�Q�其总花费�ؓ$ 1 4 0�Q�在处理局部最优�\径亚特兰大到�U�约�q�程中选择了最低花费的路径�Q�亚特兰�?芝加�?�U�约�Q��?/p>
		
如果用三�l�数�l�（t a g�Q��v点，�l�点�Q�表�C�问题状态，其中t a g�?表示转飞�Q?t a g�?表示其他情�Ş�Q�那么在到达亚特兰大后，状态的三维数组���变为（ 0�Q�亚特兰大，�U�约�Q�，它对应的最优�\径是�l�由芝加哥的那条路径�?/p>
		
当最优决�{�序列中包含最优决�{�子序列�Ӟ��可徏立动态规划递归方程�Q?d y n a m i c -programming recurrence equation�Q�，它可以帮助我们高效地解决问题�?/p>
		
�?-4 [0/1背包] 在例3 - 2�? / 1背包问题中，最优决�{�序列由最优决�{�子序列�l�成。假设f (i,y) 表示�? 5 - 2中剩余容量�ؓy�Q�剩余物品�ؓi�Q�i + 1�Q?�Q�n 时的最优解的��|��卻I��和利用最优序列由最优子序列构成的结论，可得到f 的递归式。f ( 1 ,c) 是初始时背包问题的最优解。可使用�Q?1 5 - 2�Q�式通过递归或�P代来求解f ( 1 ,c)。从f (n, * )开始�P式， f (n, * )由（1 5 - 1�Q�式得出�Q�然后由�Q?1 5 - 2�Q�式递归计算f (i,*) ( i=n- 1�Q�n- 2�Q?�Q?2 )�Q�最后由�Q?1 5 - 2�Q�式得出f ( 1 ,c)�?/p>
		
对于�? 5 - 2�Q�若0≤y�Q? 0�Q�则f ( 3 ,y) = 0�Q�若y�? 0�Q�f ( 3 ,y) = 1 5。利用递归式（1 5 - 2�Q�，可得f (2, y) = 0 ( 0≤y�Q?0 )�Q�f�Q?�Q�y�Q? 1 5�Q? 0≤y�Q? 4�Q�；f�Q?�Q�y�Q? 1 8�Q? 4≤y�Q? 4�Q�和f�Q?�Q�y�Q? 3 3�Q�y�? 4�Q�。因此最优解f ( 1 , 11 6 ) = m a x {f�Q?�Q?1 6�Q�，f�Q?�Q?1 6 - w1�Q? p1} = m a x {f�Q?�Q?1 6�Q�，f�Q?�Q? 6�Q? 2 0 } = m a x { 3 3�Q? 8 } = 3 8�?/p>
		
现在计算xi ��|��步骤如下�Q�若f ( 1 ,c) =f ( 2 ,c)�Q�则x1 = 0�Q�否则x1 = 1。接下来需从剩余容量c-w1中寻求最优解�Q�用f (2, c-w1) 表示最优解。依此类推，可得到所有的xi (i= 1.n) 倹{�?/p>
		
在该例中�Q�可得出f ( 2 , 11 6 ) = 3 3≠f ( 1 , 11 6 )�Q�所以x1 = 1。接着利用�q�回�? 8 -p1=18 计算x2 及x3�Q�此时r = 11 6 -w1 = 1 6�Q�又由f ( 2 , 1 6 ) = 1 8�Q�得f ( 3 , 1 6 ) = 1 4≠f ( 2 , 1 6 )�Q�因此x2 = 1�Q�此时r= 1 6 -w2 = 2�Q�所以f (3,2) =0�Q�即得x3 = 0�?/p>
		
动态规划方法采用最优原则（ principle of optimality�Q�来建立用于计算最优解的递归式。所谓最优原则即不管前面的策略如何，此后的决�{�必���L����Z��当前状态（�׃��一�ơ决�{���生）的最优决�{�。由于对于有些问题的某些递归式来说�ƈ不一定能保证最优原则，因此在求解问题时有必要对它进行验证。若不能保持最优原则，则不可应用动态规划方法。在得到最优解的递归式之后，需要执行回溯（t r a c e b a c k�Q�以构造最优解�?/p>
		
�~�写一个简单的递归�E�序来求解动态规划递归方程是一件很�׃�h的事。然而，正如我们���在下文看到的，如果不努力地去避免重复计���，递归�E�序的复杂性将非常可观。如果在递归�E�序设计中解决了重复计算问题�Ӟ��复杂性将急剧下降。动态规划递归方程也可用�P代方式来求解�Q�这时很自然地避免了重复计算。尽����P代程序与避免重复计算的递归�E�序有相同的复杂性，但�P代程序不需要附加的递归栈空��_��因此���比避免重复计算的递归�E�序更快�?/p>
		

				
3.2 应用 
		3.2.1 0/1背包问题 
		1. 递归�{�略
		在例3 - 4中已建立了背包问题的动态规划递归方程�Q�求解递归式（ 1 5 - 2�Q�的一个很自然的方法便是��用程�? 5 - 1中的递归���法。该模块假设p、w 和n �����入，且p 为整型，F(1,c) �q�回f ( 1 ,c) 倹{�?/p>
		
�E�序15-1 背包问题的递归函数
		int F(int i, int y)
		{// �q�回f ( i , y ) .
		if (i == n) return (y < w[n]) ? 0 : p[n];
		if (y < w[i]) return F(i+1,y);
		return max(F(i+1,y), F(i+1,y-w[i]) + p[i]);
		}
		�E�序1 5 - 1的时间复杂性t (n)满���Q�t ( 1 ) =a�Q�t�Q�n�Q�≤2t�Q�n- 1�Q?b�Q�n�Q?�Q�，其中a、b 为常数。通过求解可得t (n) =O( 2n)�?/p>
		
�?-5 设n= 5�Q�p= [ 6 , 3 , 5 , 4 , 6 ]�Q�w=[2,2,6,5,4] 且c= 1 0 ,求f ( 1 , 1 0 )。�ؓ了确定f ( 1 , 1 0 )�Q�调用函数F ( 1 , 1 0 )。递归调用的关�p�d���? 5 - 1的树型结构所�C�。每个节点用y值来标记。对于第j层的节点有i=j�Q�因此根节点表示F ( 1 , 1 0 )�Q�而它有左孩子和右孩子�Q�分别对应F ( 2 , 1 0 )和F ( 2 , 8 )。��d��执行�? 8�ơ递归调用。但我们注意刎ͼ�其中可能含有重复前面工作的节点，如f ( 3 , 8 )计算�q�两�ơ，相同情况的还有f ( 4 , 8 )、f ( 4 , 6 )、f ( 4 , 2 )、f ( 5 , 8 )、f ( 5 , 6 )、f ( 5 , 3 )、f (5,2) 和f ( 5 , 1 )。如果保留以前的计算�l�果�Q�则可将节点数减�? 9�Q�因为可以丢弃图中的阴媄节点�?/p>
		
正如在例3 - 5中所看到的，�E�序1 5 - 1做了一些不必要的工作。�ؓ了避免f (i,y)的重复计���，必须定义一个用于保留已被计���出的f (i,y)值的表格L�Q�该表格的元素是三元�l?i,y,f (i,y) )。在计算每一个f (i,y)之前�Q�应���查表L中是否已包含一个三元组(i,y, * )�Q�其�?表示��L��倹{��如果已包含�Q�则从该表中取出f (i,y)的��|��否则�Q�对f (i,y)�q�行计算�q�将计算所得的三元�l?i,y,f (i,y) )加入表L。L既可以用散列�Q�见7 . 4节）的�Ş式存储，也可用二叉搜索树(�?1�?的�Ş式存储�?/p>
		
2. 权�ؓ整数的�P代方�?/p>
		
当权为整数时�Q�可设计一个相当简单的���法�Q�见�E�序1 5 - 2�Q�来求解f ( 1 ,c)。该���法��Z���? - 4所�l�出的策略，因此每个f (i,y) 只计���一�ơ。程�? 5 - 2用二�l�数�l�f [ ][ ]来保存各f 的倹{��而回溯函数Tr a c e b a c k用于���定��q���? 5 - 2所产生的xi 倹{��函数K n a p s a c k的复杂性�ؓ( n c�Q�，而Tr a c e b a c k的复杂性�ؓ( n )�?/p>
		
�E�序15-2 f 和x 的�P代计��?/p>
		
template
		void Knapsack(T p[], int w[], int c, int n, T** f)
		{// 对于所有i和y计算f [ i ] [ y ]
		// 初始化f [ n ] [ ]
		for (int y = 0; y <= yMax; y++)
		f[n][y] = 0;
		for (int y = w[n]; y <= c; y++)
		f[n][y] = p[n];
		// 计算剩下的f
		for (int i = n - 1; i > 1; i--) {
		for (int y = 0; y <= yMax; y++)
		f[i][y] = f[i+1][y];
		for (int y = w[i]; y <= c; y++)
		f[i][y] = max(f[i+1][y], f[i+1][y-w[i]] + p[i]);
		}
		f[1][c] = f[2][c];
		if (c >= w[1])
		f[1][c] = max(f[1][c], f[2][c-w[1]] + p[1]);
		}
		template
		void Traceback(T **f, int w[], int c, int n, int x[])
		{// 计算x
		for (int i = 1; i < n; i++)
		if (f[i][c] == f[i+1][c]) x[i] = 0;
		else {x[i] = 1;
		c -= w[i];}
		x[n] = (f[n][c]) ? 1 : 0;
		}
		3. 元组�Ҏ���Q?选读�Q?/p>
		
�E�序1 5 - 2有两个缺点：1) 要求权�ؓ整数�Q?) 当背包容量c 很大�Ӟ���E�序1 5 - 2的速度慢于�E�序1 5 - 1。一般情况下�Q�若c�Q?n�Q�程�? 5 - 2的复杂性�ؓW (n2n )。可利用元组的方法来克服上述两个�~�点。在元组�Ҏ��中，对于每个i�Q�f (i, y) 都以数对(y, f (i, y)) 的�Ş式按y的递增�ơ序存储于表P(i)中。同�Ӟ���׃��f (i, y) 是y 的非递减函数�Q�因此P(i) 中各数对(y, f (i, y)) 也是按f (i, y) 的递增�ơ序排列的�?/p>
		
�?-6 条�g同例3 - 5。对f 的计���如�? 5 - 2所�C�。当i= 5�Ӟ��f 由数寚w��合P( 5 ) = [ ( 0 , 0 ) , ( 4 , 6 ) ]表示。而P( 4 )、P( 3 )和P( 2 )分别为[ ( 0 , 0 ) , ( 4 , 6 ) , ( 9 , 1 0 ) ]、[ ( 0 , 0 ) ( 4 , 6 ) , ( 9 , 1 0 ) , ( 1 0 , 11)] 和[ ( 0 , 0 ) ( 2 , 3 ) ( 4 , 6 ) ( 6 , 9 ) ( 9 , 1 0 ) ( 1 0 , 11 ) ]�?/p>
		
为求f ( 1 , 1 0 )�Q�利用式�Q? 5 - 2�Q�得f ( 1 , 1 0 ) = m a x｛f ( 2 , 1 0 )�Q�f ( 2 , 8 ) + p 1｝。由P( 2 )得f ( 2 , 1 0 ) = 11、f (2,8)=9 (f ( 2 , 8 ) = 9来自数对( 6�Q? ) )�Q�因此f ( 1 , 1 0 ) = m a x�?1 , 1 5�? 1 5。现在来求xi 的��|��因�ؓf ( 1 , 1 0 ) =f ( 2 , 6 ) +p1�Q�所以x1 = 1�Q�由f ( 2 , 6 ) =f ( 3 , 6 - w 2 ) +p2 =f ( 3 , 4 ) +p2�Q�得x2 = 1�Q�由f ( 3 , 4 ) =f ( 4 , 4 ) =f ( 5 , 4 )得x3=x4 = 0�Q�最后，因f ( 5 , 4 )�?得x5= 1�?/p>
		
���查每个P(i) 中的数对�Q�可以发现每�?y,f (i,y)) 对应于变量xi , ., xn �?/1 赋值的不同�l�合。设�Q�a,b�Q�和�Q�c,d�Q�是对应于两�l�不同xi , ., xn �? / 1赋��|��若a≥c且b�Q�d�Q�则(a, b) �?b, c) 支配。被支配者不必加入P(i)中。若在相同的数对中有两个或更多的赋��|��则只有一个放入P(i)。假设wn≤C�Q�P(n)=[(0,0), (wn , pn ) ]�Q�P�Q�n�Q�中对应于xn 的两个数对分别等�?�?。对于每个i�Q�P(i)可由P(i+ 1 )得出。首先，要计���数对的有序集合Q�Q���得当且仅当wi≤s≤c�?s-wi , t-pi )为P(i+1) 中的一个数�Ҏ���Q�（s,t�Q��ؓQ中的一个数寏V��现在Q中包含xi = 1时的数对集，而P(i+ 1 )对应于xi = 0的数寚w��。接下来�Q�合�q�Q和P(i+ 1 )�q�删除受支配者和重复值即可得到P(i)�?/p>
		
�?-7 各数据同�? 5 - 6。P(5)=[(0,0),(4,6)], 因此Q= [ ( 5 , 4 ) , ( 9 , 1 0 ) ]。现在要���P( 5 )和Q合�ƈ得到P( 4 )。因( 5 , 4 )�? 4 , 6 )支配�Q�可删除( 5 , 4 )�Q�所以P�Q?�Q?[(0,0), (4,6), (9,10)]。接着计算P( 3 )�Q�首先由P( 4 )得Q=[(6,5), (10,11 ) ]�Q�然后又由合�q�方法得P(3)=[(0,0), (4,6), (9,10), (10,11 ) ]。最后计���P( 2 )�Q�由P( 3 )得Q= [ ( 2 , 3 )�Q? 6 , 9 ) ]�Q�P( 3 )与Q合�ƈ得P(2)=[(0,0), (2,3), (4,6), (6,9), (9,10). (10,11 ) ]。因为每个P(i) 中的数对对应于xi , ., xn 的不�? / 1赋��|��因此P(i) 中的数对不会���过2n-i+ 1个。计���P(i) �Ӟ��计算Q需消�? |P(i+ 1 ) |�Q�的旉����Q�合�q�P(i+1) 和Q同样需�? |P(i+ 1 ) | )的时间。计���所有P(i) 时所需要的��L��间�ؓ�Q?(n ?i=2|P(i + 1)|= O ( 2n )。当权�ؓ整数�Ӟ��|P(i) |≤c+1, 此时复杂性�ؓO ( m i n {n c, 2n } )�?/p>
		
�? . 4 . 3节定义的�Q�数字化囑փ�是m×m的像素阵列。假定每个像素有一�? ~ 2 5 5的灰度倹{��因此存储一个像素至多需8位。若每个像素存储都用最大位8位，则�ȝ��存储�I�间�?m2 位。�ؓ了减���存储空��_��我们���采用变长模式（ variable bit scheme�Q�，即不同像素用不同位数来存储。像素��gؓ0�?时只需1位存储空��_���?�?各需2位；�?�Q?�Q?�?各需3位；以此�c�L���Q���用变长模式的步骤如下�Q?/p>
		
1) 囑փ��U�性化�Ҏ���?5-3a 中的折线���m×m�l�图像�{换�ؓ1×m2 �l�矩��c�?/p>
		
2) 分段���像素组分成若干个段�Q�分�D�原则是�Q�每�D�中的像素位数相同。每个段是相��d��素的集合且每�D�|��多含2 5 6个像素，因此�Q�若相同位数的像素超�q? 5 6个的话，则用两个以上的段表示�?/p>
		
3) 创徏文�g创徏三个文�g�Q�S e g m e n t L e n g t h, BitsPerPixel 和P i x e l s。第一个文件包含在2 )中所建的�D늚�长度(�? )�Q�文件中各项均�ؓ8位长。文件BitsPerPixel �l�出了各�D�中每个像素的存储位敎ͼ��?�Q�，文�g中各��均�?位。文件Pixels 则是以变长格式存储的像素的二�q�制丌Ӏ?/p>
		
4) 压羃文�g压羃�?) 中所建立的文�Ӟ��以减���空间需求�?/p>
		
上述压羃�Ҏ��的效率（用所得压�~�率表示�Q�很大程度上取决于长�D늚�出现频率�?/p>
		
�?-8 考察�?5-3b �?×4囑փ�。按照蛇形的行主�ơ序�Q�灰度��g���ơ�ؓ1 0�Q?�Q? 2�Q? 0�Q? 0�Q? 5�Q? 5�Q? 2�Q?�Q? 0�Q?�Q? 5�Q?1�Q? 3 0�Q? 6 0�? 4 0。各像素所需的位数分别�ؓ4�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�?�Q�按�{�长的条件将像素分段�Q�可以得�?个段[ 1 0�Q?�Q? 2 ]、[ 4 0�Q? 0�Q? 5 ]、[15, 12, 8, 10, 9, 15, 11] 和��E130, 160, 240�Q�。因此，文�gSegmentLength �?�Q?�Q?�Q?�Q�文件BitsPerSegment 的内容�ؓ3�Q?�Q?�Q?�Q�文件P i x e l s包含了按蛇�Ş行主�ơ序排列�? 6个灰度��|��其中头三个各�?位存储，接下来三个各�?位，再接下来的七个各�?位，最后三个各�?位存储。因此存储单元中�? 0位存储了前六个像素：
		1010 1001 1100 111000 110010 100011
		�q�三个文仉���要的存储�I�间分别为：文�gSegmentLength 需3 2位；BitsPerSegment 需1 2位；Pixels 需8 2位，共需1 2 6位。而如果每个像素都�?位存储，则存储空间需8×1 6 = 1 2 8位，因而在本例囑փ�中，节省�?位的�I�间�?/p>
		
假设�?) 之后�Q���生了n 个段。段标题�Q�segment header�Q�用于存储段的长度以及该�D�中每个像素所占用的位数。每个段标题需11位。现假设li 和bi 分别表示�W�i �D늚��D�长和该�D�|��个像素的长度�Q�则存储�W�i �D�像素所需要的�I�间为li *bi 。在2) 中所得的三个文�g的��d��储空间�ؓ11 n+n ?i = 1li bi。可通过���某些相��L��合�ƈ的方式来减少�I�间消耗。如当段i 和i+ 1被合�q�时�Q�合�q�后的段长应为li +li + 1。此时每个像素的存储位数为m a x {bi�Q�bi +1 } 位。尽���这�U�技术增加了文�gP i x e l s的空间消耗，但同时也减少了一个段标题的空间�?/p>
		
�?-9 如果���例1 5 - 8中的�W?�D�和�W?�D�合�qӞ��合�ƈ后，文�gS e g m e n t L e n g t h变�ؓ5�Q?�Q?�Q�BitsPerSegment 变�ؓ5�Q?�Q?。而文件Pixels 的前3 6位存储的是合�q�后的第一�D�：001010 001001 001100 111000 110010 100011其余的像素（�? 5 - 8�W?�D�）没有改变。因为减���了1个段标题�Q�文件S e g m e n t L e n g t h和BitsPerPixel 的空间消耗共减少�?1位，而文件Pixels 的空间增�?位，因此��d��节约的空间�ؓ5位，�I�间��L��耗�ؓ1 2 1位�?/p>
		
我们希望能设计一�U�算法，使得在��生n 个段之后�Q�能对相��L���q�行合�ƈ�Q�以便��生一个具有最���空间需求的新的�D�集合。在合�ƈ盔R���D�之后，可利用诸如L Z W法（�? . 5节）和霍夫曼�~�码�Q�见9 . 5 . 3节）�{�其他技术来�q�一步压�~�这三个文�g�?/p>
		
令sq 为前q 个段的最优合�q�所需要的�I�间。定义s0 = 0。考虑�W�i �D?i�Q? )�Q�假如在最优合�q�C中，�W�i �D�与�W�i- 1�Q�i- 2�Q?�Q�i-r+1 �D늛�合�ƈ�Q�而不包括�W�i-r �D�c��合�q�C所需要的�I�间消耗等于：�W?�D�到�W�i-r �D�|��需�I�间+ l s u m (i-r+ 1 ,i) * b m a x (i-r+ 1 ,i) + 11
		其中l s u m(a, b)=b ?j =a
		lj�Q�bmax (a, b)= m a x {ba , ..., bb }。假如在C中第1�D�到�W�i-r �D늚�合�ƈ不是最优合�qӞ��那么需要对合�ƈ�q�行修改�Q�以使其��h��更小的空间需求。因此还必须�Ҏ��1到段i-r �q�行最优合�qӞ��也即保证最优原则得以维持。故C的空间消耗�ؓ�Q?/p>
		
si = si-r +l s u m�Q�i-r+1, i�Q?b m a x�Q�i-r+1, i�Q? 11
		r 的��g���?到i 之间�Q�其中要求l s u m不超�q? 5 6 (因�ؓ�D�长限制�? 5 6之内)。尽���我们不知道如何选择r�Q�但我们知道�Q�由于C��h��最���的�I�间需求，因此在所有选择中， r 必须产生最���的�I�间需求�?/p>
		
假定k a yi 表示取得最���值时k 的��|��sn 为n �D늚�最优合�q�所需要的�I�间�Q�因而一个最优合�q�可用kay 的值构造出来�?/p>
		
�?-10 假定�?) 中得��C��个段�Q�它们的长度为[ 6�Q?�Q? 0�Q?�Q? ]�Q�像素位��Cؓ[ 1�Q?�Q?�Q?�Q? ]�Q�要用公式（1 5 - 3�Q�计���sn�Q�必���d��求出sn-1�Q?�Q�s0 的倹{��s0 �?�Q�现计算s1�Q�s1 =s0 +l1 *b1+ 11 = 1 7k a y1 = 1s2 �׃��式得出：
		s2 = m i n {s1 +l2 b2 , s0 + (l1 +l2 ) * m a x {b1 , b2} } + 11 = m i n { 1 7 + 6 , 0 + 9 * 2 } + 11 = 2 9
		k a y2 = 2
		以此�c�L���Q�可得s1.s5 = [ 1 7�Q? 9�Q? 7�Q? 3�Q?2] �Q�k a y1.k a y5 = [ 1�Q?�Q?�Q?�Q? ]。因为s5 = 8 2�Q�所以最优空间合�q����8 2位的�I�间。可由k a y5 导出本合�q�的方式�Q�过�E�如下：因�ؓk a y5 = 4�Q�所以s5 是由公式�Q? 5 - 3�Q�在k=4 时取得的�Q�因而最优合�q�包括：�D?到段( 5 - 4 ) = 1的最优合�q�以及段2�Q?�Q?�?的合�q�。最后仅剩下两个�D�：�D?以及�D?到段5的合�q�段�?/p>
		
1. 递归�Ҏ��
		用递归式（1 5 - 3�Q�可以递归地算出si 和k a yi。程�? 5 - 3为递归式的计算代码。l�Q�b�Q�和k a y是一�l�的全局整型数组�Q�L是段镉K���Ӟ�� 2 5 6�Q�，h e a d e r为段标题所需的空�? 11 )。调用S ( n )�q�回sn 的��g��同时得出k a y倹{��调用Tr a c e b a c k ( k a y, n )可得到最优合�q��?/p>
		
现讨论程�? 5 - 3的复杂性。t( 0 ) =c�Q�c ��Z��个常敎ͼ��Q?�Q�n�Q?�Q�，因此利用递归的方法可得t (n) = O ( 2n )。Tr a c e b a c k的复杂性�ؓ(n)�?/p>
		
�E�序15-3 递归计算s , k a y及最优合�q?/p>
		
int S(int i)
		{ / /�q�回S ( i )�q�计���k a y [ i ]
		if (i == 0 ) return 0;
		//k = 1�? �Ҏ��公式�Q?1 5 - 3�Q�计���最����?/p>
		
int lsum = l[i],bmax = b[i];
		int s = S(i-1) + lsum * bmax;
		kay[i] = 1;
		/ /对其余的k计算最���值�ƈ求取最����?/p>
		
for (int k = 2; k <= i && lsum+l[i-k+1] <= L; k++) {
		lsum += l[i-k+1];
		if (bmax < b[i-k+1]) bmax = b[i-k+1];
		int t = S(i-k);
		if (s > t + lsum * bmax) {
		s = t + lsum * bmax;
		kay[i] = k;}
		}
		return s + header;
		}
		void Traceback(int kay[], int n)
		{// 合�ƈ�D?/p>
		
if (n == 0) return;
		Tr a c e b a c k ( k a y, n-kay[n]);
		cout << "New segment begins at " << (n - kay[n] + 1) << endl;
		}
		2. 无重复计���的递归�Ҏ��
		通过避免重复计算si�Q�可���函数S的复杂性减���到(n)。注意这里只有n个不同的si�?/p>
		
�? - 11 再考察�? 5 - 1 0中五个段的例子。当计算s5 �Ӟ��先通过递归调用来计���s4�Q?�Q�s0。计���s4 �Ӟ��通过递归调用计算s3�Q?�Q�s0�Q�因此s4 只计���了一�ơ，而s3 计算了两�ơ，每一�ơ计���s3要计���一�ơs2�Q�因此s2 ��p�����了四次�Q�而s1 重复计算�? 6�ơ！可利用一个数�l�s 来保存先前计���过的si 以避免重复计���。改�q�后的代码见�E�序1 5 - 4�Q�其中s为初��gؓ0的全局整型数组�?/p>
		
�E�序15-4 避免重复计算的递归���法
		int S(int i)
		{ / /计算S ( i )和k a y [ i ]
		/ /避免重复计算
		if (i == 0) return 0;
		if (s[i] > 0) return s[i]; //已计���完
		/ /计算s [ i ]
		/ /首先�Ҏ��公式�Q? 5 - 3�Q�计���k = 1时最����?/p>
		
int lsum = l[i], bmax = b[i];
		s[i] =S(i-1) + lsum * bmax;
		kay[i] = 1;
		/ /对其余的k计算最���值�ƈ更新
		for (int k = 2; k <= i && lsum+l[i-k+1] <= L; k++) {
		lsum += l[i-k+1];
		if (bmax < b[i-k+1]) bmax = b[i-k+1];
		int t = S(i-k);
		if (s[i] > t + lsum * bmax) {
		s[i] = t + lsum * bmax;
		kay[i] = k;}
		}
		s[i] += header;
		return s[i];
		}
		��Z�����定�E�序1 5 - 4的时间复杂性，我们�����用分期计���模式（ amortization scheme�Q�。在该模式中�Q���L��间被分解������q�个不同��，通过计算各项的时间然后求和来获得��L��间。当计算si �Ӟ��若sj �q�未���出�Q�则把调用S(j) 的消耗计入sj �Q�若sj 已算出，则把S(j) 的消耗计入si (�q�里sj依次把计���新sq 的消耗�{�U�至每个sq )。程�? 5 - 4的其他消耗也被计入si。因为L�? 5 6之内的常��C��每个li 臛_���?�Q�所以程�? 5 - 4的其他消耗�ؓ( 1 )�Q�即计入每个si 的量是一个常敎ͼ�且si 数目为n�Q�因而��d��作量�?n)�?/p>
		
3. �q�代�Ҏ��
		倘若用式�Q? 5 - 3�Q�依序计���s1 , ., sn�Q�便可得��C��个复杂性�ؓ(n)的�P代方法。在该方法中�Q�在si 计算之前�Q?sj 必须已计���好。该�Ҏ��的代码见�E�序1 5 - 5�Q�其中仍利用函数Tr a c e b a c k�Q�见�E�序1 5 - 3�Q�来获得最优合�q��?/p>
		
�E�序15-5 �q�代计算s和k a y
		void Vbits (int l[], int b[], int n, int s[], int kay[])
		{ / /计算s [ i ]和k a y [ i ]
		int L = 256, header = 11 ;
		s[0] = 0;
		/ /�Ҏ��式（1 5 - 3�Q�计���s [ i ]
		for (int i = 1; i <= n; i++) {
		// k = 1�?计算最����?/p>
		
int lsum = l,
		bmax = b[i];
		s[i] = s[i-1] + lsum * bmax;
		kay[i] = 1;
		/ /对其余的k计算最���值�ƈ更新
		for (int k=2; k<= i && lsum+l[i-k+1]<= L; k++) {
		lsum += l[i-k+1];
		if (bmax < b[i-k+1]) bmax = b[i-k+1];
		if (s[i] > s[i-k] + lsum * bmax){
		s[i] = s[i-k] + lsum * bmax;
		kay[i] = k; }
		}
		s[i] += header;
		}
		}
		
				
3.2.3 矩阵乘法�?/p>
		
m×n矩阵A与n×p矩阵B�怹�需耗费(m n p)的时��_��见第2章练�? 6�Q�。我们把m n p作�ؓ两个矩阵�怹�所需旉���的测量倹{��现假定要计���三个矩阵A、B和C的乘�U�，有两�U�方式计���此乘积。在�W�一�U�方式中�Q�先用A乘以B得到矩阵D�Q�然后D乘以C得到最�l�结果，�q�种乘法的顺序可写�ؓ(A*B) *C。第二种方式写�ؓA* (B*C) ,道理同上。尽���这两种不同的计���顺序所得的�l�果相同�Q�但旉���消耗会有很大的差距�?/p>
		
�?-12 假定A�? 0 0×1矩阵�Q�B�?×1 0 0矩阵�Q�C�? 0 0×1矩阵�Q�则A*B的时间耗费�?0 0 0 0�Q�得到的�l�果D�? 0 0×1 0 0矩阵�Q�再与C�怹�所需的时间耗费�? 000 000�Q�因此计��?A*B) *C的��L��间�ؓ1 010 000。B*C的时间耗费�?0 000�Q�得到的中间矩阵�?×1矩阵�Q�再与A�怹�的时间消耗�ؓ1 0 0�Q�因而计���A*�Q�B*C�Q�的旉���耗费竟只�?0 100�Q�而且�Q�计���（ A*B�Q?C�Ӟ���q�需10 000个单元来存储A*B�Q�而A*�Q�B*C�Q�计���过�E�中�Q�只需�?个单元来存储B*C�?/p>
		
下面举一个得益于选择合适秩序计���A*B*C矩阵的实例：考虑两个3�l�图像的匚w��。图像匹配问题的要求是，���定一个图像需旋�{、��^�U�d���~�放多少�ơ才能��D��另一个图像。实现匹配的�Ҏ��之一便是执行�U? 0 0�ơ�P代计���，每次�q�代需计算1 2×1个向量T�Q?/p>
		
T=?A(x, y, z) *B(x, y, z)*C(x, y, z )
		其中A�Q�B和C分别�? 2×3�Q?×3�?×1矩阵�?x , y, z) 为矩阵中向量的坐标。设t 表示计算A(x , y, z) *B(x , y, z) *C(x , y, z)的计���量。假定此囑փ��? 5 6×2 5 6×2 5 6个向量，在此条�g中，�q? 0 0个�P代所需的总计���量�q�似�? 0 0 * 2 5 63 * t�? . 7 * 1 09 t。若三个矩阵是按由左向右的顺序相乘的�Q�则t = 1 2 * 3 * 3 + 1 2 * 3 *1= 1 4 4�Q�但如果从右向左�怹��Q?t = 3 * 3 * 1 + 1 2 * 3 * 1 = 4 5。由左至双������约需2 . 4 * 1 011个操作，而由双���左计���大概只需7 . 5 * 1 01 0个操作。假如��用一个每�U�可执行1亿次操作的计���机�Q�由左至右需4 0分钟�Q�而由双���左只需1 2 . 5分钟�?/p>
		
在计���矩阵运���A*B*C�Ӟ��仅有两种乘法��序�Q�由左至��x��由右臛_���Q�，所以可以很�Ҏ�����出每种��序所需要的操作敎ͼ��q����择操作数比较少的那�U�乘法顺序。但对于更多矩阵�怹�来说�Q�情况要复杂得多。如计算矩阵乘积M1×M2×.×Mq�Q�其中Mi 是一个ri×ri + 1 矩阵( 1≤i≤q)。不妨考虑q=4 的情况，此时矩阵�q�算A*B*C*D可按以下方式�Q�顺序）计算�Q?/p>
		
A* ( (B*C) *D) A* (B* (C*D)) (A*B) * (C*D) (A* (B*C) ) *D
		不难看出计算的方法数会随q 以指数��增加。因此，对于很大的q 来说�Q�考虑每一�U�计���顺序�ƈ选择最优者已是不切实际的�?/p>
		
现在要介�l�一�U�采用动态规划方法获得矩阵乘法次序的最优策略。这�U�方法可���算法的旉���消耗降�?q3 )。用Mi j 表示链Mi×.×Mj �Q�i≤j�Q�的乘积。设c(i,j) 为用最优法计算Mi j 的消耗，k a y(i, j) 为用最优法计算Mi j 的最后一步Mi k×Mk+1, j 的消耗。因此Mij 的最优算法包括如何用最优算法计���Mik 和Mkj 以及计算Mik×Mkj 。根据最优原理，可得到如下的动态规划递归式：k a y(i,i+s)= 获得上述最���值的k. 以上求c 的递归式可用递归或�P代的�Ҏ��来求解。c( 1�Q�q) 为用最优法计算矩阵铄���消耗，k a y( 1 ,q) 为最后一步的消耗。其余的乘积可由k a y值来���定�?/p>
		
1. 递归�Ҏ��
		与求�? / 1背包及图像压�~�问题一��P��本递归�Ҏ��也须避免重复计算c (i, j) 和k a y(i, j)�Q�否则算法的复杂性将会非帔R���?/p>
		
�?-13 设q= 5和r =�Q? 0 , 5 , 1 , 1 0 , 2 , 1 0�Q�，式中待求的c 中有四个c的s= 0�?�Q�因此用动态规划方法可立即求得它们的��|�� c( 1 , 1 ) =c( 5 , 5 ) = 0 ;c(1,2)=50; c( 4 , 5 ) = 2 0 0。现计算C( 2�Q? )�Q�c( 2 , 5 ) = m i n {c( 2 , 2 ) +c(3,5)+50, c( 2 , 3 ) +c(4,5)+500, c( 2 , 4 ) +c( 5 , 5 ) + 1 0 0 } �Q? 5 - 5�Q�其中c( 2 , 2 ) =c( 5 , 5 ) = 0�Q�c( 2 , 3 ) = 5 0�Q�c(4,5)=200 。再用递归式计���c( 3 , 5 )及c( 2 , 4 ) :c( 3 , 5 ) = m i n {c( 3 , 3 ) +c(4,5)+100, c( 3 , 4 ) +c( 5 , 5 ) + 2 0 } = m i n { 0 + 2 0 0 + 1 0 0 , 2 0 + 0 + 2 0 } = 4 0c( 2 , 4 ) = m i n {c( 2 , 2 ) +c( 3 , 4 ) + 1 0 ,c( 2 , 3 ) +c( 4 , 4 ) + 1 0 0 } = m i n { 0 + 2 0 + 1 0 , 5 0 + 1 0 + 2 0 } = 3 0�׃��上计���还可得k a y( 3 , 5 ) = 4�Q�k ay( 2 , 4 ) = 2。现�?计算c(2,5) 所需的所有中间值都已求得，���它们代入式�Q? 5 - 5�Q�得�Q?/p>
		
c(2,5)=min{0+40+50, 50+200+500, 30+0+100}=90且k a y( 2 , 5 ) = 2
		再用式（1 5 - 4�Q�计���c( 1 , 5 )�Q�在此之前必��ȝ��出c( 3 , 5 )、c(1,3) 和c( 1 , 4 )。同上述�q�程�Q�亦可计���出它们的值分别�ؓ4 0�? 5 0�? 0�Q�相应的k a y 值分别�ؓ4�?�?。代入式�Q? 5 - 4�Q�得�Q?/p>
		
c(1,5)=min{0+90+500, 50+40+100, 150+200+1000, 90+0+200}=190且k a y( 1 , 5 ) = 2
		此最优乘法算法的消耗�ؓ1 9 0�Q�由k a y(1,5) 值可推出该算法的最后一步， k a y(1,5) �{�于2�Q�因此最后一步�ؓM1 2×M3 5�Q�而M12 和M35 都是用最优法计算而来。由k a y( 1 , 2 ) = 1知M12 �{�于M11×M2 2�Q�同理由k a y( 3 , 5) = 4得知M35 由M3 4×M55 ���出。依此类推，M34 由M3 3×M44 得出。因而此最优乘法算法的步骤为：
		M11×M2 2 = M1 2
		M3 3×M4 4 = M3 4
		M3 4×M5 5 = M3 5
		M1 2×M3 5 = M1 5
		计算c(i, j) 和k a y (i, j) 的递归代码见程�? 5 - 6。在函数C中，r 为全局一�l�数�l�变量， k a y是全局二维数组变量�Q�函数C�q�回c(i j) 之��g���|�k a y [a] [b] =k ay (a , b) (对于��M��a , b)�Q�其中c(a , b)在计���c(i,j) 时皆已算出。函数Traceback 利用函数C中已���出的k a y值来推导出最优乘法算法的步骤�?/p>
		
设t(q)为函数C的复杂性，其中q=j-i+ 1�Q�即Mij 是q个矩阵运���的�l�果�Q�。当q�?�?�Ӟ��t(q) =d�Q�其中d ��Z��常数�Q�而q> 2�Ӟ��t (q)=2q-1?k = 1t (k ) +e q�Q�其中e 是一个常量。因此当q�Q?�Ӟ��t(q)�Q?t (q- 1 ) +e�Q�所以t (q)= W ( 2q)。函数Traceback 的复杂性�ؓ(q)�?/p>
		
�E�序15-6 递归计算c (i, j) 和kay (i, j)
		int C(int i, int j)
		{ / /�q�回c(i,j) 且计���k(i,j) = kay[i][j]
		if (i==j) return 0; //一个矩�늚�情�Ş
		if (i == j-1) { //两个矩阵的情�?/p>
		
kay[i][i+1] = i;
		return r[i]*r[i+1]*r[r+2];}
		/ /多于两个矩阵的情�?/p>
		
/ /设u为k = i 时的最����?/p>
		
int u = C(i,i) + C(i+1,j) + r[i]*r[i+1]*r[j+1];
		kay[i][j] = i;
		/ /计算其余的最���值�ƈ更新u
		for (int k = i+1; k < j; k++) {
		int t = C(i,k) + C(k+1,j) + r[i]*r[k+1]*r[j+1];
		if (r < u) {//���于最���值的情�Ş
		u = t;
		kay[i][j] = k;
		}
		return u;
		}
		void Traceback (int i, int j ,int **kay)
		{ / /输出计算Mi j 的最优方�?/p>
		
if ( i == j) return;
		Traceback(i, kay[i][j], kay);
		Traceback(kay[i][j]+1, j, kay);
		cout << "Multiply M" << i << ", "<< kay[i][j];
		cout << " and M " << (kay[i][j]+1) << ", " << j << end1;
		}
		2. 无重复计���的递归�Ҏ��
		若避免再�ơ计���前面已�l�计���过的c�Q�及相应的k a y�Q�，可将复杂性降低到�Q�q3�Q�。而�ؓ了避免重复计���，需用一个全局数组c[ ][ ]存储c(i, j) ��|��该数�l�初始��gؓ0。函数C的新代码见程�? 5 - 7�Q?/p>
		
�E�序15-7 无重复计���的c (i, j) 计算�Ҏ��
		int C(int i,int j)
		{ / /�q�回c(i,j) �q�计���k a y ( i , j ) = k a y [ I ] [ j ]
		/ /避免重复计算
		/ /���查是否已计算�q?/p>
		
if �Q�c[i][j] >�Q?return c[i][j];
		/ /若未计算,则进行计��?/p>
		
if(i==j) return 0; //一个矩�늚�情�Ş
		i f ( i = = j - 1 ) { / /两个矩阵的情�?/p>
		
kay[i][i+1]=i;
		c [ i ] [ j ] = r [ i ] * r [ i + 1 ] * r [ i + 2 ] ;
		return c[i][j];}
		/ /多于两个矩阵的情�?/p>
		
/ /设u为k = i 时的最����?/p>
		
int u=C(i,i)+C(i+1,j)+r[i]*r[i+1]*r[j+1];
		k a y [ i ] [ j ] = i ;
		/ /计算其余的最���值�ƈ更新u
		for (int k==i+1; k
		
int t=C(i,k)+C(k+1,j)+r[i]*r[k+1]*r[j+1];
		if (t
		
u = t ;
		k a y [ i ] [ j ] = k ; }
		}
		c [ i ] [ j ] = u ;
		return u;
		}
		为分析改�q�后函数C 的复杂性，再次使用分期计算�Ҏ��。注意到调用C(1, q) 时每个c (i, j)�Q?≤i≤j≤q�Q�仅被计���一�ơ。要计算���未计算�q�的c(a,b)�Q�需附加的工作量s =j-i�Q?。将s 计入�W�一�ơ计���c (a, b) 时的工作量中。在依次计算c(a, b) �Ӟ���q�个s 会�{计到每个c (a, b) 的第一�ơ计���时间c 中，因此每个c (i, i) 均被计入s。对于每个s�Q�有q-s+ 1个c(i, j) 需要计���，因此�ȝ��工作消耗�ؓq-1 ?s=1(q-s+ 1) = (q3 )�?/p>
		
3. �q�代�Ҏ��
		c 的动态规划递归式可用�P代的�Ҏ��来求解。若按s = 2�Q?�Q?�Q�q-1 的顺序计���c (i, i+s)�Q�每个c 和kay 仅需计算一�ơ�?/p>
		
�?-14 考察�? - 1 3中五个矩�늚�情况。先初始化c (i, i) (0≤i�?) �?�Q�然后对于i=1, ., 4分别计算c (i, i+ 1 )。c (1, 2)= r1 r2 r3 = 5 0�Q�c (2, 3)= 5 0�Q�c ( 3,4)=20 和c (4, 5) = 2 0 0。相应的k ay 值分别�ؓ1�Q?�Q?�?�?/p>
		
当s= 2�Ӟ��可得�Q?/p>
		
c( 1 , 3 ) = m i n {c( 1 , 1 ) +c(2,3)+ r1 r2 r4 , c( 1 , 2 ) +c( 3 ,3 )+r1r3r4 }=min
		=150
		且k a y( 1 , 3 ) = 2。用相同�Ҏ��可求得c( 2 , 4 )和c( 3 , 5 )分别�? 0�? 0�Q�相应k a y值分别�ؓ2�?�?/p>
		
当s= 3�Ӟ��需计算c(1,4) 和c( 2 , 5 )。计���c(2,5) 所需要的所有中间值均已知(�? 1 5 - 5 )�?�Q�代入计���公式后可得c( 2 , 5 ) = 9 0�Q�k a y( 2 , 5 ) = 2。c( 1 , 4 )可用同样的公式计���。最后，当s= 4�Ӟ��可直接用�Q? 5 - 4�Q�式来计���c( 1 , 5 )�Q�因�����式右�Ҏ��有项都已知�?
		计算c 和kay 的�P代程序见函数M a t r i x C h a i n�Q�见�E�序1 5 - 8�Q�，该函数的复杂性�ؓ(q3 )。计���出kay 后同样可用程�? 5 - 6中的Traceback 函数推算出相应的最优乘法计���过�E��?/p>
		
�E�序15-8 c 和kay 的�P代计��?/p>
		
void MatrixChain(int r[], int q, int **c, int **kay)
		{// 为所有的Mij 计算耗费和k a y
		// 初始化c[i][i], c[i][i+1]和k a y [ i ] [ i + 1 ]
		for (int i = 1; i < q; i++) {
		c[i][i] = 0;
		c[i][i+1] = r[i]*r[i+1]*r[i+2];
		kay[i][i+1] = i;
		}
		c[q][q] = 0;
		/ /计算余下的c和k a y
		for (int s = 2; s < q; s++)
		for (int i = 1; i <= q - s; i++) {
		// k = i时的最���项
		c[i][i+s] = c[i][i] + c[i+1][i+s] + r[i]*r[i+1]*r[i+s+1];
		kay[i][i+s] = i;
		// 余下的最���项
		for (int k = i+1; k < i + s; k++) {
		int t = c[i][k] + c[k+1][i+s] + r[i]*r[k+1]*r[i+s+1];
		if (t < c[i][i+s]) {// 更小的最���项
		c[i][i+s] = t;
		kay[i][i+s] = k;}
		}
		}
		}
		3.2.4 最短�\�?/p>
		
假设G为有向图�Q�其中每条边都有一个长度（或耗费�Q�，图中每条有向路径的长度等于该路径中各边的长度之和。对于每寚w���?i, j)�Q�在��点i 与j 之间可能有多条�\径，各�\径的长度可能各不相同。我们定义从i 到j 的所有�\径中�Q�具有最���长度的路径��Z��i 到j 的最短�\径�?/p>
		
�?-15 如图1 5 - 4所�C�。从��点1到顶�?的�\径有
		1) 1,2,5,3
		2) 1,4,3
		3) 1,2,5,8,6,3
		4) 1,4,6,3
		��p��囑֏��?各�\径相应的长度�? 0�? 8�?�? 7�Q�因而�\�?) 是该图中��点1到顶�?的最短�\径�?/p>
		
在所有点�Ҏ��短�\径问题（ a l l - p a i r sshorest-paths problem�Q�中�Q�要��L��有向图G中每寚w��点之间的最短�\径。也���是��_��对于每对��点(i, j)�Q�需要寻找从i到j 的最短�\径及从j 到i 的最短�\径。因此对于一个n 个顶点的图来��_��需��L��p =n(n-1) 条最短�\径。假定图G中不含有长度�����数的环�\�Q�只有在�q�种假设下才可保证G中每寚w���?i, j) 之间��L��一条不含环路的最短�\径。当有向图中存在长度���于0的环路时�Q�可能得到长度�ؓ�Q�∞的更短�\径，因�ؓ包含该环路的最短�\径往往可无限多�ơ地加上此负长度的环路�?/p>
		
讑֛�G中n 个顶点的�~�号�?到n。��oc (i, j, k)表示从i 到j 的最短�\径的长度�Q�其中k 表示该�\径中的最大顶炏V��因此，如果G中包含边�Q�则c(i, j, 0) =�?lt;i, j> 的长度；若i= j �Q�则c(i,j, 0)=0�Q�如果G中不包含�?lt;i, j>�Q�则c (i, j, 0)= +∞。c(i, j, n) 则是从i 到j 的最短�\径的长度�?/p>
		
�?-16 考察�? 5 - 4。若k=0, 1, 2, 3�Q�则c (1, 3, k)= ∞；c (1, 3, 4)= 2 8�Q�若k = 5, 6, 7�Q�则c (1, 3,k) = 1 0�Q�若k=8, 9, 10�Q�则c (1, 3, k) = 9。因�?�?的最短�\径长度�ؓ9。对于�Q意k�Q?�Q�如何确定c (i, j, k) 呢？中间��点不超�q�k 的i 到j 的最短�\径有两种可能�Q�该路径含或不含中间��点k。若不含�Q�则该�\径长度应为c(i, j, k- 1 )�Q�否则长度�ؓc(i, k, k- 1) +c (k, j, k- 1 )。c(i, j, k) 可取两者中的最���倹{��因此可得到如下递归式：
		c( i, j, k)= m i n {c(i, j, k-1), c (i, k, k- 1) +c (k, j, k- 1 ) }�Q�k�Q?
		以上的递归公式���一个k �U�运����{化�ؓ多个k-1 �U�运���，而多个k-1 �U�运���应比一个k �U�运���简单。如果用递归�Ҏ��求解上式�Q�则计算最�l�结果的复杂性将无法估量。��ot (k) 为递归求解c (i, j, k) 的时间。根据递归式可以看出t(k) = 2t(k- 1 ) +c。利用替代方法可得t(n) = ( 2n )。因此得到所有c (i, j, n) 的时间�ؓ(n2 2n )�?/p>
		
当注意到某些c (i, j, k-1) 值可能被使用多次�Ӟ��可以更高效地求解c (i, j, n)。利用避免重复计���c(i, j, k) 的方法，可将计算c 值的旉���减少�?n3 )。这可通过递归方式�Q�见�E�序1 5 - 7矩阵��N��题）或�P代方式来实现。出�q�代���法的伪代码如图1 5 - 5所�C��?/p>
		
 
		/ /��L��最短�\径的长度
		/ /初始化c�Q�i�Q�j�Q?�Q?/p>
		
for �Q�int i=1�Q?i < = n ; i + +�Q?/p>
		
for (int j=1; j<=n; j+ + )
		c ( i ,j, 0 ) = a ( i ,j); // a 是长度邻接矩�?/p>
		
/ /计算c ( i ,j, k ) ( 0 < k < = n )
		for(int k=1;k<=n;k++)
		for (int i=1;i<=n;i++)
		for (int j= 1 ;j< = n ;j+ + )
		if (c(i,k,k-1)+c(k,j, k - 1 ) < c ( i ,j, k - 1 ) )
		c ( i ,j, k ) = c ( i , k , k - 1 ) + c ( k ,j, k - 1 ) ;
		else c(i,j, k ) = c ( i ,j, k - 1 ) ;
		�?5-5 最短�\径算法的伪代�?/p>
		
 
		注意到对于�Q意i�Q�c(i,k,k) =c(i,k,k- 1 )且c(k,i,k) =c(k,i,k- 1 )�Q�因而，若用c(i,j)代替�? 5 - 5的c(i,j,k)�Q�最后所得的c(i,j) 之值将�{�于c(i,j,n) 倹{��此时图1 5 - 5可改写成�E�序1 5 - 9的C + +代码。程�? 5 - 9中还利用了程�? 2 - 1中定义的AdjacencyWDigraph �c�R��函数AllPairs 在c 中返回最短�\径的长度。若i 到j 无通�\�Q�则c [i] [j]被赋��gؓN o E d g e。函数AllPairs 同时计算了k a y [ i ] [ j ]�Q�其中kay[i][j] 表示从i 到j 的最短�\径中最大的k 倹{��在后面���看到如何根据kay 值来推断��Z��一个顶点到另一��点的最短�\径（见程�? 5 - 1 0中的函数O u t p u t P a t h�Q��?/p>
		
�E�序1 5 - 9的时间复杂性�ؓ(n3 )�Q�其中输��Z��条最短�\径的实际旉���为O (n)�?/p>
		
�E�序15-9 c 和kay 的计��?/p>
		
template
		void AdjacencyWDigraph::Allpairs(T **c, int **kay)
		{ / /所有点对的最短�\�?/p>
		
/ /对于所有i和j�Q�计���c [ i ] [ j ]和k a y [ i ] [ j ]
		/ /初始化c [ i ] [ j ] = c�Q�i�Q�j�Q?�Q?/p>
		
for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++) {
		c[i][j] = a[i][j];
		kay[i][j] = 0;
		}
		for (i = 1; i <= n; i++)
		c[i][i] = 0;
		// 计算c[i][j] = c(i,j,k)
		for (int k = 1; k <= n; k++)
		for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++) {
		T t1 = c[i][k];
		T t2 = c[k][j];
		T t3 = c[i][j];
		if (t1 != NoEdge && t2 != NoEdge && (t3 == NoEdge || t1 + t2 < t3)) {
		c[i][j] = t1 + t2;
		kay[i][j] = k;}
		}
		}
		�E�序15-10 输出最短�\�?/p>
		
void outputPath(int **kay, int i, int j)
		{// 输出i 到j 的�\径的实际代码
		if (i == j) return;
		if (kay[i][j] == 0) cout << j << ' ';
		else {outputPath(kay, i, kay[i][j]);
		o u t p u t P a t h ( k a y, kay[i][j], j);}
		}
		template
		void OutputPath(T **c, int **kay, T NoEdge, int i, int j)
		{// 输出从i 到j的最短�\�?/p>
		
if (c[i][j] == NoEdge) {
		cout << "There is no path from " << i << " to " << j << endl;
		r e t u r n ; }
		cout << "The path is" << endl;
		cout << i << ' ';
		o u t p u t P a t h ( k a y, i , j ) ;
		cout << endl;
		}
		�?-17 �?5-6a �l�出某图的长度矩阵a�Q?5-6b �l�出��q���? 5 - 9所计算出的c 矩阵�Q?5-6c 为对应的k a y倹{��根�?5-6c 中的kay ��|��可知�?�?的最短�\径是�?到k a y [ 1 ] [ 5 ] = 4的最短�\径再加上�?�?的最短�\径，因�ؓk a y [ 4 ] [ 5 ] = 0�Q�所以从4�?的最短�\径无中间��点。从1�?的最短�\径经�q�k a y [ 1 ] [ 4 ] = 3。重复以上过�E�，最后可�?�?的最短�\径�ؓ�Q?�Q?�Q?�Q?�Q?�?/p>
		
3.2.5 �|�络的无交叉子集
		�?1 . 5 . 3节的交叉分布问题中，�l�定一个每边带n 个针脚的布线通道和一个排列C。顶部的针脚i 与底部的针脚Ci 相连�Q�其�?≤i≤n�Q�数�?i, Ci ) �U�Cؓ�|�组。��d��有n 个网�l�需�q�接或连通。假设有两个或更多的布线层，其中有一个�ؓ优先层，在优先层中可以��用更�l�的�q�线�Q�其电阻也可能比其他层要���得多。布�U�时应尽可能在优先层中布设更多的�|�组。而剩下的其他�|�组���布讑֜�其他层。当且仅当两个网�l�之间不交叉�Ӟ��它们可布讑֜�同一层。我们的��d��是寻找一个最大无交叉子集�Q�Maximum Noncrossing Su b s e t�Q�M N S )。在该集中，��L��两个�|�组都不交叉。因(i, Ci ) 完全由i 军_���Q�因此可用i 来指�?i, Ci )�?/p>
		
�?-18 考察�? 5 - 7�Q�对应于�? 0 - 1 7�Q��? 1 , 8 )�? 2 , 7 )�Q�也�?��L���l�和2��L���l�）交叉�Q�因而不能布讑֜�同一层中。�? 1 , 8 )�Q?7,9) �?9,10) 未交叉，因此可布讑֜�同一层。但�q?个网�l��ƈ不能构成一个M N S�Q�因�����有更大的不交叉子集。图1 0 - 1 7中给出的例子中，集合�?( 4 , 2 ) ,( 5 , 5 ) , ( 7 , 9 ) , ( 9 , 1 0 )｝是一个含4个网�l�的M N S�?/p>
		
设M N S(i, j) 代表一个M N S�Q�其中所有的(u, Cu ) 满��u≤i�Q�Cu≤j。��os i z e(i,j) 表示M N S(i,j)的大��?即网�l�的数目)。显然M N S(n,n)是对应于�l�定输入的M N S�Q�而s i z e(n,n)是它的大����?/p>
		
�?-19 对于�? 0 - 1 7中的例子�Q�M N S( 1 0 , 1 0 )是我们要扄���最�l�结果。如�? - 1 8中所指出的，s i z e( 1 0 , 1 0 ) = 4�Q�因�? 1 , 8 )�Q? 2 , 7 )�Q? 7 , 9 )�Q? 8 , 3 )�Q? 9 , 1 0 )�? 1 0 , 6 )中要么顶部针脚编��h��7大，要么底部针脚�~�号�?大，因此它们都不属于M N S( 7 , 6 )。因此只需考察剩下�?个网�l�是否属于M N S( 7 , 6 )�Q�如�? 5 - 8所�C�。子集｛( 3 , 4 ) , ( 5 , 5 )｝是大小�?的无交叉子集。没有大����ؓ3的无交叉子集�Q�因此s i z e( 7 , 6) = 2�?/p>
		
当i= 1�Ӟ��( 1 ,C1) 是M N S( 1 ,j) 的唯一候选。仅当j≥C1 �Ӟ���q�个�|�组才会是M N S( 1 ,j) 的一个成�? 
		下一步，考虑i�Q?时的情况。若j�Q�Ci�Q�则(i,Ci ) 不可能是M N S( i,j) 的成员，所有属于M N S(i,j) �?u, Cu ) 都需满��u�Q�i且Cu�Q�j�Q�因此：s i z e(i,j) =s i z e(i- 1 ,j), j
		
若j≥Ci�Q�则(i,Ci ) 可能在也可能不在M N S(i,j) 内。若(i,Ci ) 在M N S(i,j) 内，则在M N S(i,j)中不会有�q�样�?u,Cu )�Q�u�Q�i且Cu�Q�Ci�Q�因�����个网�l�必�?i, Ci ) �怺�。因此M N S(i,j) 中的其他所有成员都必须满��条�gu�Q�i且Cu�Q�Ci。在M N S(i,j) 中这��L���|�组共有Mi- 1 , Ci- 1 个。若(i,Ci ) 不在M N S(i,j)中，则M N S(i,j) 中的所�?u, Cu ) 必须满��u�Q�i�Q�因此s i z e(i,j)=s i z e(i- 1 ,j)。虽然不能确�?i, Ci )是否在M N S(i,j) 中，但我们可以根据获取更大M N S的原则来作出选择。因此：s i z e(i,j) = m a x {s i z e(i-1 ,j), s i z e(i- 1 ,Ci-1)+1}, j≥Ci �Q? 5 - 8�Q?/p>
		
虽然从（1 5 - 6�Q�式刎ͼ� 1 5 - 8�Q�式可用递归法求解，但从前面的例子可以看出，即��避免了重复计���，动态规划递归���法的效率也不够高，因此只考虑�q�代�Ҏ��。在�q�代�q�程中先用式�Q? 5 - 6�Q�计���出s i ze ( 1 ,j)�Q�然后再用式�Q? 5 - 7�Q�和�Q? 5 - 8�Q�按i=2, 3, ., n 的顺序计���s i ze (i,j)�Q�最后再用Traceback 来得到M N S(n, n) 中的所有网�l��?/p>
		
�?-20 �? 5 - 9�l�出了图1 5 - 7对应的s i z e(i,j) 倹{��因s i z e( 1 0 , 1 0) = 4�Q�可知M N S�?个网�l�。�ؓ求得�q?个网�l�，先从s i ze ( 1 0 , 1 0 )入手。可用（1 5 - 8�Q�式���出s i z e( 1 0 , 1 0 )。根据式�Q? 5 - 8�Q�时的��生原因可知s i ze ( 1 0 , 1 0)=s i z e( 9 , 1 0 )�Q�因此现在要求M NS ( 9 , 1 0 )。由于M NS ( 1 0 , 1 0 )≠s i z e( 8 , 1 0 )�Q�因此M NS (9,10) 中必包含9��L���l�。M N S(9,10) 中剩下的�|�组�l�成M NS ( 8 , C9- 1)=M N S( 8 , 9 )。由M N S( 8 , 9 ) =M NS (7,9) 知，8��L���l�可以被排除。接下来要求M N S( 7 , 9 )�Q�因为s i z e( 7 , 9 )≠s i z e( 6 , 9 )�Q�所以M N S中必�?��L���l�。M NS (7,9) 中余下的�|�组�l�成M NS ( 6 , C7- 1 ) =M N S( 6 , 8 )。根据s i z e( 6 , 8 ) =s i z e( 5 , 8 )可排�?��L���l�。按同样的方法， 5��L���l�，3��L���l�加入M N S中，�?��L���l�等其他�|�组被排除。因此回溯过�E�所得到的大����ؓ4的M N S为{ 3 , 5 , 7 , 9 }�?/p>
		
注意到在回溯�q�程中未用到s i z e( 1 0 ,j) (j�? 0 )�Q�因此不必计���这些倹{�?/p>
		
�E�序1 5 - 11�l�出了计���s i z e ( i , j ) 的�P代代码和输出M N S的代码。函数M N S用来计算s i ze (i,j) 的��|��计算�l�果用一个二�l�数�l�M N来存储。size[i][j] 表示s i z e(i,j)�Q�其中i=j= n �?≤i�Q�n�Q?≤j≤n�Q�计���过�E�的旉���复杂性�ؓ(n2 )。函数Traceback 在N et�Q? : m - 1�Q�中输出所得到的M N S�Q�其旉���复杂性�ؓ(n)。因此求解M M S问题的动态规划算法的�ȝ��旉���复杂�?/p>
		
�?n2 )�?/p>
		
�E�序1 5 - 11 ��L��最大无交叉子集
		void MNS(int C[], int n, int **size)
		{ / /对于所有的i 和j�Q�计���s i z e [ i ] [ j ]
		/ /初始化s i z e [ 1 ] [ * ]
		for (int j = 0; j < C[1]; j++)
		size[1][j] = 0;
		for (j = C[1]; j <= n; j++)
		size[1][j] = 1;
		// 计算size[i][*], 1 < i < n
		for (int i = 2; i < n; i++) {
		for (int j = 0; j < C[i]; j++)
		size[i][j] = size[i-1][j];
		for (j = C[i]; j <= n; j++)
		size[i][j] = max(size[i-1][j], size[i-1][C[i]-1]+1);
		}
		size[n][n] = max(size[n-1][n], size[n-1][C[n]-1]+1);
		}
		void Traceback(int C[], int **size, int n, int Net[], int& m)
		{// 在N e t [ 0 : m - 1 ]中返回M M S
		int j = n; // 所允许的底部最大针脚编�?/p>
		
m = 0; // �|�组的游�?/p>
		
for (int i = n; i > 1; i--)
		// i 号n e t在M N S�?
		if (size[i][j] != size[i-1][j]){// 在M N S�?/p>
		
Net[m++] = i;
		j = C[i] - 1;}
		// 1��L���l�在M N S�?
		if (j >= C[1])
		Net[m++] = 1; // 在M N S�?/p>
		
}
		3.2.6 元�g折叠
		在设计电路的�q�程中，工程师们会采取多�U�不同的设计风格。其中的两种��Z���Q�片设计�Q�bit-slice design�Q�和标准单元设计�Q�standard-cell design�Q�。在前一�U�方法中�Q�电路首先被设计��Z��个元件栈�Q�如�?5-10a 所�C�）。每个元件Ci 宽�ؓwi �Q�高为hi �Q�而元件宽度用片数来表�C�。图15-10a �l�出了一个四片的设计。线路是按片来连接各元�g的，卌����U�可能连接元件Ci 的第j片到元�gCi+1 的第j 片。如果某些元件的宽度不��j 片，则这些元件之间不存在片j 的连�Uѝ��当�? 5 -10a 的位�Q�片设计作�ؓ某一大系�l�的一部分�Ӟ��则在V L SI ( Very Large Scale Integrated) 芯片上�ؓ它分配一定数量的�I�间单元。分配是按空间宽度或高度的限制来完成的。现在的问题便是如何���元件栈折叠到分配空间中去，以便���量减小未受限制的尺度（如，若高度限制�ؓH�Ӟ��必须折叠栈以���量减小宽度W�Q�。由于其他尺度不变，因此�~�小一个尺度（如W�Q�等价于�~�小面积。可用折�U�方式来折叠元�g栈，在每一折叠点，元�g旋�{1 8 0��。在�?5-10b 的例子中�Q�一�? 2元�g的栈折叠成四个垂直栈�Q�折叠点为C6 , C9 和C1 0。折叠栈的宽度是宽度最大的元�g所需的片数。在�?5-10b 中，栈宽各�ؓ4�Q?�Q?�?。折叠栈的高度等于各栈所有元仉���度之和的最大倹{��在�?5-10b 中栈1的元仉���度之和最大，该栈的高度决定了包围所有栈的矩形高度�?/p>
		
实际上，在元件折叠问题中�Q�还需考虑�q�接两个栈的�U��\所需的附加空间。如�Q�在�? 5 -10b 中C5 和C6 间的�U��\因C6 为折叠点而弯曌Ӏ�这些线路要求在C5 和C6 之下留有垂直�I�间�Q�以便能从栈1�q�到�?。��ori 为Ci 是折叠点时所需的高度。栈1所需的高度�ؓ5 ?i =1hi +r6�Q�栈2所需高度�? ?i=6hi +r6+r9�?/p>
		
在标准单元设计中�Q�电路首先被设计成�ؓ��h��相同高度的符合线性顺序的元�g排列。假设此�U�性顺序中的元件�ؓC1�Q?�Q�Cn�Q�下一步元件被折叠成如�? 5 - 11所�C�的相同宽度的行。在此图中， 1 2个标准单元折叠成四个�{�宽行。折叠点是C4�Q�C6 和C11。在盔R��标准单元行之��_��使用布线通道来连接不同的行。折叠点军_��了所需布线通道的高度。设li 表示当Ci 为折叠点时所需的通道高度。在�? 5 - 11的例子中�Q�布�U�K��道1的高度�ؓl4�Q�通道2的高度�ؓl6�Q�通道3的高度�ؓl11。位�Q�片栈折叠和标准单元折叠都会引出一�p�d��的问题，�q�些问题可用动态规划方法来解决�?/p>
		
1. �{�宽位－片元件折�?/p>
		
定义r1 = rn+1 =0。由元�gCi 至Cj 构成的栈的高度要求�ؓj ?k= ilk+ ri+ rj + 1。设一个位�Q�片设计中所有元件有相同宽度W。首先考察在折叠矩形的高度H�l�定的情况下�Q�如何羃���其宽度。设Wi
		为将元�gCi 到Cn 折叠到高为H的矩形时的最���宽度。若折叠不能实现�Q�如当ri +hi�Q�H�Ӟ���Q�取Wi =∞。注意到W1 可能是所有n 个元件的最��x��叠宽度�?/p>
		
当折叠Ci 到Cn �Ӟ��需要确定折叠点。现假定折叠�Ҏ��按栈左到栈右的顺序来取定的。若�W�一点定为Ck+ 1�Q�则Ci 到Ck 在第一个栈中。�ؓ了得到最���宽度，从Ck+1 到Cn 的折叠必��ȝ��最优化�Ҏ���Q�因此又���用到最优原理，可用动态规划方法来解决此问题。当�W�一个折叠点k+ 1已知�Ӟ��可得��C��下公式：
		Wi =w+ Wk + 1 �Q? 5 - 9�Q?/p>
		
�׃��不知道第一个折叠点�Q�因此需要尝试所有可行的折叠点，�q����择满���Q?1 5 - 9�Q�式的折叠点。��oh s u m(i,k)=k ?j = ihj。因k+ 1是一个可行的折叠点，因此h s u m(i, k) +ri +rk+1 一定不会超�q�H�?/p>
		
�Ҏ��上述分析�Q�可得到以下动态规划递归式：
		�q�里Wn+1 =0�Q�且在无最优折叠点k+ 1时Wi 为∞。利用递归式（1 5 - 1 0�Q�，可通过递归计算Wn , Wn- 1., W2 , W1 来计���Wi。Wi 的计���需要至多检查n-i+ 1个Wk+ 1�Q�耗时为O (n-k)。因此计���所有Wi 的时间�ؓO (n2 )。通过保留式（1 5 - 1 0�Q�每�ơ所得的k ��|��可回溯地计算出各个最优的折叠点，其时间耗费为O (n)�?/p>
		
现在来考察另外一个有关等宽元件的折叠问题�Q�折叠后矩�Ş的宽度W已知�Q�需要尽量减���其高度。因每个折叠矩�Ş宽�ؓw�Q�因此折叠后栈的最大数量�ؓs=W / w。��oHi, j 为Ci , ., Cn 折叠成一宽度为jw 的矩形后的最���高度， H1, s 则是所有元件折叠后的最���高度。当j= 1�Ӟ��不允�怓Q何折叠，因此�Q�Hi,1 =h s u m(i,n) +ri , 1≤i≤n
		另外�Q�当i=n �Ӟ��仅有一个元�Ӟ��也不可能折叠�Q�因此：Hn ,j=hn+rn , 1≤j≤s
		在其他情况下�Q�都可以�q�行元�g折叠。如果第一个折叠点为k+ 1�Q�则�W�一个栈的高度�ؓ
		h s u m(i,k) +ri +rk+ 1。其他元件必���M��臛_��(j- 1 ) *w 的宽度折叠。�ؓ保证该折叠的最优性，其他元�g也需以最���高度进行折�?
		因�ؓ�W�一个折叠点未知�Q�因此必���d��试所有可能的折叠点，然后从中扑և�一个��式（1 5 - 11�Q�的右侧取最���值的点，该点成�ؓ�W�一个折叠点�?/p>
		
可用�q�代法来求解Hi, j ( 1≤i≤n, 1≤j≤s)�Q�求解的��序为：先计���j=2 时的H i, j�Q�再���j= 3�Q?�Q�以此类推。对应每个j 的Hi, j 的计���时间�ؓO (n2 )�Q�所以计���所有H i, j 的时间�ؓO(s n2 )。通过保存由（ 1 5 - 1 2�Q�式计算出的每个k ��|��可以采用复杂性�ؓO (n) 的回溯过�E�来���定各个最优的折叠炏V�?/p>
		
2. 变宽位－片元件的折叠
		首先考察折叠矩�Ş的高度H已定�Q�欲求最���的折叠宽度的情��c����oWi 如式�Q? 5 - 1 0�Q�所�C�，按照与（1 5 - 1 0�Q�式相同的推��D���E�，可得�Q?/p>
		
Wi = m i n {w m i n(i, k) +Wk+1 | h s u m(i,k)+ ri +rk+ 1≤H, i≤k≤n} �Q? 5 - 1 3�Q?/p>
		
其中Wn+1=0且w m i n(i,k)= m ini≤j≤k{wj }。可用与�Q? 5 - 1 0�Q�式一��L���Ҏ��求解�Q? 5 - 1 3�Q�式�Q�所需旉���为O(n2 )�?/p>
		
当折叠宽度W�l�定�Ӟ��最���高度折叠可用折半搜索方法对���过O(n2 )个可能��D��行搜索来实现�Q�可能的高度��gؓh(i,j)+ri +rj + 1。在������每个高度时�Q�也可用�Q?1 5 - 1 3�Q�式来确定该折叠的宽度是否小于等于W。这�U�情况下�ȝ��旉���消耗�ؓO (n2 l o gn)�?/p>
		
3. 标准单元折叠
		用wi 定义单元Ci 的宽度。每个单元的高度为h。当标准单元行的宽度W 固定不变�Ӟ��通过减少折叠高度�Q�可以相应地减少折叠面积。考察Ci 到Cn 的最���高度折叠。设�W�一个折叠点是Cs+ 1。从元�gCs+1 到Cn 的折叠必���M��用最���高度，否则�Q�可使用更小的高度来折叠Cs+1 到Cn�Q�从而得到更���的折叠高度。所以这里仍可��用最优原理和动态规划方法�?/p>
		
令Hi , s 为Ci 到Cn 折叠成宽为W的矩形时的最���高度，其中�W�一个折叠点为Cs+ 1。��ow s u m(i, s)=s ?j = iwj。可假定没有宽度���过W的元�Ӟ��否则不可能进行折叠。对于Hn,n 因�ؓ只有一个元�Ӟ��不存在连�U�K��题，因此Hn, n =h。对于H i, s�Q?≤i�Q�s≤n�Q�注意到如果w s u m(i, s )�Q�W�Q�不可能实现折叠。若w s u m(i,s)≤W�Q�元件Ci 和C j + 1 在相同的标准单元行中�Q�该行下方布�U�K��道的高度�ؓls+ 1�Q�定义ln+1 = 0�Q�。因而：Hi, s = Hi+1, k �Q? 5 - 1 4�Q?/p>
		
当i=s�Q�n �Ӟ���W�一个标准单元行只包含Ci 。该行的高度为h 且该行下方布�U�K��道的高度�ؓli+ 1。因Ci+ 1 到Cn 单元的折叠是最优的.
		��Z����L��最���高度折叠，首先使用式（ 1 5 - 1 4�Q�和�Q? 5 - 1 5�Q�来���定Hi, s �Q?≤i≤s≤n�Q�。最���高度折叠的高度为m in｛H1 , s｝。可以��用回溯过�E�来���定最���高度折叠中的折叠点�?/p>


保尔�?/a> 2007-02-27 17:10 发表评论


Tue, 27 Feb 2007 03:41:00 GMT

		
				
				//
				建立二叉树�ƈ先根遍历的代�?/span>
				
						

						
						
				
				public
				 
				class
				 BinaryTreeTest 
				
						
				
				
						{
 
						public
						 
						static
						 
						void
						 main(String args[]) 
						
								
						
						
								{
								//
								��L���?/span>
								
										

										
								
								  BinaryTreeTest b 
								=
								 
								new
								 BinaryTreeTest();
  
								int
								 data[] 
								=
								 
								
										
								
								
										{ 
										12
										, 
										11
										, 
										34
										, 
										45
										, 
										67
										, 
										89
										, 
										56
										, 
										43
										, 
										22
										, 
										98
										 }
								
								;
  BinaryTree root 
								=
								 
								new
								 BinaryTree(data[
								0
								]);

  System.out.print(
								"
								二叉树的中的数据�Q�　　
								"
								);

								//
								建立二叉�?/span>
								
										

										
										
								
								  
								for
								 (
								int
								 i 
								=
								 
								1
								; i 
								<
								 data.length; i
								++
								) 
								
										
								
								
										{
   root.insertTree(root, data[i]);
   System.out.print(data[i 
										-
										 
										1
										] 
										+
										 
										"
										;
										"
										);
  }
								
								
										

										
										

										  System.out.println(data[data.length 
								-
								 
								1
								]);

  
								int
								 key 
								=
								 Integer.parseInt(args[
								0
								]);

  
								if
								 (b.searchkey(root, key)) 
								
										
								
								
										{
   System.out.println(
										"
										扑ֈ��?
										"
										 
										+
										 key);
  }
								
								 
								else
								 
								
										
								
								
										{
   System.out.println(
										"
										没有扑ֈ��Q?/span>
										"
										 
										+
										 key);
  }
								
								
										

										 }
						
						
								

								
								

								
								 
						public
						 
						boolean
						 searchkey(BinaryTree root, 
						int
						 key) 
						
								
						
						
								{
								//
								查询
								
										

										
								
								  
								boolean
								 bl 
								=
								 
								false
								;
  
								if
								 (root 
								==
								 
								null
								) 
								
										
								
								
										{
   bl 
										=
										 
										false
										;
   
										return
										 bl;
  }
								
								 
								else
								 
								if
								 (root.data 
								==
								 key) 
								
										
								
								
										{
   bl 
										=
										 
										true
										;
   
										return
										 bl;
  }
								
								 
								else
								 
								if
								 (key 
								>=
								 root.data) 
								
										
								
								
										{
   
										return
										 searchkey(root.rightpoiter, key);
  }
								
								
										

										  
								return
								 searchkey(root.leftpoiter, key);
 }
						
						
								

								}
				
				
						

						
						

						
						
				
				class
				 BinaryTree 
				
						
				
				
						{
						//
						二叉树类
						
								

								
						
						 
						int
						 data;

 BinaryTree leftpoiter;

 BinaryTree rightpoiter;

 BinaryTree(
						int
						 data) 
						
								
						
						
								{
  
								this
								.data 
								=
								 data;
  leftpoiter 
								=
								 
								null
								;
  rightpoiter 
								=
								 
								null
								;
 }
						
						
								

								
								

								
								 
						public
						 
						void
						 insertTree(BinaryTree root, 
						int
						 data) 
						
								
						
						
								{
								//
								插入节点
								
										

										
										
								
								  
								if
								 (data 
								>=
								 root.data) 
								
										
								
								
										{
   
										if
										 (root.rightpoiter 
										==
										 
										null
										) 
										
												
										
										
												{
    root.rightpoiter 
												=
												 
												new
												 BinaryTree(data);
   }
										
										 
										else
										 
										
												
										
										
												{
    insertTree(root.rightpoiter, data);
   }
										
										
												

												
												  }
								
								 
								else
								 
								
										
								
								
										{
   
										if
										 (root.leftpoiter 
										==
										 
										null
										) 
										
												
										
										
												{
    root.leftpoiter 
												=
												 
												new
												 BinaryTree(data);
   }
										
										 
										else
										 
										
												
										
										
												{
    insertTree(root.leftpoiter, data);
   }
										
										
												

												  }
								
								
										

										 }
						
						
								

								}
				
				
						

						
				
				//
				 end
		
		讲解�Q�一个寻扑օ�键字�Q�－searchkey 
另一个是插入一个结点：insertTree 
另外�q�是一个完全的先序遍历二叉树的语法。先根结点，再左�l�点�Q�如无再右结点，如些加归��x��索完毕。 �?/p>


保尔�?/a> 2007-02-27 11:41 发表评论


Mon, 20 Nov 2006 07:28:00 GMT
1。自然数�?�Q?�Q?……

2。素数是2�Q?�Q?……�Q�不包括1的只能背1和它本��n整除的自然数�Q?br />


import java.util.Scanner;



public class Prime {
    //最基本的做�?br />

    private int prime1(int num) {

        int i = 0, s = 0;

        label1: for (int n = 2; n <= num; n++) {

            for (int m = 2; m * m <= n; m++) {

                if (n % m == 0)

                    continue label1;

            }

            s++;

            i++;

            //System.out.println("�W? + i + "个素数是�Q? + n);

        }

        return s;

    }


    //6N±1�?/font>

    private int prime2(int num){

        int i = 0, s = 0;

        for(int n = 2; n <=3; n ++){

            s++;

            i++;

            //System.out.println("�W? + i + "个素数是�Q? + n);

        }

        label1: for(int n = 1; ; n++) {

            label2: for (int m = 0; m <= 1; m++) {

                int tmp = 2 * (3 * n + m) - 1;

                if (tmp > num)

                    break label1;

                for(int k = 2; k * k <= tmp; k++)

                    if (tmp % k == 0)

                        if (m == 0)

                            continue label2;

                        else

                            continue label1;

                s++;

                i++;

                //System.out.println("�W? + i + "个素数是�Q? + tmp);

            }

        }

        return s;

    }



    public static void main(String args[]) {

        Scanner in = new Scanner(System.in);

        int num = in.nextInt();

        long start = System.currentTimeMillis();

        int sum = new Prime().prime1(num);

        long end = System.currentTimeMillis();

        System.out.println("�Ҏ��一�? + sum + "个素�?);

        System.out.println("用时�Q? + (end - start));

        start = System.currentTimeMillis();

        sum = new Prime().prime2(num);

        end = System.currentTimeMillis();

        System.out.println("�Ҏ��二共" + sum + "个素�?);

        System.out.println("用时�Q? + (end - start));

        

    }

}


输入�Q?000000
�q�行�l�果�Q?/p>
�Ҏ��一�?8498个素�?br />
用时�Q?434

�Ҏ��二共78498个素�?br />
用时�Q?453
�Q�看来基本方法比6N±1�?/font>�q�要更快些，奇怪了�Q�我的程序写的没什么问题阿�Q?br />




�?】求10000以内的所有素数�?br />
素数是除�?和它本��n之外再不能被其他数整除的自然数。由于找不到一个通项公式来表�C�所有的素数�Q�所以对于数学家来说�Q�素��C��直是一个未解之谜。像著名�?哥�d巴赫猜想、孪生素数猜惻I��几百�q�来不知吸引了世界上多少优秀的数学家。尽���他们苦心钻研，呕心沥血�Q�但至今仍然未见分晓�?br />
自从有了计算��Z��后，��Z��借助于计���机的威力，已经扑ֈ��?²¹⁶⁰⁹¹以内的所有素数�?br />
求素数的�Ҏ��有很多种�Q�最���单的�Ҏ��是根据素数的定义来求。对于一个自然数N�Q�用大于1���于N的各个自然数都去除一下N�Q�如果都除不���，则N为素敎ͼ�否则N为合数�?br />
但是�Q�如果用素数定义的方法来�~�制计算机程序，它的效率一定是非常低的�Q�其中有许多地方都值得改进�?br />
�W�一�Q�对于一个自然数N�Q�只要能被一个非1非自�w�的数整除，它就肯定不是素数�Q�所以不

必再用其他的数去除�?br />
�W�二�Q�对于N来说�Q�只需用小于N的素数去除就可以了。例如，如果N能被15整除�Q�实�?br />
上就能被3�?整除�Q�如果N不能�?�?整除�Q�那么N也决不会�?5整除�?br />
�W�三�Q�对于N来说�Q�不必用�?到N一1的所有素数去除，只需用小于等�?#8730;N(根号N)的所有素数去除就可以了。这一点可以用反证法来证明�Q?br />
如果N是合敎ͼ�则一定存在大�?���于N的整数d1和d2�Q���得N=d1×d2�?br />
如果d1和d2均大�?#8730;N�Q�则有：N�Q�d1×d2>√N×√N�Q�N�?br />
而这是不可能的，所以，d1和d2中必有一个小于或�{�于√N�?br />
��Z��上述分析�Q�设计算法如下：

(1)�?�Q?�Q?�Q?逐个试除N的方法求�?00以内的所有素数�?br />
(2)�?00以内的所有素数逐个试除的方法求�?0000以内的素数�?br />
首先�Q�将2�Q?�Q?�Q?分别存放在a[1]、a[2]、a[3]、a[4]中，以后每求��Z��个素敎ͼ�只要不大�?00�Q�就依次存放在A数组中的一个单�?中。当我们�?00�?0000之间的素数时�Q�可依次用a[1]�Q�a[2]的素数去试除N�Q�这个范围内的素数可以不保存�Q�直接打印�?br />


�?】用�{�法求素数�?/font>

���单介�l�一下厄拉多塞筛法。厄拉多塞是一位古希腊数学�Ӟ��他在��L��素数�Ӟ��采用了一�U�与众不同的�Ҏ���Q�先��?�Q�N的各数写在纸上：



�?的上面画一个圆圈，然后划去2的其他倍数�Q�第一个既未画圈又没有被划�ȝ��数是3�Q�将它画圈，再划�?的其他倍数�Q�现在既未画圈又没有被划�ȝ���W�一个数 �?�Q�将它画圈，�q�划�?的其他倍数……依次�c�L���Q�一直到所有小于或�{�于N的各数都��M��圈或划去为止。这�Ӟ��表中��M��圈的以及未划�ȝ��那些数正好就是小�?N的素数�?br />


�q�很像一面筛子，把满���x��件的数留下来�Q�把不满���x��件的数筛掉。由于这�U�方法是厄拉多塞首先发明的，所以，后�h���把�q�种�Ҏ���U�C��厄拉多塞�{�法�?br />
在计���机中，�{�法可以用给数组单元�|�零的方法来实现。具体来说就是：首先开一个数�l�：a[i]�Q�i=1�Q?�Q?�Q?#8230;�Q�同�Ӟ��令所有的数组元素都等于下�?��|��即a[i]=i�Q�当i不是素数�Ӟ��令a[i]=0 。当输出�l�果�Ӟ��只要判断a[i]是否�{�于零即可，如果a[i]=0�Q�则令i=i+1�Q�检查下一个a[i]�?br />
�{�法是计���机�E�序设计中常用的���法之一�?br />


�?】用6N±1法求素数�?/font>

��M��一个自然数�Q���d��以表�C�成为如下的形式之一�Q?br />
6N�Q?N+1�Q?N+2�Q?N+3�Q?N+4�Q?N+5 (N=0�Q?�Q?�Q?#8230;)

昄����Q�当N≥1�Ӟ��6N�Q?N+2�Q?N+3�Q?N+4都不是素敎ͼ�只有形如6N+1�?N+5的自然数有可能是素数。所以，除了2�?之外�Q�所有的素数都可以表�C�成6N±1的�Ş�?N�����然数)�?br />
�Ҏ��上述分析�Q�我们可以构造另一面筛子，只对形如6 N±1的自然数�q�行�{�选，�q�样���可以大大减���筛选的�ơ数�Q�从而进一步提高程序的�q�行效率和速度�?br />


在程序上�Q�我们可以用一个二重��@环实现这一点，外��@环i�?的倍数递增�Q�内循环j�?�Q?的��@环，�?(i+j)-1恰好���是形如6N±1的自然数�?/p>


保尔�?/a> 2006-11-20 15:28 发表评论



各种排序���法java实现
Mon, 20 Nov 2006 07:27:00 GMT

		 
插入排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class InsertSort implements SortUtil.Sort{
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=1;i            for(int j=i;(j>0)&&(data[j]                SortUtil.swap(data,j,j-1);
            }
        }        
    }
}
冒��排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class BubbleSort implements SortUtil.Sort{
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=0;i            for(int j=data.length-1;j>i;j--){
                if(data[j]                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }
}
选择排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SelectionSort implements SortUtil.Sort {
    /*
     * (non-Javadoc)
     * 
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for (int i = 0; i < data.length; i++) {
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[lowIndex]) {
                    lowIndex = j;
                }
            }
            SortUtil.swap(data,i,lowIndex);
        }
    }
}
Shell排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ShellSort implements SortUtil.Sort{
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        for(int i=data.length/2;i>2;i/=2){
            for(int j=0;j                insertSort(data,j,i);
            }
        }
        insertSort(data,0,1);
    }
    /**
     * @param data
     * @param j
     * @param i
     */
    private void insertSort(int[] data, int start, int inc) {
        int temp;
        for(int i=start+inc;i            for(int j=i;(j>=inc)&&(data[j]                SortUtil.swap(data,j,j-inc);
            }
        }
    }
}
快速排�?
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class QuickSort implements SortUtil.Sort{
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        quickSort(data,0,data.length-1);        
    }
    private void quickSort(int[] data,int i,int j){
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);
        
        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);
        
    }
    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) {
        do{
           while(data[++l]           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l        SortUtil.swap(data,l,r);        
        return l;
    }
}
改进后的快速排�?
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedQuickSort implements SortUtil.Sort {
    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] stack=new int[MAX_STACK_SIZE];
        
        int top=-1;
        int pivot;
        int pivotIndex,l,r;
        
        stack[++top]=0;
        stack[++top]=data.length-1;
        
        while(top>0){
            int j=stack[top--];
            int i=stack[top--];
            
            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];
            
            SortUtil.swap(data,pivotIndex,j);
            
            //partition
            l=i-1;
            r=j;
            do{
                while(data[++l]                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);
            
            if((l-i)>THRESHOLD){
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD){
                stack[++top]=l+1;
                stack[++top]=j;
            }
            
        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /**
     * @param data
     */
    private void insertSort(int[] data) {
        int temp;
        for(int i=1;i            for(int j=i;(j>0)&&(data[j]                SortUtil.swap(data,j,j-1);
            }
        }       
    }
}
归�ƈ排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class MergeSort implements SortUtil.Sort{
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }
    
    private void mergeSort(int[] data,int[] temp,int l,int r){
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++){
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++){
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];            
        }
    }
}
改进后的归�ƈ排序:
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedMergeSort implements SortUtil.Sort {
    private static final int THRESHOLD = 10;
    /*
     * (non-Javadoc)
     * 
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }
    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);
        for (i = l; i <= mid; i++) {
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) {
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) {
            if (a < b) {
                data[k] = temp[i++];
                a = temp[i];
            } else {
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }
    /**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) {
        for(int i=start+1;i            for(int j=i;(j>start) && data[j]                SortUtil.swap(data,j,j-1);
            }
        }
    }
}
堆排�?
package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class HeapSort implements SortUtil.Sort{
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        MaxHeap h=new MaxHeap();
        h.init(data);
        for(int i=0;i            h.remove();
        System.arraycopy(h.queue,1,data,0,data.length);
    }

     private static class MaxHeap{
         
        
        void init(int[] data){
            this.queue=new int[data.length+1];
            for(int i=0;i                queue[++size]=data[i];
                fixUp(size);
            }
        }
         
        private int size=0;
        private int[] queue;
                
        public int get() {
            return queue[1];
        }
        public void remove() {
            SortUtil.swap(queue,1,size--);
            fixDown(1);
        }
        //fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j]                    j++; 
                if (queue[k]>queue[j]) //不用交换
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j]>queue[k])
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
    }
}
 
SortUtil:
package org.rut.util.algorithm;
import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SortUtil {
    public final static int INSERT = 1;
    public final static int BUBBLE = 2;
    public final static int SELECTION = 3;
    public final static int SHELL = 4;
    public final static int QUICK = 5;
    public final static int IMPROVED_QUICK = 6;
    public final static int MERGE = 7;
    public final static int IMPROVED_MERGE = 8;
    public final static int HEAP = 9;
    public static void sort(int[] data) {
        sort(data, IMPROVED_QUICK);
    }
    private static String[] name={
            "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
    };
    
    private static Sort[] impl=new Sort[]{
            new InsertSort(),
            new BubbleSort(),
            new SelectionSort(),
            new ShellSort(),
            new QuickSort(),
            new ImprovedQuickSort(),
            new MergeSort(),
            new ImprovedMergeSort(),
            new HeapSort()
    };
    public static String toString(int algorithm){
        return name[algorithm-1];
    }
    
    public static void sort(int[] data, int algorithm) {
        impl[algorithm-1].sort(data);
    }
    public static interface Sort {
        public void sort(int[] data);
    }
    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}


保尔�?/a> 2006-11-20 15:27 发表评论

av不卡在线播放,欧美日韩综合一区,蝌蚪视频在线播放

求两个数或多个数的最大公�U�数��法及其实现

1 术语定义

2 朴素匚w��法

3 KMP��法

4 支持通配�W?�?的KMP��法

5 正则语言和确定状态自动机

6 �l�语

java字符串全排列问题�Q�经典）

各种排序��法java实现

av不卡在线播放,欧美日韩综合一区,蝌蚪视频在线播放

求两个数或多个数的最大公�U�数���法及其实现

1 术语定义

2 朴素匚w�����法

3 KMP���法

4 支持通配�W?�?的KMP���法

5 正则语言和确定状态自动机

6 �l�语

java字符串全排列问题�Q�经典）

各种排序���法java实现

求两个数或多个数的最大公�U�数��法及其实现

2 朴素匚w��法

3 KMP��法

4 支持通配�W?�?的KMP��法

各种排序��法java实现