转: 

b).给出一个在非空 m*n 的 Young  氏矩阵上实现 EXTRACT-MIN 算法,使其运行时间为O(m+n).

c).说明如何在O(m+n)时间内,将一个新元素手入到一个未满的 m*n Young 氏矩阵中.

d).给出一个时间复杂度为 O(n^3) 的对 n*n Young 氏矩阵排序的算法.

e).给出一个运行时间为O(m+n) 的算法,来决定一个给定的数是否存在于一个给定的 m*n  的 Young 氏矩阵当中.

答

a).  2     3      4      5

8     9     12    14

16    ∞      ∞     ∞

∞     ∞      ∞     ∞

PS.该矩阵并不是唯一的.

b). (1)用递归的思想.在 Young 氏矩阵中，通过递归的解决(m-1)*n,或m*(n-1) 的子问题来求解.则有 T(m,n)=T(m-1,n) or T(m,n-1)+ O(1),显然,T=O(m+n).伪代码如下:

c).  类似堆的插入：先将待插入的元素 K 放在 Young[m][n], 然后比较 K 与它左方或上方元素的大小,并与其中较大的一个交换.反复进行直到 K 不小于它左方和上方的元素为止. 在这里,同样有,T(m,n)=T(m-1,n) or T(m,n-1)+ O(1),T=O(m+n).伪代码如下:

d). 调用 n*n 次 EXTRACT_MIN 过程即可.

e). 总是于最右上角的元素X比较；
1）如果==X,结束；
2）如果比X小，那么元素只可能在前N-1列中；
3）如果比X大，那么元素只可能在后M-1行中；
Young 氏矩阵去掉一行或一列还是 Young 氏矩阵；
所以每次比较最少去掉一行或一列，这样复杂度就是 O(m+n);

文件描述符----文件表----v节点结构三者的联系

       既然文件描述符标识特定进程正在访问的文件，那进程跟文件是怎么联系起来的呢？

       首先我们得知道每运行一个进程，shell就会默认为其打开三个文件描述符(0,1,2)，分别与标准输入(stdin)，标准输出(stdout)和标准错误(stderr)对应。

       接下来讲下内核所使用的三种数据结构，正是这三种数据结构才使进程最终跟文件联系起来。建议边看图一边看下面的文字描述

      a. 每个进程在进程表中都有一个记录项，每个记录项中有一张打开文件描述符表，可将其视为一个矢量，每个描述符占用一项。
          与每个文件描述符相关联的是：(a) 文件描述符。(b) 指向一个文件表项的指针

      b. 内核为所有打开文件维持一张文件表。每个文件表项包含：(a) 文件状态标志。(b) 当前文件位移量。(c) 指向该文件v节点表项的指针。

      c. 每个打开文件（或设备）都有一个v节点结构。是文件的重要信息部分。

2 Egg Problem

给C瓜同学吧

基本解释

　　const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的健壮性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一些帮助。

　　虽然这听起来很简单，但实际上，const的使用也是c语言中一个比较微妙的地方，微妙在何处呢？请看下面几个问题。

　　问题：const变量 & 常量

　　为什么我象下面的例子一样用一个const变量来初始化数组，ANSI C的编译器会报告一个错误呢？

　　const int n = 5;

　　int a[n];

　　答案与分析:

　　1)、这个问题讨论的是“常量”与“只读变量”的区别。常量肯定是只读的，例如5， “abc”，等，肯定是只读的，因为程序中根本没有地方存放它的值，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符(Qualifier)。上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。而ANSI C规定数组定义时维度必须是“常量”，“只读变量”也是不可以的。

　　2)、注意：在ANSI C中，这种写法是错误的，因为数组的大小应该是个常量，而const int n,n只是一个变量(常量 != 不可变的变量，但在标准C++中，这样定义的是一个常量，这种写法是对的)，实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是ANSI C对数组的规定限制了它。

　　3)、那么，在ANSI C 语言中用什么来定义常量呢？答案是enum类型和#define宏，这两个都可以用来定义常量。

　　问题：const变量 & const 限定的内容

　　下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢？

　　typedef char * pStr;

　　char string[4] = "abc";

　　const char *p1 = string;

　　const pStr p2 = string;

　　p1++;

　　p2++;

　　答案与分析：

　　问题出在p2++上。

　　1)、const使用的基本形式： const char m;

　　限定m不可变。

　　2)、替换1式中的m, const char *pm;

　　限定*pm不可变，当然pm是可变的，因此问题中p1++是对的。

