浪潮AV色综合久久天堂,亚洲国产成人久久一区WWW,99久久99久久精品国产

长春赢鼎教育公司原是传销机构

luis — Sun, 01 May 2011 10:31:00 GMT

长春赢鼎教育公司长春赢鼎教育公司原是传销机构
http://www.szxkd.com/a/infos/2010/0728/42578.html
�q�日�Q�记者获悉，一起以教育为借口的传销团体�Q�在长春逐渐扩大�?span class=Apple-converted-space>
　　北京赢鼎教育机构长春分公司，实际上是长春赢鼎教育公司�Q�该公司挂着北京的名��P��在长春各大高校，以大量的“高薪求职”��|��诱导学生一人缴�U�会员费�Q?480元，会员费缴�U�x��E�收发票�Q�只有收据。现在该团队吸纳的会员数逐渐扩大�Q�预计达三千人�?span class=Apple-converted-space>
　　眼睁睁看着�q�个传销团队在长春各大高校滋生蔓�Ӟ��记者进入该团队�q�行了暗访调查得知一些情况：
　　一、该公司在没有提供实质性业务或服务情况下，以发展�h员数量�ؓ主要�l�济来源�Q?span class=Apple-converted-space>
　　二、以宣传“高薪职场”或承�?#8220;推荐学生�q�入500��Z��业工�?#8221;��饵，采取非法集会�Q��y立名目或以��品变相收取不�{��h、不客观的费用进行非法集资； http:///
　　三、以提供求职面试服务�Q?00强公司HR与大学生面对面，会员有机会获得去香港旅游�Q�手机，电脑为幌子，从事集资诈骗�{�违法犯�|�的商业��Q�用�ƺ骗手段甚至不断�z�脑诱导�q�行交易的敛财行为；
　　1、该公司��L��l�学生孩子们推荐500强工作。其实不是，是诱导前提，而所谓的工作�Q�是�l�他们机构做免费的实习生�?span class=Apple-converted-space>
　　2、该公司任课老师全部不是正规大学毕业的，而是一些没有正规学历背景的个�h。其中号�U�全球职业规划师的，其实只是化妆师（教礼仪�Ş象）�Q�或者有的号�U�全球职业企业高�U�管理�h�Q�其实是不知名单位某人力�l�理�?span class=Apple-converted-space>
　　3、以高薪教育��导点�Q�媄响在校学生们正常上课�Q�甚至翘课，不参加晚自习�{�，��g��命也要去上他们的课�?span class=Apple-converted-space>
4、所有报名费全无�E�收发票�?span class=Apple-converted-space>
　　5、该团队所有工作�h�Q�全部以团队竞争为模式：互相比较每一期课�E�、哪一�l?#8220;忽悠”的学生最多，�q�从中提成，谁忽悠的学生最多，谁的提成最高�?span class=Apple-converted-space>
　　6、如果交了会员费�Q�就�l�对不可能再退贏V�?span class=Apple-converted-space>
　　7、我们还有幸从该机构一名员工口中得知：该机构组�l�者对员工的承诺是�Q�争�?012�q�_��我们在纳斯达克上市。还承诺�Q�年底将�q�军北京�Q�优�U�的员工，��进军各大省市当代理处总负责�h。而实际是�Q�该机构可怜无辜的员工�Q�从早上7点去上班�Q�晚�?0�Ҏ��下班。一个月只有1天的休息日。五一加班公司�Ҏ��不给加班贏V��一个月工资只有1000元。而员工的提成�Q�公�怹�有各�U�借口扣下。开始讲的是挺激�׃�h�Q�现场的孩子们都被感染了。很明显�Q�都是些大一大二的孩子，刚进大学。对职场�Ҏ��不了解，他们讲的�q�些老套的东西，对大一大二的孩子就起到一个诱导的效果�?span class=Apple-converted-space>
　公司每一�ơ所谓的免费宣战之后�Q�学生们��p��被诱导参加他们的会员评��。每一个会员交费一千多。号�U�可以给孩子们推�?00强工作实习机会，或者给孩子们推荐工作等�{�。实际上是有推荐工作了：�l�他们赢鼎当免费的劳动力�?span class=Apple-converted-space>
　　当他们宣讲结束后问他们的老师�Q��ؓ什么�ȝ��大一大二孩子讲课�Q�也�l�大三大四的孩子讲讲职场嘛。老师的回�{�让记者感到很吃惊�Q�大三大四的不好�z�脑�?span class=Apple-converted-space>
　　随后�Q�记者电话至该公�怺�解其相关情况�Q�当记者问赯��公司的经营范围是什么时�Q�公司内部�h员却�{�不上来�Q��ƈ且否认有传销性质的活动�?span class=Apple-converted-space>
　　记者联�p�d��该公司法��Z��表，法�h一口否认公司的传销性质�Q��ƈ说有各大学的聘书��Q�而记者所见的该公司的营业执照�q�不规范�Q�没有注明公司经营范围�?span class=Apple-converted-space>
　　此后�Q�记者再想了解一些相��x��况，�q�要查询相关收费许可证及收费标准�Ӟ��公司�Ҏ��不接电话�Q�公司法��Z��拒接回避�?span class=Apple-converted-space>
　　长春赢鼎教育公司长春赢鼎教育公司原是传销机构!

luis 2011-05-01 18:31 发表评论

��Z��Socket的UDP和TCP�~�程介绍

luis — Sun, 12 Sep 2010 02:41:00 GMT

��Z��Socket的UDP和TCP�~�程介绍

转帖自：apps.hi.baidu.com/share/detail/8484629

一、概�q?

　　TCP�Q�传输控制协议）和UDP�Q�用��h��据报协议是网�l�体�pȝ��构TCP/IP模型中传输层一层中的两个不同的通信协议�?/span>

　　TCP�Q�传输控制协议，一�U�面向连接的协议�Q�给用户�q�程提供可靠的全双工的字节流�Q�TCP套接口是字节��套接口(stream socket)的一�U��?/span>

　　UDP�Q�用��h��据报协议。UDP是一�U�无�q�接协议。UDP套接口是数据报套接口(datagram socket)的一�U��?/span>

　　二、TCP和UDP介绍

　　1�Q�基本TCP客户—服务器�E�序设计基本框架

　　说明�Q�（三�\握手�Q?/span>

　　1.客户端发送一个SYN�D�（同步序号�Q�指明客��h��连接的服务器端口，以及初始化序�?ISN) �?/span>

　　2.服务器发回包含服务器的初始序��L��SYN报文�D�作为应�{�。同�Ӟ��确认序�?ACK)讄��为客��L��ISN�?以对客户的SYN 报文�D�进行确认。一个SYN��占用一个序受��?/span>

　　3.客户必须��确认序可��|��ؓ服务器的ISN�?以对服务器的SYN报文�D�进行确认�?/span>

　　2) 基本TCP客户—服务器�E�序设计基本框架��程�?br>

　　3) UDP和TCP的对比：

　　从上面的��程图比较我们可以很明显的看出UDP没有三次握手�q�程�?br>

　　��单点说。UDP处理的细节比TCP��。UDP不能保证消息被传送到�Q�它也报告消息没有传送到�Q�目的地。UDP也不保证数据包的传送顺序。UDP把数据发出去后只能希望它能够抵达目的地�?/span>

　　TCP优缺点：

　　优点�Q?/span>

　　1�Q�TCP提供以认可的方式昑ּ�地创建和�l�止�q�接�?/span>

　　2�Q�TCP保证可靠的、顺序的�Q�数据包以发送的��序接收�Q�以及不会重复的数据传输�?/span>

　　3�Q�TCP处理��控制�?/span>

　　4�Q�允许数据优�?/span>

　　5�Q�如果数据没有传送到�Q�则TCP套接口返回一个出错状态条件�?/span>

　　6�Q�TCP通过保持�q�箋�q�将数据块分成更��的分片来处理大数据块。—无需�E�序员知�?/span>

　　�~�点�Q?TCP在�{�U�L��据时必须创徏�Q��ƈ保持�Q�一个连接。这个连接给通信�q�程增加了开销�Q�让它比UDP速度要慢�?/span>

　　UDP优缺点：

　　1�Q�UDP不要求保持一个连�?/span>

　　2�Q�UDP没有因接收方认可收到数据包（或者当数据包没有正��抵达而自动重传）而带来的开销�?/span>

　　3�Q�设计UDP的目的是用于短应用和控制消息

　　4�Q�在一个数据包�q�接一个数据包的基��上，UDP要求的网�l�带宽比TDP更小�?/span>

　　三、Socket�~�程

　　Socket接口是TCP/IP�|�络的API�Q�Socket接口定义了许多函数或例程�Q�程序员可以用它们来开发TCP/IP�|�络上的应用�E�序。要学Internet上的TCP/IP�|�络�~�程�Q�必��ȝ��解Socket接口�?/span>

　　Socket接口设计者最先是��接口放在Unix操作�pȝ��里面的。如果了解Unix�pȝ��的输入和�?出的话，��很�Ҏ��了解Socket了。网�l�的Socket数据传输是一�U�特�D�的I/O�Q�Socket也是一�U�文件描�q�符。Socket也具有一个类��g��?开文�g的函数调用Socket()�Q�该函数�q�回一个整型的Socket描述�W�，随后的连接徏立、数据传输等操作都是通过该Socket实现的。常用的 Socket�c�d��有两�U�：��式Socket�Q�SOCK_STREAM�Q�和数据报式Socket�Q�SOCK_DGRAM�Q�。流式是一�U�面向连接的 Socket�Q�针对于面向�q�接的TCP服务应用�Q�数据报式Socket是一�U�无�q�接的Socket�Q�对应于无连接的UDP服务应用�?/span>

　　1、socket调用库函��C��要有�Q?/span>

　　创徏套接�?/span>

　　Socket(af,type,protocol)

　　建立地址和套接字的联�p?/span>

　　bind(sockid, local addr, addrlen)

　　服务器端侦听客户端的��h��

　　listen( Sockid ,quenlen)

　　建立服务�?客户端的�q�接 (面向�q�接TCP�Q?/span>

　　客户端请求连�?/span>

　　Connect(sockid, destaddr, addrlen)

　　服务器端�{�待从编号�ؓSockid的Socket上接收客戯��接请�?/span>

　　newsockid=accept(Sockid�Q�Clientaddr, paddrlen)

　　发�?接收数据

　　面向�q�接�Q�send(sockid, buff, bufflen)

　　recv( )

　　面向无连接：sendto(sockid,buff,…,addrlen)

　　recvfrom( )

　　释放套接�?/span>

　　close(sockid)

　　2、TCP/IP应用�~�程接口�Q�API�Q?/span>

　　服务器的工作��程�Q�首先调用socket函数创徏一个Socket�Q�然后调用bind函数��其与本机地址以及一个本地端口号�l�定�Q�然后调用listen在相应的socket�?�Q�当accpet接收��C��个连接服务请求时�Q�将生成一个新的socket�?服务器显�C��客户机的IP地址�Q��ƈ通过新的socket向客��L��发送字�W�串" hi,I am server!"。最后关闭该socket�?br>

main()
{
int sock_fd,client_fd; /*sock_fd�Q?socket�Q�client_fd�Q�数据传输socket */
struct sockaddr_in ser_addr; /* 本机地址信息 */
struct sockaddr_in cli_addr; /* 客户端地址信息 */
char msg[MAX_MSG_SIZE];/* �~�冲�?/
ser_sockfd=socket(AF_INET,SOCK_STREAM,0);/*创徏�q�接的SOCKET */
if(ser_sockfd<0)
{/*创徏��p�| */
fprintf(stderr,"socker Error:%s\n",strerror(errno));
exit(1);
}
/* 初始化服务器地址*/
addrlen=sizeof(struct sockaddr_in);
bzero(&ser_addr,addrlen);
ser_addr.sin_family=AF_INET;
ser_addr.sin_addr.s_addr=htonl(INADDR_ANY);
ser_addr.sin_port=htons(SERVER_PORT);
if(bind(ser_sockfd,(struct sockaddr*)&ser_addr,sizeof(struct sockaddr_in))<0)
{ /*�l�定��p�| */
fprintf(stderr,"Bind Error:%s\n",strerror(errno));
exit(1);
}
/*侦听客户端请�?/
if(listen(ser_sockfd,BACKLOG)<0)
{
fprintf(stderr,"Listen Error:%s\n",strerror(errno));
close(ser_sockfd);
exit(1);
}
while(1)
{/* �{�待接收客户�q�接��h��*/
cli_sockfd=accept(ser_sockfd,(struct sockaddr*) & cli_addr,&addrlen);
if(cli_sockfd<=0)
{
fprintf(stderr,"Accept Error:%s\n",strerror(errno));
}
else
{/*开始服�?/
recv(cli_addr,msg,MAX_MSG_SIZE,0); /* 接受数据*/
printf("received a connection from %sn", inet_ntoa(cli_addr.sin_addr));
printf("%s\n",msg);/*在屏�q�上打印出来 */
strcpy(msg,"hi,I am server!");
send(cli_addr,msg,sizeof(msg),0); /*发送的数据*/
close(cli_addr);
}
}
close(ser_sockfd);
}

　　客户端的工作��程�Q�首先调用socket函数创徏一个Socket�Q�然后调用bind函数��其与本机地址以及一个本地端口号�l�定�Q�请求连接服务器�Q�通过新的socket向客��L��发送字�W�串" hi,I am client!"。最后关闭该socket�?/p>

main()
{
int cli_sockfd;/*客户端SOCKET */
int addrlen;
char seraddr[14];
struct sockaddr_in ser_addr,/* 服务器的地址*/
cli_addr;/* 客户端的地址*/
char msg[MAX_MSG_SIZE];/* �~�冲�?/
GetServerAddr(seraddr);
cli_sockfd=socket(AF_INET,SOCK_STREAM,0);/*创徏�q�接的SOCKET */
if(ser_sockfd<0)
{/*创徏��p�| */
fprintf(stderr,"socker Error:%s\n",strerror(errno));
exit(1);
}
/* 初始化客��L��地址*/
addrlen=sizeof(struct sockaddr_in);
bzero(&ser_addr,addrlen);
cli_addr.sin_family=AF_INET;
cli_addr.sin_addr.s_addr=htonl(INADDR_ANY);
cli_addr.sin_port=0;
if(bind(cli_sockfd,(struct sockaddr*)&cli_addr,addrlen)<0)
{
/*��定��p�| */
fprintf(stderr,"Bind Error:%s\n",strerror(errno));
exit(1);
}
/* 初始化服务器地址*/
addrlen=sizeof(struct sockaddr_in);
bzero(&ser_addr,addrlen);
ser_addr.sin_family=AF_INET;
ser_addr.sin_addr.s_addr=inet_addr(seraddr);
ser_addr.sin_port=htons(SERVER_PORT);
if(connect(cli_sockfd,(struct sockaddr*)&ser_addr,&addrlen)!=0)/*��h��q�接*/
{
/*�q�接��p�| */
fprintf(stderr,"Connect Error:%s\n",strerror(errno));
close(cli_sockfd);
exit(1);
}
strcpy(msg,"hi,I am client!");
send(sockfd,msg,sizeof(msg),0);/*发送数�?/
recv(sockfd,msg,MAX_MSG_SIZE,0); /* 接受数据*/
printf("%s\n",msg);/*在屏�q�上打印出来 */
close(cli_sockfd);
}

　　3、UDP/IP应用�~�程接口�Q�API�Q?/strong>

　　服务器的工作��程�Q�首先调用socket函数创徏一个Socket�Q�然后调用bind函数��其与本机地址以及一个本地端口号�l�定�Q�接收到一个客��L��Ӟ��服务器显�C��客户端的IP地址�Q��ƈ��字串返回给客户端�?/p>
int main(int argc,char **argv)
{
int ser_sockfd;
int len;
//int addrlen;
socklen_t addrlen;
char seraddr[100];
struct sockaddr_in ser_addr;
/*建立socket*/
ser_sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(ser_sockfd<0)
{
printf("I cannot socket success\n");
return 1;
}
/*填写sockaddr_in �l�构*/
addrlen=sizeof(struct sockaddr_in);
bzero(&ser_addr,addrlen);
ser_addr.sin_family=AF_INET;
ser_addr.sin_addr.s_addr=htonl(INADDR_ANY);
ser_addr.sin_port=htons(SERVER_PORT);
/*�l�定客户�?br>if(bind(ser_sockfd,(struct sockaddr *)&ser_addr,addrlen)<0)
{
printf("connect");
return 1;
}
while(1)
{
bzero(seraddr,sizeof(seraddr));
len=recvfrom(ser_sockfd,seraddr,sizeof(seraddr),0,(struct sockaddr*)&ser_addr,&addrlen);
/*昄��client端的�|�络地址*/
printf("receive from %s\n",inet_ntoa(ser_addr.sin_addr));
/*昄��客户端发来的字串*/
printf("recevce:%s",seraddr);
/*��字串返回给client�?/
sendto(ser_sockfd,seraddr,len,0,(struct sockaddr*)&ser_addr,addrlen);
}
}

　　客户端的工作��程�Q�首先调用socket函数创徏一个Socket�Q�填写服务器地址及端口号�Q�从标准输入讑֤�中取得字�W�串�Q�将字符串传送给服务器端�Q��ƈ接收服务器端�q�回的字�W�串。最后关闭该socket�?/p>
int GetServerAddr(char * addrname)
{
printf("please input server addr:");
scanf("%s",addrname);
return 1;
}
int main(int argc,char **argv)
{
int cli_sockfd;
int len;
socklen_t addrlen;
char seraddr[14];
struct sockaddr_in cli_addr;
char buffer[256];
GetServerAddr(seraddr);
/* 建立socket*/
cli_sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(cli_sockfd<0)
{
printf("I cannot socket success\n");
return 1;
}
/* 填写sockaddr_in*/
addrlen=sizeof(struct sockaddr_in);
bzero(&cli_addr,addrlen);
cli_addr.sin_family=AF_INET;
cli_addr.sin_addr.s_addr=inet_addr(seraddr);
//cli_addr.sin_addr.s_addr=htonl(INADDR_ANY);
cli_addr.sin_port=htons(SERVER_PORT);

bzero(buffer,sizeof(buffer));
/* 从标准输入设备取得字�W�串*/
len=read(STDIN_FILENO,buffer,sizeof(buffer));
/* ��字�W�串传送给server�?/
sendto(cli_sockfd,buffer,len,0,(struct sockaddr*)&cli_addr,addrlen);
/* 接收server端返回的字符�?/
len=recvfrom(cli_sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&cli_addr,&addrlen);
//printf("receive from %s\n",inet_ntoa(cli_addr.sin_addr));
printf("receive: %s",buffer);
close(cli_sockfd);
}

luis 2010-09-12 10:41 发表评论

[转蝲]Vector遍历

luis — Tue, 26 Jan 2010 01:08:00 GMT
import java.util.Iterator;
import java.util.Vector;

public class VectorIterator implements Iterator{

     private Vector v;

     private int currentIndex=0;

     public VectorIterator(){

     }

     public VectorIterator(Vector v){
         this.v=v;
     }

     public boolean hasNext() {
         if(this.currentIndex             System.out.println("current index is :   "+this.currentIndex);
             return true;
         }else{
             System.out.println("out of the bound ");
         }
         return false;
     }

     public Object next() {
         return this.v.get(this.currentIndex++);
     }

     public void remove() {
         this.v.remove(this.currentIndex);
     }


     public static void main(String[] args){
         Vector v=new Vector();
         v.add(new String("aaa"));
         v.add(new String("bbb"));
         v.add(new String("ccc"));
         //System.out.println(v);


         Iterator iter=new VectorIterator(v);
         while(iter.hasNext()){
             String str=(String)iter.next();
             System.out.println(str);
         }
     }

}

luis 2010-01-26 09:08 发表评论

luis — Mon, 25 Jan 2010 17:48:00 GMT

temp=CustomerMaker.quickPassQueue.get(0);//获得首元�?br />  CustomerMaker.quickPassQueue.remove(0);//删除首元�?br />
quickPassQueue.add();在末��添加元�?br />----演示�E�序-----

import java.util.*;
import java.io.*;

public class test
{
Vector v = new Vector();

public void testMethod(){
v.add("a");
v.add("b");
v.add("c");

System.out.println("\n原来的vecotr");
for(int i=0;i   System.out.println("\n"+" index is: "+ i + " element is: " +v.get(i));
}

v.remove(0);

System.out.println("\n��L��一个vector中第一个元�?);
for(int i=0;i   System.out.println("\n"+" index is: "+ i + " element is: " +v.get(i));
}
}

public static void main(String[] args)
{
test t = new test();
t.testMethod();
System.out.println("Hello World!");
}
}
-----------------排序�E�序------------------------------
import java.util.*;

class MyCompare implements Comparator //实现Comparator�Q�定义自��q��比较�Ҏ��
{
public int compare(Object o1, Object o2) {
Elem e1=(Elem)o1;
Elem e2=(Elem)o2;

if(e1.get() > e2.get())//�q�样比较是降�?如果�?1�Ҏ��1��是升序.
{
   return -1;
}
else if(e1.get(){
   return 1;
}
else
{
   return 0;
}
}
}

class Elem {
private int iVal;

public Elem(int i) {
   this.iVal = i;
}

public int get() {
   return this.iVal;
}
}

public class Vector1 {
public static void main(String[] args) {
   List v = new Vector();
   v.add(new Elem(1));
   v.add(new Elem(22));
   v.add(new Elem(3));
   v.add(new Elem(14));
   Comparator ct = new MyCompare();
   Collections.sort(v, ct);
   for (int i = 0; i < v.size(); i++)
    System.out.println(((Elem) v.get(i)).get());

}

}

luis 2010-01-26 01:48 发表评论

[转蝲]使用 Java �~�程语言实现�U�程

luis — Mon, 25 Jan 2010 17:17:00 GMT

使用 Java �~�程语言实现�U�程

　　Java�~�程语言使多�U�程如此��单有效，以致于某些程序员说它实际上是自然的。尽��在 Java 中��用线�E�比在其他语�a�中要�Ҏ��得多�Q�仍然有一些概念需要掌握。要��C��的一仉��要的事情�?/span> main() 函数也是一个线�E�，�q�可用来做有用的工作。程序员只有在需要多个线�E�时才需要创建新的线�E��?/span>

　　Thread �c?/span>

　　Thread �c�L��一个具体的�c�，即不是抽象类�Q�该�c�d��装了�U�程的行为。要创徏一个线�E�，�E�序员必��d��Z��个从 Thread �c�d��出的新类。程序员必须覆盖 Thread �?/span> run() 函数来完成有用的工作。用户�ƈ不直接调用此函数�Q�而是必须调用 Thread �?/span> start() 函数�Q�该函数再调�?/span> run()。下面的代码说明了它的用法：

　　创徏两个新线�E?/span>

import java.util.*;

class TimePrinter extends Thread {
　int pauseTime;
　String name;
　public TimePrinter(int x, String n) {
　　pauseTime = x;
　　name = n;
　}

　public void run() {
　　while(true) {
　　　try {
　　　　System.out.println(name + ":" + new Date(System.currentTimeMillis()));
　　　　Thread.sleep(pauseTime);
　　　} catch(Exception e) {
　　　　System.out.println(e);
　　　}
　　}
　}

　static public void main(String args[]) {
　　TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
　　tp1.start();
　　TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
　　tp2.start();

　}
}

　　在本例中�Q�我们可以看��C��个简单的�E�序�Q�它按两个不同的旉��间隔�Q?/span>1 �U�和 3 �U�）在屏�q�上昄��当前旉��。这是通过创徏两个新线�E�来完成的，包括 main() �׃��个线�E�。但是，因�ؓ有时要作为线�E�运行的�c�d��能已�l�是某个�c�d��ơ的一部分�Q�所以就不能再按�q�种机制创徏�U�程。虽然在同一个类中可以实��C�Q意数量的接口�Q�但 Java �~�程语言只允�怸�个类有一个父�c�R��同�Ӟ��某些�E�序员避免从 Thread �c�d��出，因�ؓ它强加了�c�d��ơ。对于这�U�情况，��p�� runnable 接口�?/span>

　　Runnable 接口

　　此接口只有一个函敎ͼ�run()�Q�此函数必须由实��C��此接口的�c�d��现。但是，��p��行这个类而论�Q�其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。（不同的部分用黑体表示。）

　　创徏两个新线�E�而不强加�c�d��?/span>

import java.util.*;

class TimePrinter implements Runnable {
　int pauseTime;
　String name;
　public TimePrinter(int x, String n) {
　　pauseTime = x;
　　name = n;
　}

　public void run() {
　　while(true) {
　　　try {
　　　　System.out.println(name + ":" + new Date(System.currentTimeMillis()));
　　　　Thread.sleep(pauseTime);
　　　} catch(Exception e) {
　　　　System.out.println(e);
　　　}
　　}
　}

　static public void main(String args[]) {
　　Thread t1 = new Thread(new TimePrinter(1000, "Fast Guy"));
　　t1.start();
　　Thread t2 = new Thread(new TimePrinter(3000, "Slow Guy"));
　　t2.start();
　}
}

　　��h��意，当��?/span> runnable 接口�Ӟ��您不能直接创建所需�cȝ��对象�q�运行它�Q�必��M�� Thread �cȝ��一个实例内部运行它。许多程序员更喜��?/span> runnable 接口�Q�因��Z�� Thread �cȝ��承会强加�c�d��ơ�?/span>

　　synchronized 关键�?/span>

　　到目前�ؓ止，我们看到的示例都只是以非常简单的方式来利用线�E�。只有最��的数据��，而且不会出现两个�U�程讉K��同一个对象的情况。但是，在大多数有用的程序中�Q�线�E�之间通常有信息流。试考虑一个金融应用程序，它有一�?/span> Account 对象�Q�如下例中所�C�：

　　一个银行中的多��Ҏ��?/span>

public class Account {
　String holderName;
　float amount;
　public Account(String name, float amt) {
　holderName = name;
　amount = amt;
}

public void deposit(float amt) {
　amount += amt;
}

public void withdraw(float amt) {
　amount -= amt;
}

public float checkBalance() {
　return amount;
}
}

　　在此代码样例中潜伏着一个错误。如果此�cȝ��于单�U�程应用�E�序�Q�不会有��M��问题。但是，在多�U�程应用�E�序的情况中�Q�不同的�U�程��有可能同时讉K��同一�?/span> Account 对象�Q�比如说一个联合帐��L��所有者在不同�?/span> ATM 上同时进行访问。在�q�种情况下，存入和支出就可能以这��L��方式发生�Q�一个事务被另一个事务覆盖。这�U�情况将是灾难性的。但是，Java �~�程语言提供了一�U�简单的机制来防止发生这�U�覆盖。每个对象在�q�行旉��有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这��P��修订�q�的 Account 对象�Q�如下所�C�）��不会遭受像数据损坏�q�样的错误：

　　对一个银行中的多��Ҏ��动进行同步处�?/span>

public class Account {
　String holderName;
　float amount;
　public Account(String name, float amt) {
　holderName = name;
　amount = amt;
}

public synchronized void deposit(float amt) {
　amount += amt;
}

public synchronized void withdraw(float amt) {
　amount -= amt;
}

public float checkBalance() {
　return amount;
}
}

　　deposit() �?/span> withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时�Q�另一个函数就被阻塞。请注意�Q?/span> checkBalance() 未作更改�Q�它严格是一个读函数。因�?/span> checkBalance() 未作同步处理�Q�所以�Q何其他方法都不会��d��它，它也不会��d��M��其他�Ҏ��Q�不��那些方法是否进行了同步处理

luis 2010-01-26 01:17 发表评论

joj 1092 To the Max 转帖Dp�l�典

luis — Thu, 09 Jul 2009 10:37:00 GMT

[原创]POJ1050 To the Max 解题报告

2006-04-17 11:55

题目大意:

��d��一个n*n的数�l?比如

0 -2 -7 0

9 2 -6 2

-4 1 -4 1

-1 8 0 -2

从里面�Q意截取一个矩�?使得矩阵所包含的数字的和最�?

截取出来的矩�?和�ؓ15

9 2

-4 1

-1 8

---------------------------------------------------------

POJ 1050 我的解题报告�Q?br>
�q�个题目很经典的��_��O�Q�N^3�Q�的DP�?br>
首先偶们考察�q�样的题目，��化版�Q?br>
已知一列数�Q�求��L��q�箋若干个数和的最大倹{�?br>
SAMPLE�Q?nbsp;3 2 -6 2 -1 7

原数3        2      -6       2      -1       7

处理3        5      -1       2       1       8

因�ؓ是连�l�若�q�个自然数的和，那么�Q�前面的某个数字取与不取的条件在于：以前面这个数字�ؓ�l�尾的连�l�数的和最大值是否大�?�Q�如果大�?�Q�那么这个数字必然要会出现在包括数字的序列中�Q�否则无法做到最大�?br>
所以，昄��。处理的原则是maxn[i]=max{0,maxn[i-1]}+a[i];

�׃��无须记录位置。所以，可以直接用一个变量sum代替maxn数组。O(n)的扫描即可�?br>
单列数字的问题解决了�Q�下面我们考察多列数字�?br>
sample:

         0    -2    -7    0

         9     2    -6    2

        -4     1    -4    1

        -1     8     0   -2

我们可以��多列数字�{换成单列数字来做�Q?nbsp;可以�q�样设想�Q�结果是一个长方�Ş�Q�我们把他压扁，使得宽�ؓ1�?br>
引入辅助数组st,st[i][j]代表�W�i列从�W?行开始的数字累加到第j行的倹{��那么，我们每次压扁的时候，��可以用st[i][j]-st[i][k-1]来表�C�第i列从�W�k个数字篏加到�W�j个数字的倹{��达到压�~�的效果。然后用上面单列数字的方法来做。算法时间复杂度O (N^3)

Source

Problem Id:1050  User Id:galaxy

Memory:112K  Time:0MS

Language:G++  Result:Accepted

/*

  Name:POJ 1050

  Copyright: flymouse@galaxy

  Author:chenlei

  Date: 15-02-06 07:36

  Description: DP O(N^3)

*/

#include

#include

#define mt 101

int main()

{

int a[mt][mt];

int st[mt][mt];

int p,k,n,i,j,sum,maxn;

//freopen("in.txt","r",stdin);

scanf("%d",&n);

for (i=1;i<=n;i++)

for (j=1;j<=n;j++)

scanf("%d",&a[i][j]);

memset(st,0,sizeof(st));

for (i=1;i<=n;i++)

   for (j=1;j<=n;j++)

  st[i][j]=st[i][j-1]+a[j][i];

  maxn=0;

   for (i=1;i<=n;i++)

   {

for (j=i;j<=n;j++)

{

p=st[1][j]-st[1][i-1];

sum=p;

for (k=2;k<=n;k++)

{

if (sum>0)

sum+=st[k][j]-st[k][i-1];

else sum=st[k][j]-st[k][i-1];

if (sum>p) p=sum;

}

if (p>maxn) maxn=p;

}

   }

   printf("%d\n",maxn);

   return 0;
原文地址�Q?a >http://hi.baidu.com/flymouse/blog/item/fd1378f05c7ff7c37931aac3.html

luis 2009-07-09 18:37 发表评论

luis — Wed, 01 Jul 2009 06:29:00 GMT

�q�是�W�一�U�哈希函敎ͼ��q�行旉��短，但内存占用多。哈希函数是怎么得到的？我也想知道。。�?br>#include
#include
#include
struct abc
{
    int boo;
    char key[12];
}hash[1100005];
int const prime=999983;
double const gold=0.618033;
void insert(char a[],int k,int w)
{
    if(hash[w].boo==0)
    {
        hash[w].boo=k;
        memcpy(hash[w].key,a,sizeof(hash[w].key));
    }
    else
        insert(a,k,w%prime+1);
}
int find(int k,int w)
{
    if(hash[w].boo==k)
    {
        printf("%s\n",hash[w].key);
            return 1;
    }
    else
    {
        if(hash[w].boo==0)
            return 0;
        else
            return find(k,w%prime+1);
    }
}
int main()
{
    freopen("in.txt","r",stdin);
    char a[12],b[12];
    scanf("%c",&a[0]);
    while(scanf("%s%s",a+1,b))
    {
        getchar();
        int len=strlen(b);
        int k=0;
        for(int i=0;i            k=k*26+b[i]-'a';
        int w=int (prime*(k*gold-floor(k*gold)));
        insert(a,k,w);
        scanf("%c",&a[0]);
        if(a[0]=='\n')
            break;
    }
    while(scanf("%s",&a)==1)
    {
        int len=strlen(a);
        int k=0;
        for(int i=0;i        k=k*26+a[i]-'a';
        int w=int (prime*(k*gold-floor(k*gold)));
        if(find(k,w)==0)
        printf("eh\n");
    }
    return 0;
}
�q�是用书中提到的ELFhash()函数�Q�也没体现出旉��上的优势�Q�但�I�间上确实是省了不少�Q�可能是计算ELFhash()时浪费了旉��吧，处理字符串哈希冲�H�的办法目前只发��C��U��Ş探测法，虽然不理惻I��但愿��来能发现别的办法�?br>ELFhash函数在UNIX�pȝ��V 版本4中的“可执行链接格�?#8221;( Executable and Linking Format�Q�即ELF )中会用到�Q�ELF文�g格式用于存储可执行文件与目标文�g。ELFhash函数是对字符串的散列。它对于长字�W�串和短字符串都很有效，字符串中每个字符�?有同��L��作用�Q�它巧妙地对字符的ASCII�~�码��D��行计��，ELFhash函数对于能够比较均匀地把字符串分布在散列表中�?br>#include
#include
#include
#define MOD 300005
struct abc
{
    bool boo;
    char akey[12];
    char bkey[12];
}hash[300005];

int ELFhash(char *key)
{
    unsigned long h=0;
    while(*key)
    {
        h=(h<<4)+*key++;
        unsigned long g=h&0Xf0000000L;
        if(g) h^=g>>24;
        h&=~g;
    }
    return h%MOD;
}
void insert(char a[],char b[],int w)
{
    if(!hash[w].boo)
    {
        hash[w].boo=true;
        memcpy(hash[w].akey,a,sizeof(hash[w].akey));
        memcpy(hash[w].bkey,b,sizeof(hash[w].bkey));
    }
    else
        insert(a,b,w+1);
}
int find(char b[],int w)
{
    if(hash[w].boo && strcmp(hash[w].bkey,b)==0)
    {
        printf("%s\n",hash[w].akey);
            return 1;
    }
    else
    {
        if(!hash[w].boo)
            return 0;
        else
            return find(b,w+1);
    }
}
int main()
{
    char a[12],b[12];
    scanf("%c",&a[0]);
    while(scanf("%s%s",a+1,b))
    {
        getchar();
        int w=ELFhash(b);
        insert(a,b,w);
        scanf("%c",&a[0]);
        if(a[0]=='\n')
            break;
    }
    while(scanf("%s",&b)==1)
    {
        int w=ELFhash(b);
        if(find(b,w)==0)
        printf("eh\n");
    }
    return 0;
}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/cugbliang/archive/2008/05/30/2497539.aspx

luis 2009-07-01 14:29 发表评论

哈希�?poj 3320 Jessica's Reading Problem

luis — Wed, 01 Jul 2009 05:00:00 GMT

poj 3320 Jessica's Reading Problem http://acm.pku.edu.cn/JudgeOnline/problem?id=3320
�q�道题目可以用哈希表法也可以用二分查找法�Q�现在用哈希�Q�二分查扑ְ�在后面的博客中推出�?br>�q�道题目用到的是数的哈希�Q�对于不需要删除的字典�Q�哈希表是一�U�理想的实现方式�?br>1.哈希表的插入和查扄��?br>(1)计算函数值h(k)
(2)从槽h(k)开始，使用冲突解决�{�略定位包含关键码k的纪�?br>(3)如果需要插入，再槽内插入即�?br>两种操作的复杂度在忽略冲�H�时是O(1)
2.哈希函数的选取
本题使用最��单的直接取余法，除数为PRIME�Q�最好是质数�Q�可减小冲突�?br>3.冲突解决�Ҏ��
开散列法（�q�也是大多数情况下��用的�Q?br>开散列法也叫拉链法�Q�通俗地说��是“既然元素a和b都该攑֜�里面�Q�只好挤一挤了”。即在每个槽里存放所有该攑֜�里面的元素。那么怎么把很多的元素攑֜�槽里呢？只在槽里放一个链表表头就行了�Q�该链表中包含所有该攑֜�槽里的元素。但在实际中�q�不是这样做的，而是自己�l�护一个大数组�Q�给链表元素分配数组下标�Q�这��h��方便又节省时间和�I�间。那么链表中的元素的排列��序怎样呢？如果按照查找成功时的效率�Q�显然可以按照访问的频率�Q�而如果按照查扑֤�败的效率�Q�则可以按照关键值排序，即��查找��p�|也不需要遍历整个链表。这��是数据�l�构中的�怺�矛盾的两个问题，应根据实际情况协调�?br>#include
#define PRIME 99991
struct hashnode
{
    int key;
    int num;
    int next;
}a[1000005];
int b[1000005];
int hashl;
int hash(int num)
{
    int i;
    i=num%PRIME;
    while(a[i].next!=-1)
    {
        if(num>a[a[i].next].key)     //例如hash表中已有8�Q�后面又插入99999�Ӟ��那么99999>8,需要给99999重新分配                                                                           一个下标，即hashl�Q�即前面提到的开散列法解军_��H?br>            break;
        else if(num==a[a[i].next].key)    //例如hash表中已有8�Q�后面又插入8�Ӟ��q�是只要num++
            return a[i].next;
        i=a[i].next;                               //�q�句用于查找�Q�如果哈希表中已�?�?9999�Q�那么你要找8时a[8].next指向的是较大�?9999�Q�那么你��必��L��着next��C��去，因�ؓ�q�个所谓的链表是按减小的顺序排序的。最�l�走到return a[i].next推出while 循环
    }
    a[hashl].key=num;
    a[hashl].next=-1;
    a[hashl].num=0;
    a[hashl].next=a[i].next;
    a[i].next=hashl;
    hashl++;                                //以上6行用于第一�ơ插入元素（即while循环未执行）或while循环break退出的插入
    return hashl-1;
}

int main()
{
    int n,i,tmp,left,ans;
    while(scanf("%d",&n)!=EOF)
    {
        for(i=0;i            a[i].next=-1;
        hashl=PRIME;
        left=0;
        ans=1;
        scanf("%d",&b[0]);
        tmp=hash(b[0]);
        a[tmp].num++;
        for(i=1;i        {
            scanf("%d",&b[i]);
            tmp=hash(b[i]);
            a[tmp].num++;
            if(a[tmp].num<=1)     //插入的数字以前没有出现过�Q�肯定包含在ans�?br>            {
                ans=i-left+1;
                continue;
            }
            while(1)                     //对应于if的else,即a[tmp].num>=2�Q�即插入的数字以前出现过。如果是在left位置出现�q�，则left右移�Q�如果是�?#8220;left双��Q�i左边”出现�q�，则说明目前的i-left+1和ans都可以包括全部的知识点，当然取小的了�Q?nbsp;
            {
                tmp=hash(b[left]);
                if(a[tmp].num<=1)
                    break;
                a[tmp].num--;
                left++;
            }
            if(ans>i-left+1)
                ans=i-left+1;
        }
        printf("%d\n",ans);
    }
    return 0;
}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/cugbliang/archive/2008/06/01/2497376.aspx

luis 2009-07-01 13:00 发表评论

矛_��合�ƈ问题

luis — Tue, 30 Jun 2009 12:12:00 GMT

转帖
在一个圆形操场的四周摆放着n堆石子。现要将矛_��有次序地合�ƈ成一堆。规定每�ơ只能选相�ȝ��2堆石子合�q�成新的一堆，�q�将新的一堆石子数��Cؓ该次合�ƈ的得分。试设计一个算法，计算出将n堆石子合�q�成一堆的最��得分和最大得分�?nbsp;

假设有n堆石子需要合�q?可以设计一�?*n-1个元素的数组来存储每堆石子的个数�?
分析最优解的结构：假设有石头AiAi+1……Aj需要合�q?��CؓA[i,j].如果设最后一�ơ合�q�发生在Ak与Ak+1之间(i<=k可以假设计算A[0,n-1]的一个最优次序所包含的计��子链A[0,k]和A[K+1,n-1]的次序也是最优的.
证明:
假设存在一个比计算A[0,k]的次序得分更��的�ơ序,则用此次序来替换原来计算A[0,k]的次�?那么此时计算A[0,n-1]�ơ序的得分就会比最优次序所得到的分数更��?�q�与假设相矛�?同理可证�?计算A[0,n-1]的一个最优次序所包含的另一个计��子链A[k+1,n-1]的次序也是最优的!

�l�g��所�q?此题满��最优子�l�构性质,因此可以用动态规划算法来求解.
建立递归关系
设m[i][j]表示A[i,j]的计��结�?
当i=j�?表示只有一堆石�?不能合�ƈ,因此得分为零,所以m[i,j]=0;
当im[i,j]=m[i,k]+m[k+1,j]+totalValue(i,j)(i<=k
可用矩阵�q�乘的最优计��次序问题来求解�q�题.可选用自顶向下的备忘录��法或是自底向上的动态规划算�?

以下代码使用动态规划算�?

void MatrixChain(int *p,int n,int **m,int flag) //矩阵�q�乘��法
{
for(int i=0;im[i][i]=0;
for(int r=2;rfor(int i=0;i{
int j=i+r-1;
int temp=totalValue(i,j,p);
m[i][j]=m[i+1][j]+temp;
for(int k=i+1;k{
int t=m[i][k]+m[k+1][j]+temp;
if(!flag) //求最��得�?
{
if(t m[i][j]=t;
}
else //求最大得�?
if(t>m[i][j])
m[i][j]=t;
}
}
}
MatrixChain(inputNum,2*n-1,m,0); //计算最��得�?
int resultMin=m[0][n-1];
for(i=1;i<=n-1;i++)
if(resultMin>m[i][n-1+i])
resultMin=m[i][n-1+i];

MatrixChain(inputNum,2*n-1,m,1); //计算最大得�?
int resultMax=m[0][n-1];
for(i=1;i<=n-1;i++)
if(resultMaxresultMax=m[i][n-1+i];

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/lyflower/archive/2008/03/05/2150239.aspx

一�Q�试�?br>      在一个园形操场的四周摆放N堆石子（N≤100�Q�，现要��石子有�ơ序地合�q�成一堆。规�?br>      每次只能选相�ȝ��两堆合�ƈ成新的一堆，�q�将新的一堆的矛_��敎ͼ��Cؓ该次合�ƈ的得分�?br>      �~�一�E�序�Q�由文�g��d��堆数N及每堆的矛_��敎ͼ�≤�Q�０�Q�，
      ①选择一�U�合�q�石子的�Ҏ��Q��得做N�Q?�ơ合�qӞ��得分的��d��最��；
      ②选择一�U�合�q�石子的�Ҏ��Q��得做N�Q?�ơ合�qӞ��得分的��d��最大�?br>      例如�Q�所�C�的�Q�堆矛_��Q�每堆石子数�Q�从最上面的一堆数��P��时针数�Q�依
      �ơ�ؓ�Q�５�Q�４。则�Q�次合�ƈ得分��d��最��的�Ҏ��Q�８�Q�１�Q�＋�Q�２�Q�４�Q?br>      得分最大的�Ҏ��为：�Q�４�Q�１�Q�＋�Q�２�Q�５�Q?br>      输入数据�Q?br>      文�g名由键盘输入�Q�该文�g内容为：
      �W�一行�ؓ矛_��堆数N�Q?br>      �W�二行�ؓ每堆的石子数�Q�每两个��C��间用一个空格符分隔�?br>      输出数据�Q?br>      输出文�g名�ؓoutput.txt
      从第1至第N行�ؓ得分最��的合�ƈ�Ҏ��。第N�Q?行是�I��。从�W�N�Q?行到�W?N�Q?行是�?br>      分最大合�q�方案�?br>      每种合�ƈ�Ҏ��用N行表�C�，其中�W�i行（1≤i≤N�Q�表�C�第i �ơ合�q�前各堆的石子数�Q�依
      ��时针次序输出，哪一堆先输出均可�Q��?要求��待合�ƈ的两堆石子数以相应的负数表示�Q�以便标识�?/font>

      输入输出范例�Q?br>      输入文�g内容�Q?br>      �Q?br>      �Q?�Q�９ �Q?br>      输出文�g内容�Q?br>      �Q�４ �Q?�Q?�Q�４
      �Q�８�Q�５ �Q?br>      �Q�１�Q?�Q�９
      �Q�２

      �Q?�Q�５ �Q�９ �Q?br>      �Q?�Q�１�Q?�Q�４
      �Q�４�Q�１�Q?br>      �Q�２

      二．��法分析
      竞赛中多数选手都不�U�而同地采用了��可能��D��目标的贪心法来逐次合�ƈ�Q�从最上面
      的一堆开始，沉K��旉��方向排成一个序列�?�W�一�ơ选得分最��（最大）的相��M��堆合�qӞ��
      形成新的一堆；接下来，在N�Q?堆中选得分最��（最大）的相��M��堆合�q?#8230;…�Q�依�ơ类推，
      直至所有石子经N�Q?�ơ合�q�后形成一堆�?/font>

      例如有６堆石子，每堆矛_��敎ͼ�从最上面一堆数��P��时针数�Q�依�ơ�ؓ�Q?�Q�６ �Q?�Q?�Q?
      要求选择一�U�合�q�石子的�Ҏ��Q��得做�Q�次合�ƈ�Q�得分的��d��最��?br>      按照贪心法，合�ƈ的过�E�如下：
      每次合�ƈ得分
      �W�一�ơ合�q?�Q?�Q?�Q?�Q?�Q?�Q?->�Q?br>      �W�二�ơ合�q?�Q?�Q?�Q?�Q?�Q?nbsp;   ->�Q?br>      �W�三�ơ合�q?�Q?�Q?�Q?�Q?nbsp;      ->�Q?br>      �W�四�ơ合�q?�Q?�Q?�Q?nbsp;         ->�Q�５
      �W�五�ơ合�q?�Q�５ �Q?nbsp;          ->�Q�４
      24
      ��d��分＝�Q�＋�Q�＋�Q�＋�Q�５�Q�２�Q�＝�Q�２

      但是当我们仔�l�琢��后�Q�可得出另一个合�q�石子的�Ҏ��Q?br>      每次合�ƈ得分
      �W�一�ơ合�q?�Q?�Q?�Q?�Q?�Q?�Q?nbsp; ->�Q?br>      �W�二�ơ合�q?�Q?�Q?�Q?�Q?�Q?nbsp;    ->�Q�３
      �W�三�ơ合�q?�Q�３ �Q?�Q?�Q?nbsp;     ->�Q?br>      �W�四�ơ合�q?�Q�３ �Q?�Q?nbsp;        ->�Q�１
      �W�五�ơ合�q?�Q�３ �Q�１          ->�Q�４
      24
      ��d��分＝�Q�＋�Q�＋�Q�１�Q�１�Q�＋�Q�４�Q�６�Q?br>      昄��Q�后者比贪心法得出的合�ƈ�Ҏ��更优�?题目中的�C�Z��故意造成一个贪心法解题�?br>      假像�Q�诱使读者进�?#8220;陷阱”。�ؓ了帮助读者从�q�个“陷阱”里走出来�Q?我们先来明确一个问题：

      �Q�．最佛_��q�过�E�符合最佛_��?br>      使用贪心法至所以可能出错，
      是因为每一�ơ选择得分最��（最大）的相��M��堆合�qӞ��不一定保证余下的合�ƈ�q�程能导致最优解。聪明的读者马上会惛_��一�U�理想的假设�Q�如果N�Q?�ơ合�q�的全局最优解包含了每一�ơ合�q�的子问题的最优解�Q�那么经�q�样的N�Q?�ơ合�q�后的得分��d��必然是最优的�?br>      例如上例中第五次合�ƈ矛_��数分别�ؓ�Q�３和１�Q�的盔R��两堆�?
      �q�两堆石头分别由最初的�W�１�Q�２�Q�３堆（矛_��数分别�ؓ�Q�，�Q�，�Q�）和第�Q�，�Q�，�Q�堆�Q�石头数分别为５�Q�４�Q�２�Q�经�Q�次合�ƈ后�Ş成的。于是问题又归结为如何��得这两个子序列的N�Q?
      �ơ合�q�的得分��d��最优。�ؓ了实现这一目标�Q�我们将�W�１个序列又一分�ؓ二：�W�１、２堆构成子序列�Q�，
      �W�３堆�ؓ子序列２。第一�ơ合�q�子序列�Q�中的两堆，得分�Q�；
      �W�二�ơ再��之与子序列�Q�的一堆合�qӞ��得分�Q�３。显然对于第�Q�个子序列来��_��q�样的合�q�方案是最优的。同��P��我们��第�Q�个子序列也一分�ؓ二；�W�４堆�ؓ子序列１�Q�第�Q�，�Q�堆构成子序列２。第三次合�ƈ子序列２中的�Q�堆�Q�得分６�Q�第四次再将之与子序列１中的一堆合�qӞ��得分�Q�３。显然对于第二个子序列来��_��q�样的合�q�方案也是最优的�?
      由此得出一个结论──�Q�堆矛_��l?br>      �q�这��L��Q�次合�ƈ后，得分的��d��最��。我们把每一�ơ合�q�划分�ؓ阶段�Q�当前阶�D�中计算出的得分和作为状态，
      如何在前一�ơ合�q�的基础上定义一个能使目前得分��d��最大的合�ƈ�Ҏ��作�ؓ一�ơ决�{�。很昄��Q�某阶段的状态给定后�Q�则以后各阶�D늚�决策不受�q�阶�D�以前各�D늊�态的影响�?
      �q�种无后效性的性质�W�最佛_��理，因此可以用动态规划的��法求解�?/font>

      �Q�．动态规划的方向和初值的讑֮�
      采用动态规划求解的关键是确定所有石子堆子序列的最佛_��q�方案�?�q�些矛_��堆子序列包括�Q?br>      ｛第�Q�堆、第�Q�堆｝、｛�W�２堆、第�Q�堆｝�?#8230;…、｛�W�N堆、第�Q�堆｝；
      ｛第�Q�堆、第�Q�堆、第�Q�堆｝、｛�W�２堆、第�Q�堆、第�Q�堆｝�?#8230;…、｛�W�N堆、第�Q�堆、第�Q�堆｝；……
      ｛第�Q�堆�?#8230;…、第N堆｝｛第�Q�堆�?#8230;…、第N堆、第�Q�堆�?#8230;…｛第N堆、第�Q�堆�?#8230;…、第N�Q�１堆｝

      ��Z��便于�q�算�Q�我们用〔i�Q�j〕表�C�Z��个从�W�i堆数��P��时针数j堆时的子序列｛第i堆、第i�Q�１堆�?#8230;…、第�Q�i�Q�j�Q?�Q�mod n堆｝
      它的最佛_��q�方案包括两个信息：
      ①在该子序列的各堆石子合�q�成一堆的�q�程中，各次合�ƈ得分的��d��Q?br>      ②�Ş成最佛_��分和的子序列�Q�和子序列２。由于两个子序列是相�ȝ��Q?因此只需��C��子序列１的堆敎ͼ�
      �?br>      f〔i�Q�j〕──��子序列〔i�Q�j〕中的j堆石子合�q�成一堆的最佛_��分和�Q?br>      c〔i�Q�j〕──��〔i�Q�j〕一分�ؓ二，其中子序列１的堆敎ͼ�
      �Q�１≤i≤N�Q�１≤j≤N�Q?br>      昄��Q�对每一堆石子来��_��它的
      f〔i�Q�１〕＝�Q?
      c〔i�Q�１〕＝�Q?�Q�１≤i≤N�Q?br>      对于子序列〔i�Q�j〕来��_��若求最��得分��d��Q�f〔i�Q�j〕的初始��gؓ∞�Q?若求最大得分��d��Q�f〔i�Q�j〕的初始��gؓ�Q�。（�Q?#8804;i≤N�Q�２≤j≤N�Q��?br>      动态规划的方向是顺�?即从上而下)。先考虑含二堆石子的N个子序列�Q�各子序列分别从�W�１堆、第�Q�堆�?#8230;…、第N堆数��P��时针数�Q�堆�Q�的合�ƈ�Ҏ��
      f〔１�Q�２〕，f〔２�Q�２〕，……�Q�f〔N�Q�２�?br>      c〔１�Q�２〕，c〔２�Q�２〕，……�Q�c〔N�Q�２�?br>      然后考虑含三堆石子的�Q�个子序列（各子序列分别从第�Q�堆、第�Q�堆�?#8230;…、第�Q�堆数�v�Q�顺旉��敎ͼ�堆）的合�q�方�?br>      f〔１�Q�３〕，f〔２�Q�３〕，……�Q�f〔N�Q�３�?br>      c〔１�Q�３〕，c〔２�Q�３〕，……�Q�c〔N�Q�３�?br>      ……
      依次�c�L��Q�直臌��虑了含N堆石子的N个子序列�Q�各子序列分别从�W�１堆、第�Q�堆�?……、第N堆数��P��时针数N堆）的合�q�方�?br>      f〔１�Q�N〕，f〔２�Q�N〕，……�Q�f〔N�Q�N�?br>      c〔１�Q�N〕，c〔２�Q�N〕，……�Q�c〔N�Q�N�?br>      最后，在子序列〔１�Q�N〕，〔２�Q�N〕，……�Q�〔N�Q�N〕中�Q�选择得分��d��Q�f��|��最��（或最大）的一个子序列〔i�Q�N〕（�Q?#8804;i≤N�Q�，由此出发倒推合�ƈ�q�程�?/font>

      �Q�．动态规划方�E�和倒推合�ƈ�q�程
      对子序列〔i�Q�j〕最后一�ơ合�qӞ��其得分�ؓ�W�i堆数��P��时针数j堆的矛_��L��t。被合�ƈ的两堆石子是由子序列〔i�Q�k〕和〔（i�Q�k�Q�１�Q�mod
      n�Q�１�Q�j�Q�k〕（�Q?#8804;k≤j�Q�１�Q�经有限�ơ合�q��Ş成的。�ؓ了求出最佛_��q�方案中的k��|��我们定义一个动态规划方�E�：
      当求最大得分��d��?br>      f〔i�Q�j〕＝max｛f〔i�Q�k〕＋f〔x�Q�j-k〕＋t�?br>      �Q?#8804;k≤j�Q�１
      c〔i�Q�j〕＝k�?f〔i�Q�j〕＝f〔i�Q�k〕＋f〔x�Q�j-k〕＋t
      �Q�２≤�?#8804;ｎ，�Q?#8804;�?#8804;ｎ）

      当求最��得分��d��?br>      f〔i�Q�j〕＝min｛f〔i�Q�k〕＋f〔x�Q�j�Q�k〕＋t�?br>      �Q?#8804;k≤j�Q�１
      c〔i�Q�j〕＝k�?f〔i�Q�j〕＝f〔i�Q�k〕＋f〔x�Q�j-k〕＋t
      �Q�２≤�?#8804;ｎ，�Q?#8804;�?#8804;ｎ）
      其中x�Q�（i�Q�k�Q�１�Q�modn�Q�１�Q�即�W�i堆数��P��时针数k�Q�１堆的堆序受��?/font>

      例如对上面例子中的６(�Q?�Q?�Q?�Q?�Q?�Q?)堆石子，按动态规划方�E�顺推最��得分和�?依次得出含二堆石子的�Q�个子序列的合�ƈ�Ҏ��
      f〔１�Q�２〕＝�Q?f〔２�Q�２〕＝�Q�０ f〔３ �Q�２〕＝�Q�１
      c〔１�Q�２〕＝�Q?c〔２�Q�２〕＝�Q?c〔３�Q�２〕＝�Q?br>      f〔４�Q�２〕＝�Q?f〔５�Q�２〕＝�Q?f〔６�Q�２〕＝�Q?br>      c〔４�Q�２〕＝�Q?c〔５�Q?�Q�〕＝�Q?c〔６�Q�２〕＝�Q?/font>

      含三堆石子的�Q?�Q?�Q?�Q?�Q?�Q?�Q?)个子序列的合�q�方�?br>      f〔１�Q�３〕＝�Q�０ f〔２�Q�３〕＝�Q�５ f〔３�Q�３〕＝�Q�４
      c〔１�Q�３〕＝�Q?c〔２�Q�３〕＝�Q?c〔３�Q�３〕＝�Q?br>      f〔４�Q�３〕＝�Q�７ f〔５�Q�３〕＝�Q�４ f〔６�Q�３〕＝�Q�４
      c〔４�Q�３〕＝�Q?c〔５�Q�３〕＝�Q?c〔６�Q�３〕＝�Q?/font>

      含四堆石子的�Q?�Q?�Q?�Q?�Q?�Q?�Q?)个子序列的合�q�方�?br>      f〔１�Q�４〕＝�Q�６ f〔２�Q�４〕＝�Q�８ f〔３�Q�４〕＝�Q�４
      c〔１�Q�４〕＝�Q?c〔２�Q�４〕＝�Q?c〔３�Q�４〕＝�Q?br>      f〔４�Q�４〕＝�Q�８ f〔５�Q�４〕＝�Q�６ f〔６�Q�４〕＝�Q�９
      c〔４�Q�４〕＝�Q?c〔５�Q�４〕＝�Q?c〔６�Q�４〕＝�Q?/font>

      含五堆石子的�Q?�Q?�Q?�Q?�Q?�Q?�Q?)个子序列的合�q�方�?br>      f〔１�Q�５〕＝�Q�１ f〔２�Q�５〕＝�Q�８ f〔３�Q�５〕＝�Q�５
      c〔１�Q�５〕＝�Q?c〔２�Q�５〕＝�Q?c〔３�Q�５〕＝�Q?
      f〔４�Q�５〕＝�Q�１ f〔５�Q�５〕＝�Q�３ f〔６�Q�５〕＝�Q�５
      c〔４�Q�５〕＝�Q?c〔５�Q�５〕＝�Q?c〔６�Q�５〕＝�Q?/font>

      含六堆石子的�Q?�Q?�Q?�Q?�Q?�Q?�Q?)个子序列的合�q�方�?br>      f〔１�Q�６〕＝�Q�１ f〔２�Q�６〕＝�Q�２ f〔３�Q�６〕＝�Q�１
      c〔１�Q�６〕＝�Q?c〔２�Q�６〕＝�Q?c〔３�Q�６〕＝�Q?
      f〔４�Q�６〕＝�Q�１ f〔５�Q�６〕＝�Q�１ f〔６�Q�６〕＝�Q�２
      c〔４�Q�６〕＝�Q?c〔５�Q�６〕＝�Q?c〔６�Q�６〕＝�Q?/font>

      f〔１�Q�６〕是f〔１�Q�６〕，ｆ〔２�Q�６〕，……f〔６�Q�６〕中的最��|��表明最��得分和是由序列〔１�Q�６〕经�Q�次合�ƈ得出的。我们从�q�个序列出发�Q?
      按下�q�方法倒推合�ƈ�q�程�Q?br>      由c〔１�Q�６〕＝�Q�可知，�W�５�ơ合�q�的两堆矛_��分别由子序列〔１�Q�３〕和子序列〔４�Q?〕经�Q�次合�ƈ后得出。其中c〔１�Q�３〕＝�Q�可知由子序列〔１�Q�３〕合�q�成的一堆石子是由子序列〔１�Q�２〕和�W�三堆合�q�而来的。而c〔１�Q�２〕＝�Q�，以表明了子序列〔１�Q�２〕的合�ƈ�Ҏ��是第�Q�堆合�ƈ�W�２堆�?br>      由此倒推回去�Q�得出第�Q�，�W�２�ơ合�q�的�Ҏ��Q�每�ơ合�q�得�?
      �W�一�ơ合�q?�Q?�Q?�Q?#8230;… 　　　->�Q?br>      �W�二�ơ合�q?�Q?�Q?#8230;…          ->�Q�３
      �Q�３……
      子序列〔１�Q�３〕经�Q�次合�ƈ后合�q�成�Q�堆�Q?�Q�次合�ƈ的得分和�Q�７�Q�１�Q�＝�Q�０�?br>      ｃ〔４�Q�３〕＝�Q�，可知由子序列〔４�Q�３〕合�q�成的一堆石子是��q��Q�堆和子序列〔５�Q?br>      �Q�〕合�q�而来的。而c〔５�Q�２〕＝�Q�，又表明了子序列〔５�Q�２〕的合�ƈ�Ҏ��是第�Q�堆合�ƈ�W�６堆。由此倒推回去�Q�得出第�Q�、第�Q�次合�ƈ的方�?
      每次合�ƈ得分�Q?br>       �W�三�ơ合�q?……�Q�４ �Q?nbsp;    ->�Q?
      �W�四�ơ合�q?……�Q?�Q?nbsp;       ->�Q�１
      ……�Q�１
      子序列〔４�Q�３〕经�Q�次合�ƈ后合�q�成�Q�堆�Q�２�ơ合�q�的得分和＝�Q�＋�Q�１�Q�１�Q��?br>      �W�五�ơ合�q�是��最后两堆合�q�成�Q�堆�Q�该�ơ合�q�的得分为２�Q��?br>      昄��Q�上�q�ͼ��ơ合�q�的得分��d��为最��?br>      �Q�０�Q�１�Q�＋�Q�４�Q�６�Q?/font>

      上述倒推�q�程�Q�可�׃��个print�Q�〔子序列〕）的递归��法描述
      procedure print �Q�〔i�Q�ｊ〕）
      begin
      if ｊ〈〉１ then ｛��l�倒推合�ƈ�q�程
      begin
      print�Q�〔i�Q�c〔i�Q�j〕〕；｛倒推子序列１的合�q�过�E�｝
      print�Q�〔i�Q�c〔i�Q�j〕－�Q�〕mod n�Q�１�Q�j�Q�c〔i�Q�j〕）
      ｛倒推子序列２的合�q�过�E�｝
      for K�Q�＝�Q?to N do｛输出当前被合�ƈ的两堆石子｝
      if �Q�第K堆石子未从圈内去除）
      then begin
      if�Q�K�Q�i�Q�or�Q�K�Q�X�Q�then�|�第K堆石子待合�ƈ标志
      else�W�K堆石子未被合�qӞ��
      end�Q�｛then�?br>      �W�i堆石子数←�W�i堆石子数�Q�第X堆石子数�Q?br>      ��第X堆石子从圈内去除�Q?br>      end�Q�｛then�?br>      end�Q�｛print�?br>      例如�Q�调用print�Q�〔１�Q�６〕）后的�l�果如下�Q?br>                           print�Q�〔１�Q�６〕）�?br>                                ┌──────┴──────�?br>                     print�Q�〔１�Q�３〕）�?nbsp;              print�Q�〔４�Q�３〕）�?br>                ┌─────┴─────�?nbsp;              ┌─────┴─────�?br>          print(〔１�Q�２�?�?print(�?�Q?�?     print(�?�Q?�? print(〔５�Q�２�?�?br>       ┌──────┴──────�?nbsp;                        ┌──────┴──────�?nbsp;
      print�Q��?,1〕）        print�Q��?,1〕）               print�Q��?,1〕）
      print�Q��?,1〕）
      �Q�图6.2-5�Q?br>      其中回溯�?br>      �?昄�� Q?�Q�６ �Q?�Q?
      �?昄�� Q?�Q�５ �Q?�Q?
      �?昄�� Q�３ �Q�４ �Q?br>      �?昄�� Q�３�Q?�Q?br>      �?昄�� Q�３ �Q�１
      �?调用print�q�程后，应显�C�６堆石子的��L��作�ؓ�W�５�ơ合�q�的得分�?/font>

      Program Stones;
      Type
      Node = Record{当前序列的合�q�方案}
      c : Longint;{得分和}
      d : Byte{子序�?的堆数}
      End;
      SumType = Array [1..100,1..100] of Longint;
      {sumtype[i,j]-子序列[i,j]的石子��L��}
      Var
      List : Array [1..100,1..100] of Node;
      {list[i,j]-子序列[i,j]的合�q�方案}
      Date, Dt : Array [1..100] of Integer;
      {Date[i]-�W�i堆石子数,Dt-暂存Date}
      Sum : ^SumType;{sum^[i,j]-指向子序列[i,j]的石子��L��的指针}
      F : Text;{文�g变量}
      Fn : String;{文�g名串}
      N, i, j : Integer;{N-矛_��堆数,i,j-循环变量}

      Procedure Print(i, j : Byte);{递归打印子序列[i,j]的合�q�过�E�}
      Var
      k, x : Shortint;{k-循环变量;x-子序�?中首堆石子的序号}
      Begin
      If j <> 1 Then Begin{�l�箋倒推合�ƈ�q�程}
        Print(i, List[i,j].d);{倒推子序�?的合�q�过�E�}
        x := (i + List[i, j].d - 1) Mod N + 1;{求子序列2中首堆石子的序号}
        Print(x, j - List[i, j].d);{倒推子序�?的合�q�过�E�}
        For k := 1 to N Do{输出当前合�ƈ�W�i�?�W�x堆石子的�Ҏ��}
          If Date[k] > 0 Then Begin
             If (i= k)or(x=k)Then Write(F, - Date[k], ' ')
             Else Write(F, Date[k], ' ')
          End; { Then }
        Writeln(F);{输出换行�W�}
        Date[i] := Date[i] + Date[x];{原第i堆和�W�x堆合�q�成�W�ｉ堆}
        Date[x] := - Date[x]{��原�W�x堆从圈内去除}
        End { Then }
      End; { Print }

      Procedure Main(s : Shortint);
      Var
        i, j, k : Integer;
        t, x : Longint;
      Begin
        For i := 1 to N Do Begin{仅含一堆石子的序列不存在合�q�}
          List[i, 1].c := 0;
          List[i, 1].d := 0
        End; {For}
        For j := 2 to N Do{��推�?�?�?�?#8230;…含N堆石子的各子序列的合�q�方案}
          For i := 1 to N Do Begin{当前考虑从第i堆数�?��时针数j堆的子序列}
            If s = 1 Then List[i, j].c := Maxlongint{合�ƈ[i,j]子序列的得分和初始化}
             Else List[i, j].c := 0;
            t := Sum^[i, j];{最后一�ơ合�q�的得分为[i,j]子序列的矛_��L��}
            For k := 1 to j - 1 Do Begin{子序�?的石子堆��C��ơ考虑1�?#8230;…j-1堆}
              x := (i + k - 1) Mod N + 1;{求子序列2首堆序号}
              If (s=1) And (List[i,k].c + List[x,j-k].c+t < List[i, j].c)
      Or (s=2) And (List[i,k].c + List[x,j-k].c+t > List[i, j].c)
      { 若该合�ƈ�Ҏ��为目前最�?则记下}
              Then Begin
                List[i, j].c := List[i, k].c + List[x, j - k].c + t;
                List[i, j].d := k
              End { Then }
            End { For }
        End; { For }
      {在子序列[1,N],[2,N],……,[N, N]中选择得分��d��最��?或最�?的一个子序列}
        k := 1; x := List[1, N].c;
        For i := 2 to N Do
          If (s = 1) And (List[i, N].c < x) Or (s = 2) And
      (List[i, N].c > x) Then Begin
             k := i; x := List[i, N].c
          End; { Then }
        Print(k, N);{由此出发,倒推合�ƈ�q�程}
        Writeln(F, Sum^[1, N]);{输出最后一�ơ将矛_��合�ƈ成一堆的矛_��L��}
        Writeln(F);
        Writeln(list[k, N].c)
      End; { Main }

      Begin
        Write('File name = ');{输入文�g名串}
        Readln(Fn);
        Assign(F, Fn);{该文件名串与文�g变量�q�接}
        Reset(F);{文�g��d��备}
        Readln(F, N);{��d��矛_��堆数}
        For i := 1 to N Do Read(F, Date[i]);{��d��每堆矛_��数}
        New(Sum);{求每一个子序列的石子数sum}
        For i := 1 to N Do Sum^[i, 1] := Date[i];
        For j := 2 to N Do
          For i := 1 to N Do
            Sum^[i, j] := Date[i] + Sum^[i Mod N + 1, j - 1];
        Dt := Date;{暂存合�ƈ前的各堆矛_��,�l�构相同的变量可�怺�赋值}
        Close(F);{关闭输入文�g}
        Assign(F, 'OUTPUT.TXT');{文�g变量与输出文件名串连接}
        Rewrite(F);{文�g写准备}
        Main(1);{求得分和最��的合�ƈ�Ҏ��}
        Date := Dt;{恢复合�ƈ前的各堆矛_��}
        Main(2);{求得分和最大的合�ƈ�Ҏ��}
        Close(F){关闭输出文�g}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/lyflower/archive/2008/03/05/2150251.aspx

luis 2009-06-30 20:12 发表评论

浪潮AV色综合久久天堂,亚洲国产成人久久一区WWW,99久久99久久精品国产

长春赢鼎教育公司 原是传销机构

��Z��Socket的UDP和TCP�~�程介绍

[转蝲]Vector遍历

[转蝲]使用 Java �~�程语言实现�U�程

joj 1092 To the Max 转帖Dp�l�典

哈希�?poj 3320 Jessica's Reading Problem

矛_��合�ƈ问题

长春赢鼎教育公司原是传销机构