/**
* 希望能帮上你
* 有什么需要修改：请邮件[email protected]
*/
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class TestArray {
/**
* 第一组k[i]: 500,501,502 //球编号
第二组h[j]：500=1，502=1，500=2，502=3 / /球编号=几号箱子
if( 502==502))//两组的球编号匹配{
502-1 3
}
目标：匹配相同后，得到一个二维数组关系如下
500 1 2
502 1 3
问题补充：
匹配意义：如2组都有相同的编号，匹配后，摄入该编号属于的 箱子
*/
public static void main(String[] args) {
/**
* 球编号
*/
String[] ballNumbers={"500","501","502"};
/**
* 球与组号 的关系
*/
String[][] relations={
{"500","1"},
{"502","1"},
{"500","2"},
{"502","3"},
{"502","2"},
{"502","4"},
{"502","3"}};
/**
* 遍历 比较
*/
Map<String,String> resultMap=new HashMap<String,String>();
for(int i=0;i<ballNumbers.length;i++){
String ballNum=ballNumbers[i];
for(int j=0;j<relations.length;j++){
String key=relations[j][0];
String value=relations[j][1];
if(ballNum.equals(key)){
boolean exsits=resultMap.containsKey(ballNum);
if(exsits){
String val=resultMap.get(ballNum);
val=val+":"+value;
resultMap.put(ballNum, val);
}else{
resultMap.put(ballNum, value);
}
}
}
}
/**
* 打印结果 测试
*/
printResult(resultMap);
}
private static void printResult(Map<String, String> resultMap) {
Set<String> keys=resultMap.keySet();
for(String key:keys){
System.out.println(key+"="+resultMap.get(key));
}
}
}
2. 关于二维数组与图的C语言问题
呵呵，我写的程序，可参考一下，记着数组的下标是从0开始的。
#include<stdio.h>
int main()
{
int a[5][5] =
{
{0,0,1,1,0},
{1,1,0,0,1},
{0,1,1,0,0},
{0,0,0,1,0},
{0,1,0,0,1}
};
int nTimes = 0;
do
{
for (int i=0; i<5; i++)
{
int nSumCol = 0; // 列的和
int nSumLin = 0; // 行的和
// 先求行
for (int j=0; j<5; j++)
{
nSumLin += a[i][j];
nSumCol += a[j][i];
}
if (nSumLin == 1)
{
// 找到该行中值为1的坐标
for (int k=0; k<5; k++)
{
if (a[i][k] == 1)
{
printf("a[%d][%d] = %d\n", i, k);
break;
}
}
// 将该行所在列的其他值全部置0
for (int m=0; m<5; m++)
{
a[m][k] = 0;
}
// 它本身置一个特殊值
a[i][k] = -1;
break;
}
if (nSumCol == 1)
{
// 找到该列中值为1的坐标
for (int k=0; k<5; k++)
{
if (a[k][i] == 1)
{
printf("a[%d][%d] = %d\n", k, i);
break;
}
}
// 将该列所在行的其他值全部置0
for (int m=0; m<5; m++)
{
a[k][m] = 0;
}
// 它本身置一个特殊值
a[k][i] = -1;
break;
}
}
nTimes ++;
} while (nTimes < 5);
printf("\nthe result is: \n\n");
for (int i = 0; i<5; i++)
{
for (int j = 0; j<5; j++)
{
printf(" %d", a[i][j]);
}
printf("\n\n");
}
getchar();
return 0;
}
3. asp中，两个二维数组的比较问题，求一个高效的算法。
你说的数据库应该就是很快了
4. 矩阵由0和1组成,求不同行不同列1的个数，c++编程
7.16
我好好想想再回复你。现在思路还没完全清晰。
7.17
我想到了一个简单方法：
对于n*n的矩阵，它的不同行不同列1的个数最大值是n，如果取值小于n，比如为n-1，那么行列式必然有某一行或/和某一列全为零。那么，如果取值为n-i，n-1，那么行列式必然有 i 行或/和列全为零。然后我们就可以按行和列依次遍历。大概明白了吧？
在写程序时，定义一个二维数组a[n][n]，用于存放矩阵数据。定义两个整型数m和n，初始值都为0，分别用于存放行遍历和列遍历的非零单行和单列的个数。比如遍历第一单行的时候，遇到一个1，就把m加1，然后跳出，进入第二列遍历，依次循环下去到循环结束。然后再按一样的方式进行列遍历。最后比较m和n，取值较小者，就是所求的个数了。复杂度为n^2,
当然还有比较麻烦的方法就是用树了，复杂度为n！
有什么新的想法或问题，欢迎探讨！嘿嘿
5. 如何求两个任意长度字符串中的最长匹配子串
//求使用最长子串使用LCS算法
char* LCS(char left[],char right[]) { //获取左子串的长度,获取右子串的长度 int lenLeft=strlen(left),lenRight=strlen(right),k; //注意这里要写成char型,而不是int型,否则输入整型数据时会产生错误。 //矩阵c纪录两串的匹配情况 char*c=malloc(lenRight),*p; //int c[M][M]={0};//当将c申明为一个二维数组时 int start,end,len,i,j;//start表明最长公共子串的起始点，end表明最长公共子串的终止点 end=len=0;//len表示最长公共子串的长度 for(i=0; i<lenLeft; i++) //串1从前向后比较 { //串2从后向前比较,为什么要从后向前呢?是把一维数组c[ ]当二维数组来用, //如果要从前向后,可以将c申明为一个二维数组c[M][M].但程序要做相应调整. // for(j=0;j<lenRight;j++)//当c申明为一个二维数组时 for(j=lenRight-1; j>=0; j--) { if(left[i] == right[j])//元素相等时 { if(i==0||j==0) c[j]=1;//c[i][j]=1; else { c[j]=c[j-1]+1;//c[i][j]=c[i-1][j-1]+1; } } else c[j] = 0; //c[i][j]=0; if(c[j] > len) //if (c[i][j]>len) { len=c[j]; //len=c[i][j]; end=j; } } } start=end-len+1; //数组p纪录最长公共子串 p =(char*)malloc(len+1); for(i=start; i<=end; i++) { p[i-start] = right[i]; } p[len]='\0'; return p; } void main() { char str1[M],str2[M]; printf("请输入字符串1:"); gets(str1) printf("请输入字符串2:"); gets(str2); printf("最长子串为:"); printf("%s\n",LCS(str1,str2)); }
6. 请教一个关于二维数组的算法
如果仅仅对于6×9这么小的矩阵来说，可以直接循环寻找各个方向的匹配，源代码如下:
#include <cstdio>
#include <cstring>
using namespace std;
int Array[6][9] =
{
{1,1,0,1,0,0,1,0,0},
{4,1,1,0,0,0,1,4,0},
{4,0,0,1,1,4,4,1,0},
{0,0,0,0,0,1,0,1,0},
{0,0,1,1,4,1,0,1,0},
{0,0,0,0,4,0,0,0,0},
};
int mo[5] = {1,1,4,1,1};
bool check_right(int a,int b) //右方向
{
int i;
for (i=0;i<5;i++) if (b + i >= 9) return false;
else if (Array[a][b + i] != mo[i]) return false;
return true;
}
bool check_down(int a,int b) //下方向
{
int i;
for (i=0;i<5;i++) if (a + i >= 6) return false;
else if (Array[a + i][b] != mo[i]) return false;
return true;
}
bool check_left_down(int a,int b) //左下方向
{
int i;
for (i=0;i<5;i++) if (a + i >= 6 || b - i < 0) return false;
else if (Array[a + i][b - i] != mo[i]) return false;
return true;
}
bool check_right_down(int a,int b) //右下方向
{
int i;
for (i=0;i<5;i++) if (a + i >= 6 || b + i >= 9) return false;
else if (Array[a + i][b + i] != mo[i]) return false;
return true;
}
int main()
{
int i,j;
for (i=0;i<6;i++)
for (j=0;j<9;j++)
{
if (check_right(i,j)) printf("%d %d right\n",i,j);
if (check_down(i,j)) printf("%d %d down\n",i,j);
if (check_left_down(i,j)) printf("%d %d left_down\n",i,j);
if (check_right_down(i,j)) printf("%d %d right_down\n",i,j);
// 由于模板文本具有回文性质,故只需匹配4个方向,若对于任意模板文本,追加检查剩余的四个方向即可.
}
return 0;
}
若对于较为巨大的矩阵以及较多的模板文本，（例如500×500的矩阵，500个文本），如果需要在较短的时间内完成算法（如1秒）需要使用后缀自动机，具体到这个问题就是trie图，一种基于后缀有限状态自动机（Suffix DFA）的专门用于处理多串匹配的数据结构，其构造方法大致是先构造模板文本的trie树，再通过后缀链接生成包含所有转移的trie图。参考源代码如下：
（此代码从控制台读入一个最大支持到1000×1000的字符矩阵，以及最多1000个文本，程序向控制台输出每一个文本在矩阵中的起始位置和方向，以A-H表示八个方向，在Intel Pentium D 2.1G的处理器上对于任何数据均可在1s内完成运算)
#include <stdio.h>
#include <string.h>
int n,m,l,totalnode;
#define N 1100
#define M 1100000
char data[N][N];
char word[N];
typedef struct
{
int suffix,kind;
int c[26];
}trieT;
trieT trie[M];
typedef struct
{
int a,b;
char oper;
} ans_type;
ans_type ans[N];
int Q[M];
char nowoper;
const int thitah[8]={1,1,0,-1,-1,-1,0,1};
const int thital[8]={0,-1,-1,-1,0,1,1,1};
void read_data()
{
scanf("%d %d %d%*c",&n,&m,&l);
int i,j;
for (i=1;i<=n;i++)
{
for (j=1;j<=m;j++) {scanf("%c",&data[i][j]);data[i][j]-='A';}
scanf("%*c");
}
}
void insert(int s,int len)
{
int i,pnt=1;
for (i=len-1;i>=0;i--)
{
if (trie[pnt].c[word[i]]!=0) pnt=trie[pnt].c[word[i]];
else
{
totalnode++;
trie[pnt].c[word[i]]=totalnode;
pnt=totalnode;
trie[pnt].kind=-1;trie[pnt].suffix=0;
memset(trie[pnt].c,0,sizeof(trie[pnt].c));
}
}
trie[pnt].kind=s;
}
void init()
{
totalnode=1;
trie[1].kind=-1;trie[1].suffix=1;
memset(trie[1].c,0,sizeof(trie[1].c));
int i,j,len;
for (i=1;i<=l;i++)
{
scanf("%s",&word);
len=strlen(word);
for (j=0;j<len;j++) word[j]-='A';
insert(i,len);
}
}
void make_trie_graph()
{
int i,temp,tempnode,cl,op;
cl=0;op=0;
for (i=0;i<26;i++) if (trie[1].c[i]!=0)
{
temp=trie[1].c[i];
trie[temp].suffix=1;
if (trie[temp].kind==-1) trie[temp].kind=trie[1].kind;
Q[++op]=temp;
}else trie[1].c[i]=1;
while (cl<op)
{
tempnode=Q[++cl];
for (i=0;i<26;i++) if (trie[tempnode].c[i]!=0)
{
temp=trie[tempnode].c[i];
trie[temp].suffix=trie[trie[tempnode].suffix].c[i];
if (trie[temp].kind==-1) trie[temp].kind=trie[trie[temp].suffix].kind;
Q[++op]=temp;
}else trie[tempnode].c[i]=trie[trie[tempnode].suffix].c[i];
}
}
void get_ans(int s,int h,int l)
{
while (trie[s].kind!=-1)
{
ans[trie[s].kind].a=h;ans[trie[s].kind].b=l;
ans[trie[s].kind].oper=nowoper;
s=trie[s].suffix;
}
}
void check(int h,int l)
{
int pnt=1;
while ((h>0) && (h<=n) && (l>0) && (l<=m))
{
pnt=trie[pnt].c[data[h][l]];
if (trie[pnt].kind!=-1) get_ans(pnt,h,l);
h+=thitah[nowoper];l+=thital[nowoper];
}
}
void work_ans()
{
int i;
nowoper=0;for (i=1;i<=m;i++) check(1,i);
nowoper=1;for (i=1;i<=m;i++) check(1,i);for (i=2;i<=n;i++) check(i,m);
nowoper=2;for (i=1;i<=n;i++) check(i,m);
nowoper=3;for (i=1;i<=n;i++) check(i,m);for (i=1;i<m;i++) check(n,i);
nowoper=4;for (i=1;i<=m;i++) check(n,i);
nowoper=5;for (i=1;i<=m;i++) check(n,i);for (i=1;i<n;i++) check(i,1);
nowoper=6;for (i=1;i<=n;i++) check(i,1);
nowoper=7;for (i=1;i<=n;i++) check(i,1);for (i=2;i<=m;i++) check(1,i);
}
void show_ans()
{
int i;
for (i=1;i<=l;i++) printf("%d %d %c\n",ans[i].a-1,ans[i].b-1,ans[i].oper+'A');
}
int main()
{
read_data();
init();
make_trie_graph();
work_ans();
show_ans();
return 0;
}
若楼主希望学习trie图的具体理论和构造方法，可回帖注明。
7. 算法效率与分析
算法效率与分析
数据结构作为程序设计的基础，其对算法效率的影响必然是不可忽视的。本文就如何合理选择数据结构来优化算法这一问题，对选择数据结构的原则和方法进行了一些探讨。首先对数据逻辑结构的重要性进行了分析，提出了选择逻辑结构的两个基本原则；接着又比较了顺序和链式两种存储结构的优点和缺点，并讨论了选择数据存储结构的方法；最后本文从选择数据结构的的另一角度出发，进一步探讨了如何将多种数据结构进行结合的方法。在讨论方法的同时，本文还结合实际，选用了一些较具有代表性的信息学竞赛试题举例进行了分析
【正文】一、引论
“数据结构＋算法＝程序”，这就说明程序设计的实质就是对确定的问题选择一种合适的数据结构，加上设计一种好的算法。由此可见，数据结构在程序设计中有着十分重要的地位。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。因为这其中的“关系”，指的是数据元素之间的逻辑关系，因此数据结构又称为数据的逻辑结构。而相对于逻辑结构这个比较抽象的概念，我们将数据结构在计算机中的表示又称为数据的存储结构。
建立问题的数学模型，进而设计问题的算法，直至编出程序并进行调试通过，这就是我们解决信息学问题的一般步骤。我们要建立问题的数学模型，必须首先找出问题中各对象之间的关系，也就是确定所使用的逻辑结构；同时，设计算法和程序实现的过程，必须确定如何实现对各个对象的操作，而操作的方法是决定于数据所采用的存储结构的。因此，数据逻辑结构和存储结构的好坏，将直接影响到程序的效率。
二、选择合理的逻辑结构
在程序设计中，逻辑结构的选用就是要分析题目中的数据元素之间的关系，并根据这些特定关系来选用合适的逻辑结构以实现对问题的数学描述，进一步解决问题。逻辑结构实际上是用数学的方法来描述问题中所涉及的操作对象及对象之间的关系，将操作对象抽象为数学元素，将对象之间的复杂关系用数学语言描述出来。
根据数据元素之间关系的不同特性，通常有以下四种基本逻辑结构：集合、线性结构、树形结构、图状（网状）结构。这四种结构中，除了集合中的数据元素之间只有“同属于一个集合”的关系外，其它三种结构数据元素之间分别为“一对一”、“一对多”、“多对多”的关系。
因此，在选择逻辑结构之前，我们应首先把题目中的操作对象和对象之间的关系分析清楚，然后再根据这些关系的特点来合理的选用逻辑结构。尤其是在某些复杂的问题中，数据之间的关系相当复杂，且选用不同逻辑结构都可以解决这一问题，但选用不同逻辑结构实现的算法效率大不一样。
对于这一类问题，我们应采用怎样的标准对逻辑结构进行选择呢？
下文将探讨选择合理逻辑结构应充分考虑的两个因素。
一、 充分利用“可直接使用”的信息。
首先，我们这里所讲的“信息”，指的是元素与元素之间的关系。
对于待处理的信息，大致可分为“可直接使用”和“不可直接使用”两类。对于“可直接使用”的信息，我们使用时十分方便，只需直接拿来就可以了。而对于“不可直接使用”的这一类，我们也可以通过某些间接的方式，使之成为可以使用的信息，但其中转化的过程显然是比较浪费时间的。
由此可见，我们所需要的是尽量多的“可直接使用”的信息。这样的信息越多，算法的效率就会越高。
对于不同的逻辑结构，其包含的信息是不同的，算法对信息的利用也会出现不同的复杂程度。因此，要使算法能够充分利用“可直接使用”的信息，而避免算法在信息由“不可直接使用”向“可直接使用”的转化过程中浪费过多的时间，我们必然需要采用一种合理的逻辑结构，使其包含更多“可直接使用”的信息。
〖问题一〗 IOI99的《隐藏的码字》。
〖问题描述〗
问题中给出了一些码字和一个文本，要求编程找出文本中包含这些码字的所有项目，并将找出的项目组成一个最优的“答案”，使得答案中各项目所包含的码字长度总和最大。每一个项目包括一个码字，以及该码字在文本中的一个覆盖序列（如’abcadc’就是码字’abac’的一个覆盖序列），并且覆盖序列的长度不超过1000。同时，“答案”要求其中每个项目的覆盖序列互相没有重叠。
〖问题分析〗
对于此题，一种较容易得出的基本算法是：对覆盖序列在文本中的终止位置进行循环，再判断包含了哪些码字，找出所有项目，并最后使用动态规划的方法将项目组成最优的“答案”。
算法的其它方面我们暂且不做考虑，而先对问题所采用的逻辑结构进行选择。
如果我们采用线性的逻辑结构（如循环队列），那么我们在判断是否包含某个码字t时，所用的方法为：初始时用指针p指向终止位置，接着通过p的不断前移，依次找出码字t从尾到头的各个字母。例如码字为“ABDCAB”，而文本图1-1，终止位置为最右边的箭头符号，每个箭头代表依次找到的码字的各个字母。
指针p的移动方向
A B D C A B
C D A C B D C A D C D B A D C C B A D
图1-1
由于题目规定码字的覆盖序列长度不超过1000，所以进行这样的一次是否包含的判断，其复杂度为O(1000)。
由于码字t中相邻两字母在文本中的位置，并非只有相邻(如图1-1中的’D’和’C’)这一种关系，中间还可能间隔了许多的字母(如图1-1中’C’和’A’就间隔了2个字母)，而线性结构中拥有的信息，仅仅只存在于相邻的两元素之间。通过这样简单的信息来寻找码字的某一个字母，其效率显然不高。
如果我们建立一个有向图，其中顶点i(即文本的第i位)用52条弧分别连接’a’..’z’,’A’..’Z’这52个字母在i位以前最后出现的位置（如图1-2的连接方式），我们要寻找码字中某个字母的前一个字母，就可以直接利用已连接的边，而不需用枚举的方法。我们也可以把问题看为：从有向图的一个顶点出发，寻找一条长度为length(t)-1的路径，并且路径中经过的顶点，按照码字t中的字母有序。
C D A C B D C A D C D B A D C C B A D
图1-2
通过计算，用图进行记录在空间上完全可以承受(记录1000个点×52条弧×4字节的长整型=200k左右)。在时间上，由于可以充分利用第i位和第i+1位弧的连接方式变化不大这一点(如图1-2所示，第i位和第i+1位只有一条弧的指向发生了变化，即第i+1位将其中一条弧指向了第i位)，所以要对图中的弧进行记录，只需对弧的指向进行整体赋值，并改变其中的某一条弧即可。
因此，我们通过采用图的逻辑结构，使得寻找字母的效率大大提高，其判断的复杂度为O(length(t))，最坏为O(100)，比原来方法的判断效率提高了10倍。
（附程序codes.pas）
对于这个例子，虽然用线性的数据结构也可以解决，但由于判断的特殊性，每次需要的信息并不能从相邻的元素中找到，而线性结构中只有相邻元素之间存在关系的这一点，就成为了一个很明显的缺点。因此，问题一线性结构中的信息，就属于“不可直接使用”的信息。相对而言，图的结构就正好满足了我们的需要，将所有可能产生关系的点都用弧连接起来，使我们可以利用弧的关系，高效地进行判断寻找的过程。虽然图的结构更加复杂，但却将“不可直接使用”的信息，转化成为了“可直接使用”的信息，算法效率的提高，自然在情理之中。。
二、 不记录“无用”信息。
从问题一中我们看到，由于图结构的信息量大，所以其中的信息基本上都是“可用”的。但是，这并不表示我们就一定要使用图的结构。在某些情况下，图结构中的“可用”信息，是有些多余的。
信息都“可用”自然是好事，但倘若其中“无用”（不需要）的信息太多，就只会增加我们思考分析和处理问题时的复杂程度，反而不利于我们解决问题了。
〖问题二〗 湖南省1997年组队赛的《乘船问题》
〖问题描述〗
有N个人需要乘船，而每船最多只能载两人，且必须同名或同姓。求最少需要多少条船。
〖问题分析〗
看到这道题，很多人都会想到图的数据结构：将N个人看作无向图的N个点，凡同名或同姓的人之间都连上边。
要满足用船最少的条件，就是需要尽量多的两人共乘一条船，表现在图中就是要用最少的边完成对所有顶点的覆盖。这就正好对应了图论的典型问题：求最小边的覆盖。所用的算法为“求任意图最大匹配”的算法。
使用“求任意图最大匹配”的算法比较复杂(要用到扩展交错树，对花的收缩等等)，效率也不是很高。因此，我们必须寻找一个更简单高效的方法。
首先，由于图中任两个连通分量都是相对独立的，也就是说任一条匹配边的两顶点，都只属于同一个连通分量。因此，我们可以对每个连通分量分别进行处理，而不会影响最终的结果。
同时，我们还可以对需要船只s的下限进行估计：
对于一个包含Pi个顶点的连通分量，其最小覆盖边数显然为[Pi/2]。若图中共有L个连通分量，则s=∑[Pi/2](1<=i<=L)。
然后，我们通过多次尝试，可得出一个猜想：
实际需要的覆盖边数完全等于我们求出的下限∑[Pi/2](1<=i<=L)。
要用图的结构对上述猜想进行证明，可参照以下两步进行：
1． 连通分量中若不存在度为1的点，就必然存在回路。
2． 从图中删去度为1的点及其相邻的点，或删去回路中的任何一边，连通分量依然连通，即连通分量必然存在非桥边。
由于图的方法不是这里的重点，所以具体证明不做详述。而由采用图的数据结构得出的算法为：每次输出一条非桥的边，并从图中将边的两顶点删去。此算法的时间复杂度为O(n3)。（寻找一条非桥边的复杂度为O(n2)，寻找覆盖边操作的复杂度为O(n)）
由于受到图结构的限制，时间复杂度已经无法降低，所以如果我们要继续对算法进行优化，只有考虑使用另一种逻辑结构。这里，我想到了使用二叉树的结构，具体说就是将图中的连通分量都转化为二叉树，用二叉树来解决问题。
首先，我们以连通分量中任一个顶点作为树根，然后我们来确定建树的方法。
1． 找出与根结点i同姓的点j（j不在二叉树中）作为i的左儿子，再以j为树根建立子树。
2． 找出与根结点i同名的点k（k不在二叉树中）作为i的右儿子，再以k为树根建立子树。
如图2-1-1中的连通分量，我们通过上面的建树方法，可以使其成为图2-1-2中的二叉树的结构(以结点1为根)。（两点间用实线表示同姓，虚线表示同名）
图2-1-2
图2-1-1
接着，我就来证明这棵树一定包含了连通分量中的所有顶点。
【引理2.1】
若二叉树T中包含了某个结点p，那么连通分量中所有与p同姓的点一定都在T中。
证明：
为了论证的方便，我们约定：s表示与p同姓的顶点集合；lc[p,0]表示结点p，lc[p,i](i>0)表示lc[p,i-1]的左儿子，显然lc[p,i]与p是同姓的。
假设存在某个点q，满足qs且qT。由于s是有限集合，因而必然存在某个lc[p,k]无左儿子。则我们可以令lc[p,k+1]=q，所以qT，与假设qT相矛盾。
所以假设不成立，原命题得证。
由引理2.1的证明方法，我们同理可证引理2.2。
【引理2.2】
若二叉树T中包含了某个结点p，那么连通分量中所有与p同名的点一定都在T中。
有了上面的两个引理，我们就不难得出下面的定理了。
【定理一】
以连通分量中的任一点p作为根结点的二叉树，必然能够包含连通分量中的所有顶点。
证明：
由引理2.1和引理2.2，所有与p同姓或同名的点都一定在二叉树中，即连通分量中所有与p有边相连的点都在二叉树中。由连通分量中任两点间都存在路径的特性，该连通分量中的所有点都在二叉树中。
在证明二叉树中包含了连通分量的所有顶点后，我们接着就需要证明我们的猜想，也就是下面的定理：
【定理二】包含m个结点的二叉树Tm，只需要船的数量为boat[m]=[m/2](mN)。
证明：
(i) 当m=1,m=2,m=3时命题显然成立。
图2-2-1
图2-2-2
图2-2-3
(ii) 假设当m<k(k>3)时命题成立，那么当m=k时，我们首先从树中找到一个层次最深的结点，并假设这个结点的父亲为p。那么，此时有且只有以下三种情况（结点中带有阴影的是p结点）：
(1) 如图2-2-1，p只有一个儿子。此时删去p和p唯一的儿子，Tk就成为了Tk-2，则boat[k]=boat[k-2]+1=[(k-2)/2]+1=[k/2]。
(2) 如图2-2-2，p有两个儿子，并且p是其父亲的左儿子。此时可删去p和p的右儿子，并可将p的左儿子放到p的位置上。同样地，Tk成为了Tk-2，boat[k]=boat[k-2]+1=[k/2]。
(3) 如图2-2-3，p有两个儿子，并且p是其父亲的右儿子。此时可删去p和p的左儿子，并可将p的右儿子放到p的位置上。情况与(2)十分相似，易得此时得boat[k]=boat[k-2]+1=[k/2]。
综合(1)、(2)、(3)，当m=k时，boat[k]=[k/2]。
最后，综合(i)、(ii)，对于一切mN，boat[m]=[m/2]。
由上述证明，我们将问题中数据的图结构转化为树结构后，可以得出求一棵二叉树的乘船方案的算法：
proc try(father:integer;var root:integer;var rest:byte);
{输出root为树根的子树的乘船方案，father=0表示root是其父亲的左儿子，
father=1表示root是其父亲的右儿子，rest表示输出子树的乘船方案后，
是否还剩下一个根结点未乘船}
begin
visit[root]:=true; {标记root已访问}
找到一个与root同姓且未访问的结点j;
if j<>n+1 then try(0,j,lrest);
找到一个与root同姓且未访问的结点k;
if k<>n+1 then try(1,k,rrest);
if (lrest=1) xor (rrest=1) then begin {判断root是否只有一个儿子，情况一}
if lrest=1 then print(lrest,root) else print(rrest,root);
rest:=0;
end
else if (lrest=1) and (rrest=1) then begin {判断root是否有两个儿子}
if father=0 then begin
print(rrest,root);root:=j; {情况二}
end
else begin
print(lrest,root);root:=k; {情况三}
end;
rest:=1;
end
else rest:=1;
end;
这只是输出一棵二叉树的乘船方案的算法，要输出所有人的乘船方案，我们还需再加一层循环，用于寻找各棵二叉树的根结点，但由于每个点都只会访问一次，寻找其左右儿子各需进行一次循环，所以算法的时间复杂度为O(n2)。（附程序boat.pas）
最后，我们对两种结构得出不同时间复杂度算法的原因进行分析。其中最关键的一点就是因为二叉树虽然结构相对较简单，但已经包含了几乎全部都“有用”的信息。由我们寻找乘船方案的算法可知，二叉树中的所有边不仅都发挥了作用，而且没有重复的使用，可见信息的利用率也是相当之高的。
既然采用树结构已经足够，图结构中的一些信息就显然就成为了“无用”的信息。这些多余的“无用”信息，使我们在分析问题时难于发现规律，也很难找到高效的算法进行解决。这正如迷宫中的墙一样，越多越难走。“无用”的信息，只会干扰问题的规律性，使我们更难找出解决问题的方法。
小结
我们对数据的逻辑结构进行选择，是构造数学模型一大关键，而算法又是用来解决数学模型的。要使算法效率高，首先必须选好数据的逻辑结构。上面已经提出了选择逻辑结构的两个条件（思考方向），总之目的是提高信息的利用效果。利用“可直接使用”的信息，由于中间不需其它操作，利用的效率自然很高；不不记录“无用”的信息，就会使我们更加专心地研究分析“有用”的信息，对信息的使用也必然会更加优化。
总之，在解决问题的过程中，选择合理的逻辑结构是相当重要的环
三、 选择合理的存储结构
数据的存储结构，分为顺序存储结构和链式存储结构。顺序存储结构的特点是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系；链式存储结构则是借助指示元素存储地址的指针表示数据元素之间的逻辑关系。
因为两种存储结构的不同，导致这两种存储结构在具体使用时也分别存在着优点和缺点。
这里有一个较简单的例子：我们需要记录一个n×n的矩阵，矩阵中包含的非0元素为m个。
此时，我们若采用顺序存储结构，就会使用一个n×n的二维数组，将所有数据元素全部记录下来；若采用链式存储结构，则需要使用一个包含m个结点的链表，记录所有非0的m个数据元素。由这样两种不同的记录方式，我们可以通过对数据的不同操作来分析它们的优点和缺点。
1． 随机访问矩阵中任意元素。由于顺序结构在物理位置上是相邻的，所以可以很容易地获得任意元素的存储地址，其复杂度为O(1)；对于链式结构，由于不具备物理位置相邻的特点，所以首先必须对整个链表进行一次遍历，寻找需进行访问的元素的存储地址，其复杂度为O(m)。此时使用顺序结构显然效率更高。
2． 对所有数据进行遍历。两种存储结构对于这种操作的复杂度是显而易见的，顺序结构的复杂度为O(n2)，链式结构为O(m)。由于在一般情况下m要远小于n2，所以此时链式结构的效率要高上许多。
除上述两种操作外，对于其它的操作，这两种结构都不存在很明显的优点和缺点，如对链表进行删除或插入操作，在顺序结构中可表示为改变相应位置的数据元素。
既然两种存储结构对于不同的操作，其效率存在较大的差异，那么我们在确定存储结构时，必须仔细分析算法中操作的需要，合理地选择一种能够“扬长避短”的存储结构。
一、合理采用顺序存储结构。
我们在平常做题时，大多都是使用顺序存储结构对数据进行存储。究其原因，一方面是出于顺序结构操作方便的考虑，另一方面是在程序实现的过程中，使用顺序结构相对于链式结构更便于对程序进行调试和查找错误。因此，大多数人习惯上认为，能够使用顺序结构进行存储的问题，最“好”采用顺序存储结构。
其实，这个所谓的“好”只是一个相对的标准，是建立在以下两个前提条件之下的：
1． 链式结构存储的结点与顺序结构存储的结点数目相差不大。这种情况下，由于存储的结点数目比较接近，使用链式结构完全不能体现出记录结点少的优点，并且可能会由于指针操作较慢而降低算法的效率。更有甚者，由于指针自身占用的空间较大，且结点数目较多，因而算法对空间的要求可能根本无法得到满足。
2． 并非算法效率的瓶颈所在。由于不是算法最费时间的地方，这里是否进行改进，显然是不会对整个算法构成太大影响的，若使用链式结构反而会显得操作过于繁琐。
二、必要时采用链式存储结构。
上面我对使用顺序存储结构的条件进行了分析，最后就只剩下何时应该采用链式存储结构的问题了。
由于链式结构中指针操作确实较繁琐，并且速度也较慢，调试也不方便，因而大家一般都不太愿意用链式的存储结构。但是，这只是一般的观点，当链式结构确实对算法有很大改进时，我们还是不得不进行考虑的。
〖问题三〗 IOI99的《地下城市》。
〖问题描述〗
已知一个城市的地图，但未给出你的初始位置。你需要通过一系列的移动和探索，以确定初始时所在的位置。题目的限制是：
1． 不能移动到有墙的方格。
2． 只能探索当前所在位置四个方向上的相邻方格。
在这两个限制条件下，要求我们的探索次数（不包括移动）尽可能的少。
〖问题分析〗
由于存储结构要由算法的需要确定，因此我们首先来确定问题的算法。
经过对问题的分析，我们得出解题的基本思想：先假设所有无墙的方格都可能是初始位置，再通过探索一步步地缩小初始位置的范围，最终得到真正的初始位置。同时，为提高算法效率，我们还用到了分治的思想，使我们每一次探索都尽量多的缩小初始位置的范围(使程序尽量减少对运气的依赖)。
接着，我们来确定此题的存储结构。
由于这道题的地图是一个二维的矩阵，所以一般来讲，采用顺序存储结构理所当然。但是，顺序存储结构在这道题中暴露了很大的缺点。我们所进行的最多的操作，一是对初始位置的范围进行筛选，二是判断要选择哪个位置进行探索。而这两种操作，所需要用到的数据，只是庞大地图中很少的一部分。如果采用顺序存储结构(如图3-1中阴影部分表示已标记)，无论你需要用到多少数据，始终都要完全的遍历整个地图。
4
3
2
1
1 2 3 4
图3-1
head
图3-2
然而，如果我们采用的是链式存储结构(如图3-2的链表)，那么我们需要多少数据，就只会遍历多少数据，这样不仅充分发挥了链式存储结构的优点，而且由于不需单独对某一个数据进行提取，每次都是对所有数据进行判断，从而避免了链式结构的最大缺点。
我们使用链式存储结构，虽然没有降低问题的时间复杂度(链式存储结构在最坏情况下的存储量与顺序存储结构的存储量几乎相同)，但由于体现了前文所述选择存储结构时扬长避短的原则，因而算法的效率也大为提高。（程序对不同数据的运行时间见表3-3）
测试数据编号 使用顺序存储结构的程序 使用链式存储结构的程序
1 0.06s 0.02s
2 1.73s 0.07s
3 1.14s 0.06s
4 3.86s 0.14s
5 32.84s 0.21s
6 141.16s 0.23s
7 0.91s 0.12s
8 6.92s 0.29s
9 6.10s 0.23s
10 17.41s 0.20s
表3-3
（附使用链式存储结构的程序under.pas）
我们选择链式的存储结构，虽然操作上可能稍复杂一些，但由于改进了算法的瓶颈，算法的效率自然也今非昔比。由此可见，必要时选择链式结构这一方法，其效果是不容忽视的。
小结
合理选择逻辑结构，由于牵涉建立数学模型的问题，可能大家都会比较注意。但是对存储结构的选择，由于不会对算法复杂度构成影响，所以比较容易忽视。那么，这种不能降低算法复杂度的方法是否需要重视呢？
大家都知道，剪枝作为一种常用的优化算法的方法，被广泛地使用，但剪枝同样是无法改变算法的复杂度的。因此，作用与剪枝相似的存储结构的合理选择，也是同样很值得重视的。
总之，我们在设计算法的过程中，必须充分考虑存储结构所带来的不同影响，选择最合理的存储结构。
四、 多种数据结构相结合
上文所探讨的，都是如何对数据结构进行选择，其中包含了逻辑结构的选择和存储结构的选择，是一种具有较大普遍性的算法优化方法。对于多数的问题，我们都可以通过选择一种合理的逻辑结构和存储结构以达到优化算法的目的。
但是，有些问题却往往不如人愿，要对这类问题的数据结构进行选择，常常会顾此失彼，有时甚至根本就不存在某一种合适的数据结构。此时，我们是无法选择出某一种合适的数据结构的，以上的方法就有些不太适用了。
为解决数据结构难以选择的问题，我们可以采用将多种数据结构进行结合的方法。通过多种数据结构相结合，达到取长补短的作用，使不同的数据结构在算法中发挥出各自的优势。
这只是我们将多种数据结构进行结合的总思想，具体如何进行结合，我们可以先看下面的例子。
我们可以采用映射的方法，将线性结构中的元素与堆中间的结点一一对应起来，若线性的数组中的元素发生变化，堆中相应的结点也接着变化，堆中的结点发生变化，数组中相应的元素也跟着变化。
将两种结构进行结合后，无论是第一步还是第二步，我们都不需对所有元素进行遍历，只需进行常数次复杂度为O(log2n)的堆化操作。这样，整个时间复杂度就成为了O(nlog2n)，算法效率无疑得到了很大提高。
五、 总结
我们平常使用数据结构，往往只将其作为建立模型和算法实现的工具，而没有考虑这种工具对程序效率所产生的影响。信息学问题随着难度的不断增大，对算法时空效率的要求也越来越高，而算法的时空效率，在很大程度上都受到了数据结构的制约。
8. C语言中对于这样的一个二维数组运算表达式s=s+a[k][i]的计算方法是什么
数组a中k+1行i+2列中的值加上s的值
9. java二维数组请教，求个算法，难！
public class Main {
public static void main(String[] args) {
int[][] arrSource = {{1, 2, 3, 4},
{4, 5, 6, 7}};
int[][] arrTarget = {{7, 8, 9, 10},
{10, 11, 12, 13, 14}
};
int[][][] result = myMatch(arrSource, arrTarget);
}
/***
* 合并两二维数组
* @param arr1
* @param arr2
* @return
*/
private static int[][] arrUnion(int[][] arr1, int[][] arr2) {
int newRowCount = arr1.length + arr2.length;
int newColCount = arr1[0].length > arr2[0].length ? arr1[0].length : arr2[0].length;
int[][] unionedArr = new int[newRowCount][newColCount];
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
unionedArr[i][j] = arr1[i][j];
}
}
for (int i = arr1.length; i < newRowCount; i++) {
for (int j = 0; j < arr2[0].length; j++) {
unionedArr[i][j] = arr2[i + arr2.length - newRowCount][j];
}
}
return unionedArr;
}
/***
* 自定义匹配
* @param arrSource
* @param arrTarget
* @return
*/
private static int[][][] myMatch(int[][] arrSource, int[][] arrTarget) {
int[][][] result = new int[arrSource[0].length][arrSource.length][arrSource[0].length];
for (int curCol = 0; curCol < arrSource[0].length; curCol++) {
int[][] arrSource2 = new int[arrSource.length][arrSource[0].length];
for (int i = 0; i < arrSource.length; i++) {
for (int j = 0; j < arrSource[0].length; j++) {
arrSource2[i][j] = arrSource[i][curCol];
}
}
int[][] arrUnioned = arrUnion(arrSource2, arrTarget);
result[curCol] = arrUnioned;
}
return result;
}
}
10. C语言数据结构中串和数组的三个问题！！高手速来！急！！在线等！
第一题 结果为 m*(n-m+1) 比如 子串 001 主串 0001 这就是最坏情况
第二题 第一问 求a[5][7] 由a[0][0]=1000(地址); a[0][1]=1006(因为6个字节) ;所以对于a[5][7]可以用（5*8+7）*6+1000=1282;或者直接用1000+(6*8-1)*6=1282;同理a[1][4]用(1*8+4)*6+1000=1072;
第三题 由题a[1][1]=2048(地址) 因为按列储存 所以a[32][58] 就为
((58-1)*60+32-1)*2+2048=9050; 其实可以把二维数组相像成想x-y坐标系 把求地址相像成求数列；即an=a1+(n-1)*d;