　　3)、替换1式char, const newType m;

　　限定m不可变，问题中的charptr就是一种新类型，因此问题中p2不可变，p2++是错误的。

　　问题：const变量 & 字符串常量

　　请问下面的代码有什么问题？

　　char *p = "i'm hungry!";

　　p[0]= 'I';

　　答案与分析：

　　上面的代码可能会造成内存的非法写操作。分析如下， “i'm hungry”实质上是字符串常量，而常量往往被编译器放在只读的内存区，不可写。p初始指向这个只读的内存区，而p[0] = 'I'则企图去写这个地方，编译器当然不会答应。

　　问题：const变量 & 字符串常量2

　　请问char a[3] = "abc" 合法吗？使用它有什么隐患？

　　答案与分析：

　　在标准C中这是合法的，但是它的生存环境非常狭小；它定义一个大小为3的数组，初始化为“abc”，，注意，它没有通常的字符串终止符'\0'，因此这个数组只是看起来像C语言中的字符串，实质上却不是，因此所有对字符串进行处理的函数，比如strcpy、printf等，都不能够被使用在这个假字符串上。

　　问题：const & 指针

　　类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么?

　　1)、const在前面

　　const int nValue； //nValue是const

　　const char *pContent; //*pContent是const, pContent可变

　　const (char *) pContent;//pContent是const,*pContent可变

　　char* const pContent; //pContent是const,*pContent可变

　　const char* const pContent; //pContent和*pContent都是const

　　2)、const在后面，与上面的声明对等

　　int const nValue； // nValue是const

　　char const * pContent;// *pContent是const, pContent可变

　　(char *) const pContent;//pContent是const,*pContent可变

　　char* const pContent;// pContent是const,*pContent可变

　　char const* const pContent;// pContent和*pContent都是const

　　答案与分析：

　　const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图，下面讲一下我的判断原则：

　　沿着*号划一条线，const和谁在一边，那么谁就是const，即const限定的元素就是它。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。

　　另外，需要注意：对于const (char *) ; 因为char *是一个整体，相当于一个类型(如 char)，因此，这是限定指针是const。

原文在http://hi.baidu.com/deep_pro/blog/item/cf964b0ade9f4d1594ca6b1b.html

这些词之间的区别难倒了很多人，还有什么同步阻塞， 同步非阻塞， 异步阻塞， 异步非阻塞，乱七八糟的。
很多文章也想讲明白这个问题。著名且引起热议的有

http://www.ibm.com/developerworks/cn/linux/l-async/

http://www.cppblog.com/converse/archive/2009/05/13/82879.html

可是看了之后还是有点将信将疑，跑到图书馆翻了UNP 第一卷，不愧是圣经级别的著作，似有所悟。
UNP所述：
POSIX定义中，同步IO操作：IO操作将导致请求进程阻塞，直到IO操作完成。
异步IO操作：IO操作不导致请求进程阻塞

UNP中总结的IO模型有5种之多
阻塞IO，非阻塞IO，IO复用，信号驱动IO，异步IO,前四种都属于同步IO。

阻塞IO不必说了
非阻塞IO ，IO请求时加上O_NONBLOCK一类的标志位，立刻返回，IO没有就绪会返回错误，需要请求进程主动轮询不断发IO请求直到返回正确
IO复用同非阻塞IO本质一样，不过利用了新的select系统调用，由内核来负责本来是请求进程该做的轮询操作。看似比非阻塞IO还多了一个系统调用开销，不过因为可以支持多路IO，才算提高了效率
信号驱动IO，调用sigaltion系统调用，当内核中IO数据就绪时以SIGIO信号通知请求进程，请求进程再把数据从内核读入到用户空间，这一步是阻塞的。
异步IO，如定义所说，不会因为IO操作阻塞，IO操作全部完成才通知请求进程。

这样以来，同步和阻塞，异步和非阻塞就不会被混淆了，它们不是同一个方面上的概念，不能比较区别

同步和异步是只跟IO操作过程中进程的状态变化有关
阻塞和非阻塞就是进程的两种状态。

题目：

1. 给你n个数，其中有且仅有一个数出现了奇数次，其余的数都出现了偶数次。用线性时间常数空间找出出现了奇数次的那一个数。
2. 给你n个数，其中有且仅有两个数出现了奇数次，其余的数都出现了偶数次。用线性时间常数空间找出出现了奇数次的那两个数。

答案：

1. 从头到尾异或一遍，最后得到的那个数就是出现了奇数次的数。这是因为异或有一个神奇的性质：两次异或同一个数，结果不变。再考虑到异或运算满足交换律，先异或和后异或都是一样的，因此这个算法显然正确。

2. 从头到尾异或一遍，你就得到了需要求的两个数异或后的值。这两个数显然不相等，异或出来的结果不为0。我们可以据此找出两个数的二进制表达中不同的一位，然后把所有这n个数分成两类，在那一位上是0的分成一类，在那一位上是1的分到另一类。对每一类分别使用前一个问题的算法。

求平面最近点对的核心思想乃是二分，用递归实现。具体操作如下：

     若点的个数很少（比如小于3或者小于5），就直接枚举。

     如点的个数很多，按现将所有点按X排序，并按X坐标平均的分成左右两个部分（假设分割线为X=nx），分别求出两边的最短距离minl与minr并令ans=min（minl，minr）。

     求出左右两边的最小值之后，剩下的工作就是合并。易见若该点集存在点对（a，b）的最近距离小于ans，则a，b一定分别在x=nx的两边，切nx-a.x与nx-b.x的绝对值肯定小于ans。

     据此我们可以将点集中所有X值在（nx-ans，nx+ans）的点都选出来，那么满足条件的（a，b）肯定都在其中。

     易见若存在（a，b）两点他们之间的距离小于ans，那么a.y-b.y的绝对值也肯定小于ans。

     综上存在（a，b）两点他们之间的距离小于ans那，（a，b）一定在一个长为2*ans宽为ans的矩形之中。而 且这个矩形被X=nx平分成两个ans*ans的矩形，由于无论是在左边还是在右边，任意两点的之间的距离总是小于等于ans的，所以两个ans*ans 的矩形中最多只有4个点（分别在四个顶点上），长为2*ans宽为ans的矩形最多有8个点。

     据此我们将所有X值在（nx-ans，nx+ans）的点按他们的Y值进行排序。依次看每个点与它之后的7个点的距离是否小于ans，若小于则更新ans，最后求出来的结果就是平面最近点对的距离。保留产生该距离的两个点即可得到最近点对。

     练手题目：Pku2107，Vijos1012

附C++代码（Pku2107）：

#include <iostream>
#include <cmath>

const long maxsize = 100000;

typedef struct 
{ 
double x, y; 
} PointType;

long list[maxsize], listlen,n;
PointType point[maxsize];

int sortcmp(const void *,const void *); 
double dis(PointType,PointType);
double getmin(double,double);
int listcmp(const void *,const void *); 
double shortest(long,long);
int init(void);

int main() 
{ 
while (init())
   printf("%.2lf\n",shortest(0, n - 1)/2);    
return 0;
}

int sortcmp(const void *a, const void *b) 
{ 
if (((PointType*)a)->x < ((PointType*)b)->x)    
   return -1;   
else 
   return 1; 
}

double dis(PointType a, PointType b) 
{ 
return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y)); 
}

double getmin(double a, double b) 
{ 
return a<b?a:b;
}

int listcmp(const void *a, const void *b) 
{ 
if (point[*(int*)a].y < point[*(int*)b].y)    
   return -1;   
else 
   return 1; 
}

double shortest(long l, long r) 
{ 
if (r - l == 1) 
   return dis(point[l], point[r]);   
if (r - l == 2)    
   return getmin(getmin(dis(point[l], point[l+1]), dis(point[l], point[r])), dis(point[l+1], point[r]));   
long i, j, mid = (l + r) >> 1;   
double curmin = getmin(shortest(l, mid), shortest(mid + 1, r));   
listlen = 0;   
for (i = mid; i >= l && point[mid+1].x - point[i].x <= curmin; i --)    
   list[listlen++] = i;   
for (i = mid + 1; i <= r && point[i].x - point[mid].x <= curmin; i ++)    
   list[listlen++] = i;   
qsort(list, listlen, sizeof(list[0]), listcmp);   
for (i = 0; i < listlen; i ++)    
   for (j = i + 1; j < listlen && point[list[j]].y - point[list[i]].y <= curmin; j ++)     
    curmin = getmin(curmin, dis(point[list[i]], point[list[j]]));   
return curmin; 
}

int init(void)
{
int i;
scanf("%d", &n);      
for (i=0;i<n;i++) 
   scanf("%lf%lf",&point[i].x,&point[i].y);      
qsort(point,n,sizeof(point[0]),sortcmp);
return n;
}


自己写的代码:

那么什么是保护消息边界和流呢?

       保护消息边界，就是指传输协议把数据当作一条独立的消息在网上 
传输,接收端只能接收独立的消息.也就是说存在保护消息边界,接收 
端一次只能接收发送端发出的一个数据包. 
       而面向流则是指无保护消息保护边界的,如果发送端连续发送数据, 
接收端有可能在一次接收动作中,会接收两个或者更多的数据包.

       我们举个例子来说,例如,我们连续发送三个数据包,大小分别是2k, 
4k , 8k,这三个数据包,都已经到达了接收端的网络堆栈中,如果使 
用UDP协议,不管我们使用多大的接收缓冲区去接收数据,我们必须有 
三次接收动作,才能够把所有的数据包接收完.而使用TCP协议,我们 
只要把接收的缓冲区大小设置在14k以上,我们就能够一次把所有的 
数据包接收下来.只需要有一次接收动作.

       这就是因为UDP协议的保护消息边界使得每一个消息都是独立的.而 
流传输,却把数据当作一串数据流,他不认为数据是一个一个的消息.

      所以有很多人在使用tcp协议通讯的时候,并不清楚tcp是基于流的 
传输,当连续发送数据的时候,他们时常会认识tcp会丢包.其实不然, 
因为当他们使用的缓冲区足够大时,他们有可能会一次接收到两个甚 
至更多的数据包,而很多人往往会忽视这一点,只解析检查了第一个 
数据包,而已经接收的其他数据包却被忽略了.所以大家如果要作这 
类的网络编程的时候,必须要注意这一点.

结论：
     根据以上所说，可以这样理解，TCP为了保证可靠传输，尽量减少额外
开销（每次发包都要验证），因此采用了流式传输，面向流的传输，
相对于面向消息的传输，可以减少发送包的数量。从而减少了额外开
销。但是，对于数据传输频繁的程序来讲，使用TCP可能会容易粘包。
当然，对接收端的程序来讲，如果机器负荷很重，也会在接收缓冲里
粘包。这样，就需要接收端额外拆包，增加了工作量。因此，这个特
别适合的是数据要求可靠传输，但是不需要太频繁传输的场合（
两次操作间隔100ms，具体是由TCP等待发送间隔决定的，取决于内核
中的socket的写法）

而UDP，由于面向的是消息传输，它把所有接收到的消息都挂接到缓冲
区的接受队列中，因此，它对于数据的提取分离就更加方便，但是，
它没有粘包机制，因此，当发送数据量较小的时候，就会发生数据包
有效载荷较小的情况，也会增加多次发送的系统发送开销（系统调用，
写硬件等）和接收开销。因此，应该最好设置一个比较合适的数据包
的包长，来进行UDP数据的发送。（UDP最大载荷为1472，因此最好能
每次传输接近这个数的数据量，这特别适合于视频，音频等大块数据
的发送，同时，通过减少握手来保证流媒体的实时性）

来自: http://hi.baidu.com/chongerfeia/blog/item/b1e572f631dd7e28bd310965.html

TCP无保护消息边界的解决
 针对这个问题，一般有3种解决方案：

      (1)发送固定长度的消息

      (2)把消息的尺寸与消息一块发送

      (3)使用特殊标记来区分消息间隔

下面我们主要分析下前两种方法：

1、发送固定长度的消息 
这种方法的好处是他非常容易，而且只要指定好消息的长度，没有遗漏未未发的数据，我们重写了一个SendMessage方法。代码如下：

  private static int SendMessage(Socket s, byte[] msg)

        { 
            int offset = 0; 
            int size = msg.Length; 
            int dataleft = size;

            while (dataleft > 0) 
            {

                int sent = s.Send(msg, offset, SocketFlags.None); 
                offset += sent; 
                dataleft -= sent;

            }

            return offset; 
        }

简要分析一下这个函数：形参s是进行通信的套接字，msg即待发送的字节数组。该方法使用while循环检查是否还有数据未发送，尤其当发送一个很庞大的数据包，在不能一次性发完的情况下作用比较明显。特别的，用sent来记录实际发送的数据量，和recv是异曲同工的作用，最后返回发送的实际数据总数。

   有sentMessage函数后，还要根据指定的消息长度来设计一个新的Recive方法。代码如下：

  private byte[] ReciveMessage(Socket s, int size) 
        {

            int offset = 0; 
            int recv; 
            int dataleft = size; 
            byte[] msg = new byte[size];