C++博客-I believe-随笔分类-转载

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

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

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

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

基于Socket的UDP和TCP编程介绍

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

基于Socket的UDP和TCP编程介绍

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

一、概述

　　TCP（传输控制协议）和UDP（用户数据报协议是网络体系结构TCP/IP模型中传输层一层中的两个不同的通信协议。

　　TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(stream socket)的一种。

　　UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口(datagram socket)的一种。

　　二、TCP和UDP介绍

　　1）基本TCP客户—服务器程序设计基本框架

　　说明：（三路握手）

　　1.客户端发送一个SYN段（同步序号）指明客户打算连接的服务器端口，以及初始化序号(ISN) 。

　　2.服务器发回包含服务器的初始序号的SYN报文段作为应答。同时，将确认序号(ACK)设置为客户的ISN加1以对客户的SYN 报文段进行确认。一个SYN将占用一个序号。

　　3.客户必须将确认序号设置为服务器的ISN加1以对服务器的SYN报文段进行确认。

　　2) 基本TCP客户—服务器程序设计基本框架流程图

　　3) UDP和TCP的对比：

　　从上面的流程图比较我们可以很明显的看出UDP没有三次握手过程。

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

　　TCP优缺点：

　　优点：

　　1．TCP提供以认可的方式显式地创建和终止连接。

　　2．TCP保证可靠的、顺序的（数据包以发送的顺序接收）以及不会重复的数据传输。

　　3．TCP处理流控制。

　　4．允许数据优先

　　5．如果数据没有传送到，则TCP套接口返回一个出错状态条件。

　　6．TCP通过保持连续并将数据块分成更小的分片来处理大数据块。—无需程序员知道

　　缺点： TCP在转移数据时必须创建（并保持）一个连接。这个连接给通信进程增加了开销，让它比UDP速度要慢。

　　UDP优缺点：

　　1．UDP不要求保持一个连接

　　2．UDP没有因接收方认可收到数据包（或者当数据包没有正确抵达而自动重传）而带来的开销。

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

　　4．在一个数据包连接一个数据包的基础上，UDP要求的网络带宽比TDP更小。

　　三、Socket编程

　　Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。

　　Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的 Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的 Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

　　1、socket调用库函数主要有：

　　创建套接字

　　Socket(af,type,protocol)

　　建立地址和套接字的联系

　　bind(sockid, local addr, addrlen)

　　服务器端侦听客户端的请求

　　listen( Sockid ,quenlen)

　　建立服务器/客户端的连接 (面向连接TCP）

　　客户端请求连接

　　Connect(sockid, destaddr, addrlen)

　　服务器端等待从编号为Sockid的Socket上接收客户连接请求

　　newsockid=accept(Sockid，Clientaddr, paddrlen)

　　发送/接收数据

　　面向连接：send(sockid, buff, bufflen)

　　recv( )

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

　　recvfrom( )

　　释放套接字

　　close(sockid)

　　2、TCP/IP应用编程接口（API）

　　服务器的工作流程：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，然后调用listen在相应的socket上*，当accpet接收到一个连接服务请求时，将生成一个新的socket。服务器显示该客户机的IP地址，并通过新的socket向客户端发送字符串" hi,I am server!"。最后关闭该socket。

main()
{
int sock_fd,client_fd; /*sock_fd：*socket；client_fd：数据传输socket */
struct sockaddr_in ser_addr; /* 本机地址信息 */
struct sockaddr_in cli_addr; /* 客户端地址信息 */
char msg[MAX_MSG_SIZE];/* 缓冲区*/
ser_sockfd=socket(AF_INET,SOCK_STREAM,0);/*创建连接的SOCKET */
if(ser_sockfd<0)
{/*创建失败 */
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)
{ /*绑定失败 */
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)
{/* 等待接收客户连接请求*/
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);/*在屏幕上打印出来 */
strcpy(msg,"hi,I am server!");
send(cli_addr,msg,sizeof(msg),0); /*发送的数据*/
close(cli_addr);
}
}
close(ser_sockfd);
}

　　客户端的工作流程：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，请求连接服务器，通过新的socket向客户端发送字符串" hi,I am client!"。最后关闭该socket。

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);/*创建连接的SOCKET */
if(ser_sockfd<0)
{/*创建失败 */
fprintf(stderr,"socker Error:%s\n",strerror(errno));
exit(1);
}
/* 初始化客户端地址*/
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)
{
/*棒定失败 */
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)/*请求连接*/
{
/*连接失败 */
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);/*在屏幕上打印出来 */
close(cli_sockfd);
}

　　3、UDP/IP应用编程接口（API）

　　服务器的工作流程：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，接收到一个客户端时，服务器显示该客户端的IP地址，并将字串返回给客户端。

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 结构*/
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,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);
}
}

　　客户端的工作流程：首先调用socket函数创建一个Socket，填写服务器地址及端口号，从标准输入设备中取得字符串，将字符串传送给服务器端，并接收服务器端返回的字符串。最后关闭该socket。

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));
/* 从标准输入设备取得字符串*/
len=read(STDIN_FILENO,buffer,sizeof(buffer));
/* 将字符串传送给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 发表评论

java Vector排序及用法

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

temp=CustomerMaker.quickPassQueue.get(0);//获得首元素
  CustomerMaker.quickPassQueue.remove(0);//删除首元素

quickPassQueue.add();在末尾添加元素
----演示程序-----

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去掉一个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!");
}
}
-----------------排序程序------------------------------
import java.util.*;

class MyCompare implements Comparator //实现Comparator，定义自己的比较方法
{
public int compare(Object o1, Object o2) {
Elem e1=(Elem)o1;
Elem e2=(Elem)o2;

if(e1.get() > e2.get())//这样比较是降序,如果把-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 编程语言实现线程

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

使用 Java 编程语言实现线程

　　Java编程语言使多线程如此简单有效，以致于某些程序员说它实际上是自然的。尽管在 Java 中使用线程比在其他语言中要容易得多，仍然有一些概念需要掌握。要记住的一件重要的事情是 main() 函数也是一个线程，并可用来做有用的工作。程序员只有在需要多个线程时才需要创建新的线程。

　　Thread 类

　　Thread 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个从 Thread 类导出的新类。程序员必须覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数；而是必须调用 Thread 的 start() 函数，该函数再调用 run()。下面的代码说明了它的用法：

　　创建两个新线程

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();

　}
}

　　在本例中，我们可以看到一个简单的程序，它按两个不同的时间间隔（1 秒和 3 秒）在屏幕上显示当前时间。这是通过创建两个新线程来完成的，包括 main() 共三个线程。但是，因为有时要作为线程运行的类可能已经是某个类层次的一部分，所以就不能再按这种机制创建线程。虽然在同一个类中可以实现任意数量的接口，但 Java 编程语言只允许一个类有一个父类。同时，某些程序员避免从 Thread 类导出，因为它强加了类层次。对于这种情况，就要 runnable 接口。

　　Runnable 接口

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

　　创建两个新线程而不强加类层次

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();
　}
}

　　请注意，当使用 runnable 接口时，您不能直接创建所需类的对象并运行它；必须从 Thread 类的一个实例内部运行它。许多程序员更喜欢 runnable 接口，因为从 Thread 类继承会强加类层次。

　　synchronized 关键字

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

　　一个银行中的多项活动

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;
}
}

　　在此代码样例中潜伏着一个错误。如果此类用于单线程应用程序，不会有任何问题。但是，在多线程应用程序的情况中，不同的线程就有可能同时访问同一个 Account 对象，比如说一个联合帐户的所有者在不同的 ATM 上同时进行访问。在这种情况下，存入和支出就可能以这样的方式发生：一个事务被另一个事务覆盖。这种情况将是灾难性的。但是，Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这样，修订过的 Account 对象（如下所示）将不会遭受像数据损坏这样的错误：

　　对一个银行中的多项活动进行同步处理

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() 和 withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时，另一个函数就被阻塞。请注意， checkBalance() 未作更改，它严格是一个读函数。因为 checkBalance() 未作同步处理，所以任何其他方法都不会阻塞它，它也不会阻塞任何其他方法，不管那些方法是否进行了同步处理

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

joj 1092 To the Max 转帖Dp经典

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

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

2006-04-17 11:55

题目大意:

读入一个n*n的数组,比如

0 -2 -7 0

9 2 -6 2

-4 1 -4 1

-1 8 0 -2

从里面任意截取一个矩阵,使得矩阵所包含的数字的和最大.

截取出来的矩阵,和为15

9 2

-4 1

-1 8

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

POJ 1050 我的解题报告：

这个题目很经典的说，O（N^3）的DP。

首先偶们考察这样的题目，简化版：

已知一列数，求任意连续若干个数和的最大值。

SAMPLE： 3 2 -6 2 -1 7

原数3        2      -6       2      -1       7

处理3        5      -1       2       1       8

因为是连续若干个自然数的和，那么，前面的某个数字取与不取的条件在于：以前面这个数字为结尾的连续数的和最大值是否大于0，如果大于0，那么这个数字必然要会出现在包括数字的序列中，否则无法做到最大。

所以，显然。处理的原则是maxn[i]=max{0,maxn[i-1]}+a[i];

由于无须记录位置。所以，可以直接用一个变量sum代替maxn数组。O(n)的扫描即可。

单列数字的问题解决了，下面我们考察多列数字的

sample:

         0    -2    -7    0

         9     2    -6    2

        -4     1    -4    1

        -1     8     0   -2

我们可以将多列数字转换成单列数字来做！可以这样设想，结果是一个长方形，我们把他压扁，使得宽为1。

引入辅助数组st,st[i][j]代表第i列从第1行开始的数字累加到第j行的值。那么，我们每次压扁的时候，就可以用st[i][j]-st[i][k-1]来表示第i列从第k个数字累加到第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;

原文地址：http://hi.baidu.com/flymouse/blog/item/fd1378f05c7ff7c37931aac3.html

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

字符串哈希

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

这是第一种哈希函数，运行时间短，但内存占用多。哈希函数是怎么得到的？我也想知道。。。
#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;
}
这是用书中提到的ELFhash()函数，也没体现出时间上的优势，但空间上确实是省了不少，可能是计算ELFhash()时浪费了时间吧，处理字符串哈希冲突的办法目前只发现了线形探测法，虽然不理想，但愿将来能发现别的办法。
ELFhash函数在UNIX系统V 版本4中的“可执行链接格式”( Executable and Linking Format，即ELF )中会用到，ELF文件格式用于存储可执行文件与目标文件。ELFhash函数是对字符串的散列。它对于长字符串和短字符串都很有效，字符串中每个字符都有同样的作用，它巧妙地对字符的ASCII编码值进行计算，ELFhash函数对于能够比较均匀地把字符串分布在散列表中。
#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博客，转载请标明出处：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
这道题目可以用哈希表法也可以用二分查找法，现在用哈希，二分查找将在后面的博客中推出。
这道题目用到的是数的哈希，对于不需要删除的字典，哈希表是一种理想的实现方式。
1.哈希表的插入和查找算法
(1)计算函数值h(k)
(2)从槽h(k)开始，使用冲突解决策略定位包含关键码k的纪录
(3)如果需要插入，再槽内插入即可
两种操作的复杂度在忽略冲突时是O(1)
2.哈希函数的选取
本题使用最简单的直接取余法，除数为PRIME，最好是质数，可减小冲突。
3.冲突解决方法
开散列法（这也是大多数情况下使用的）
开散列法也叫拉链法，通俗地说就是“既然元素a和b都该放在里面，只好挤一挤了”。即在每个槽里存放所有该放在里面的元素。那么怎么把很多的元素放在槽里呢？只在槽里放一个链表表头就行了，该链表中包含所有该放在槽里的元素。但在实际中并不是这样做的，而是自己维护一个大数组，给链表元素分配数组下标，这样既方便又节省时间和空间。那么链表中的元素的排列顺序怎样呢？如果按照查找成功时的效率，显然可以按照访问的频率；而如果按照查找失败的效率，则可以按照关键值排序，即使查找失败也不需要遍历整个链表。这就是数据结构中的相互矛盾的两个问题，应根据实际情况协调。
#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，后面又插入99999时，那么99999>8,需要给99999重新分配                                                                           一个下标，即hashl，即前面提到的开散列法解决冲突
            break;
        else if(num==a[a[i].next].key)    //例如hash表中已有8，后面又插入8时，这是只要num++
            return a[i].next;
        i=a[i].next;                               //这句用于查找，如果哈希表中已有8和99999，那么你要找8时a[8].next指向的是较大的99999，那么你就必须沿着next走下去，因为这个所谓的链表是按减小的顺序排序的。最终走到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)     //插入的数字以前没有出现过，肯定包含在ans里
            {
                ans=i-left+1;
                continue;
            }
            while(1)                     //对应于if的else,即a[tmp].num>=2，即插入的数字以前出现过。如果是在left位置出现过，则left右移；如果是在“left右边，i左边”出现过，则说明目前的i-left+1和ans都可以包括全部的知识点，当然取小的了！
            {
                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博客，转载请标明出处：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堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。

假设有n堆石子需要合并,可以设计一个2*n-1个元素的数组来存储每堆石子的个数。
分析最优解的结构：假设有石头AiAi+1……Aj需要合并,简记为A[i,j].如果设最后一次合并发生在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]次序的得分就会比最优次序所得到的分数更少,这与假设相矛盾;同理可证明:计算A[0,n-1]的一个最优次序所包含的另一个计算子链A[k+1,n-1]的次序也是最优的!

综上所述,此题满足最优子结构性质,因此可以用动态规划算法来求解.
建立递归关系
设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

可用矩阵连乘的最优计算次序问题来求解这题.可选用自顶向下的备忘录算法或是自底向上的动态规划算法.

以下代码使用动态规划算法:

void MatrixChain(int *p,int n,int **m,int flag) //矩阵连乘算法
{
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博客，转载请标明出处：http://blog.csdn.net/lyflower/archive/2008/03/05/2150239.aspx

一．试题
      在一个园形操场的四周摆放N堆石子（N≤100），现要将石子有次序地合并成一堆。规定
      每次只能选相邻的两堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。
      编一程序，由文件读入堆数N及每堆的石子数（≤２０），
      ①选择一种合并石子的方案，使得做N－1次合并，得分的总和最小；
      ②选择一种合并石子的方案，使得做N－1次合并，得分的总和最大。
      例如，所示的４堆石子，每堆石子数（从最上面的一堆数起，顺时针数）依
      次为４５９４。则３次合并得分总和最小的方案：８＋１３＋２２＝４３
      得分最大的方案为：１４＋１８＋２２＝５４
      输入数据：
      文件名由键盘输入，该文件内容为：
      第一行为石子堆数N；
      第二行为每堆的石子数，每两个数之间用一个空格符分隔。
      输出数据：
      输出文件名为output.txt
      从第1至第N行为得分最小的合并方案。第N＋1行是空行。从第N＋2行到第2N＋1行是得
      分最大合并方案。
      每种合并方案用N行表示，其中第i行（1≤i≤N）表示第i 次合并前各堆的石子数（依
      顺时针次序输出，哪一堆先输出均可）。要求将待合并的两堆石子数以相应的负数表示，以便标识。

      输入输出范例：
      输入文件内容：
      ４
      ４５９４
      输出文件内容：
      －４５９－４
      －８－５９
      －１３－９
      ２２

      ４－５－９４
      ４－１４－４
      －４－１８
      ２２

      二．算法分析
      竞赛中多数选手都不约而同地采用了尽可能逼近目标的贪心法来逐次合并：从最上面
      的一堆开始，沿顺时针方向排成一个序列。第一次选得分最小（最大）的相邻两堆合并，
      形成新的一堆；接下来，在N－1堆中选得分最小（最大）的相邻两堆合并……，依次类推，
      直至所有石子经N－1次合并后形成一堆。

      例如有６堆石子，每堆石子数（从最上面一堆数起，顺时针数）依次为３４６５４２
      要求选择一种合并石子的方案，使得做５次合并，得分的总和最小。
      按照贪心法，合并的过程如下：
      每次合并得分
      第一次合并３４６５４２ ->５
      第二次合并５４６５４    ->９
      第三次合并９６５４       ->９
      第四次合并９６９          ->１５
      第五次合并１５９           ->２４
      24
      总得分＝５＋９＋９＋１５＋２４＝６２

      但是当我们仔细琢磨后，可得出另一个合并石子的方案：
      每次合并得分
      第一次合并３４６５４２ ->７
      第二次合并７６５４２     ->１３
      第三次合并１３５４２      ->６
      第四次合并１３５６         ->１１
      第五次合并１３１１          ->２４
      24
      总得分＝７＋６＋１１＋１３＋２４＝６１
      显然，后者比贪心法得出的合并方案更优。题目中的示例故意造成一个贪心法解题的
      假像，诱使读者进入“陷阱”。为了帮助读者从这个“陷阱”里走出来，我们先来明确一个问题：

      １．最佳合并过程符合最佳原理
      使用贪心法至所以可能出错，
      是因为每一次选择得分最小（最大）的相邻两堆合并，不一定保证余下的合并过程能导致最优解。聪明的读者马上会想到一种理想的假设：如果N－1次合并的全局最优解包含了每一次合并的子问题的最优解，那么经这样的N－1次合并后的得分总和必然是最优的。
      例如上例中第五次合并石子数分别为１３和１１的相邻两堆。
      这两堆石头分别由最初的第１，２，３堆（石头数分别为３，４，６）和第４，５，６堆（石头数分别为５，４，２）经４次合并后形成的。于是问题又归结为如何使得这两个子序列的N－2
      次合并的得分总和最优。为了实现这一目标，我们将第１个序列又一分为二：第１、２堆构成子序列１，
      第３堆为子序列２。第一次合并子序列１中的两堆，得分７；
      第二次再将之与子序列２的一堆合并，得分１３。显然对于第１个子序列来说，这样的合并方案是最优的。同样，我们将第２个子序列也一分为二；第４堆为子序列１，第５，６堆构成子序列２。第三次合并子序列２中的２堆，得分６；第四次再将之与子序列１中的一堆合并，得分１３。显然对于第二个子序列来说，这样的合并方案也是最优的。
      由此得出一个结论──６堆石子经
      过这样的５次合并后，得分的总和最小。我们把每一次合并划分为阶段，当前阶段中计算出的得分和作为状态，
      如何在前一次合并的基础上定义一个能使目前得分总和最大的合并方案作为一次决策。很显然，某阶段的状态给定后，则以后各阶段的决策不受这阶段以前各段状态的影响。
      这种无后效性的性质符最佳原理，因此可以用动态规划的算法求解。

      ２．动态规划的方向和初值的设定
      采用动态规划求解的关键是确定所有石子堆子序列的最佳合并方案。这些石子堆子序列包括：
      ｛第１堆、第２堆｝、｛第２堆、第３堆｝、……、｛第N堆、第１堆｝；
      ｛第１堆、第２堆、第３堆｝、｛第２堆、第３堆、第４堆｝、……、｛第N堆、第１堆、第２堆｝；……
      ｛第１堆、……、第N堆｝｛第１堆、……、第N堆、第１堆｝……｛第N堆、第１堆、……、第N－１堆｝

      为了便于运算，我们用〔i，j〕表示一个从第i堆数起，顺时针数j堆时的子序列｛第i堆、第i＋１堆、……、第（i＋j－1）mod n堆｝
      它的最佳合并方案包括两个信息：
      ①在该子序列的各堆石子合并成一堆的过程中，各次合并得分的总和；
      ②形成最佳得分和的子序列１和子序列２。由于两个子序列是相邻的，因此只需记住子序列１的堆数；
      设
      f〔i，j〕──将子序列〔i，j〕中的j堆石子合并成一堆的最佳得分和；
      c〔i，j〕──将〔i，j〕一分为二，其中子序列１的堆数；
      （１≤i≤N，１≤j≤N）
      显然，对每一堆石子来说，它的
      f〔i，１〕＝０
      c〔i，１〕＝０（１≤i≤N）
      对于子序列〔i，j〕来说，若求最小得分总和，f〔i，j〕的初始值为∞；若求最大得分总和，f〔i，j〕的初始值为０。（１≤i≤N，２≤j≤N）。
      动态规划的方向是顺推(即从上而下)。先考虑含二堆石子的N个子序列（各子序列分别从第１堆、第２堆、……、第N堆数起，顺时针数２堆）的合并方案
      f〔１，２〕，f〔２，２〕，……，f〔N，２〕
      c〔１，２〕，c〔２，２〕，……，c〔N，２〕
      然后考虑含三堆石子的Ｎ个子序列（各子序列分别从第１堆、第２堆、……、第Ｎ堆数起，顺时针数３堆）的合并方案
      f〔１，３〕，f〔２，３〕，……，f〔N，３〕
      c〔１，３〕，c〔２，３〕，……，c〔N，３〕
      ……
      依次类推，直至考虑了含N堆石子的N个子序列（各子序列分别从第１堆、第２堆、 ……、第N堆数起，顺时针数N堆）的合并方案
      f〔１，N〕，f〔２，N〕，……，f〔N，N〕
      c〔１，N〕，c〔２，N〕，……，c〔N，N〕
      最后，在子序列〔１，N〕，〔２，N〕，……，〔N，N〕中，选择得分总和（f值）最小（或最大）的一个子序列〔i，N〕（１≤i≤N），由此出发倒推合并过程。

      ３．动态规划方程和倒推合并过程
      对子序列〔i，j〕最后一次合并，其得分为第i堆数起，顺时针数j堆的石子总数t。被合并的两堆石子是由子序列〔i，k〕和〔（i＋k－１）mod
      n＋１，j－k〕（１≤k≤j－１）经有限次合并形成的。为了求出最佳合并方案中的k值，我们定义一个动态规划方程：
      当求最大得分总和时
      f〔i，j〕＝max｛f〔i，k〕＋f〔x，j-k〕＋t｝
      １≤k≤j－１
      c〔i，j〕＝k│ f〔i，j〕＝f〔i，k〕＋f〔x，j-k〕＋t
      （２≤ｊ≤ｎ，１≤ｉ≤ｎ）

      当求最小得分总和时
      f〔i，j〕＝min｛f〔i，k〕＋f〔x，j－k〕＋t｝
      １≤k≤j－１
      c〔i，j〕＝k│ f〔i，j〕＝f〔i，k〕＋f〔x，j-k〕＋t
      （２≤ｊ≤ｎ，１≤ｉ≤ｎ）
      其中x＝（i＋k－１）modn＋１，即第i堆数起，顺时针数k＋１堆的堆序号。

      例如对上面例子中的６(３４６５４２ )堆石子，按动态规划方程顺推最小得分和。依次得出含二堆石子的６个子序列的合并方案
      f〔１，２〕＝７ f〔２，２〕＝１０ f〔３，２〕＝１１
      c〔１，２〕＝１ c〔２，２〕＝１ c〔３，２〕＝１
      f〔４，２〕＝９ f〔５，２〕＝６ f〔６，２〕＝５
      c〔４，２〕＝１ c〔５，２〕＝１ c〔６，２〕＝１

      含三堆石子的６(３４６５４２ )个子序列的合并方案
      f〔１，３〕＝２０ f〔２，３〕＝２５ f〔３，３〕＝２４
      c〔１，３〕＝２ c〔２，３〕＝２ c〔３，３〕＝１
      f〔４，３〕＝１７ f〔５，３〕＝１４ f〔６，３〕＝１４
      c〔４，３〕＝１ c〔５，３〕＝１ c〔６，３〕＝２

      含四堆石子的６(３４６５４２ )个子序列的合并方案
      f〔１，４〕＝３６ f〔２，４〕＝３８ f〔３，４〕＝３４
      c〔１，４〕＝２ c〔２，４〕＝２ c〔３，４〕＝１
      f〔４，４〕＝２８ f〔５，４〕＝２６ f〔６，４〕＝２９
      c〔４，４〕＝１ c〔５，４〕＝２ c〔６，４〕＝３

      含五堆石子的６(３４６５４２ )个子序列的合并方案
      f〔１，５〕＝５１ f〔２，５〕＝４８ f〔３，５〕＝４５
      c〔１，５〕＝３ c〔２，５〕＝２ c〔３，５〕＝２
      f〔４，５〕＝４１ f〔５，５〕＝４３ f〔６，５〕＝４５
      c〔４，５〕＝２ c〔５，５〕＝３ c〔６，５〕＝３

      含六堆石子的６(３４６５４２ )个子序列的合并方案
      f〔１，６〕＝６１ f〔２，６〕＝６２ f〔３，６〕＝６１
      c〔１，６〕＝３ c〔２，６〕＝２ c〔３，６〕＝２
      f〔４，６〕＝６１ f〔５，６〕＝６１ f〔６，６〕＝６２
      c〔４，６〕＝３ c〔５，６〕＝４ c〔６，６〕＝３

      f〔１，６〕是f〔１，６〕，ｆ〔２，６〕，……f〔６，６〕中的最小值，表明最小得分和是由序列〔１，６〕经５次合并得出的。我们从这个序列出发，
      按下述方法倒推合并过程：
      由c〔１，６〕＝３可知，第５次合并的两堆石子分别由子序列〔１，３〕和子序列〔４，3〕经４次合并后得出。其中c〔１，３〕＝２可知由子序列〔１，３〕合并成的一堆石子是由子序列〔１，２〕和第三堆合并而来的。而c〔１，２〕＝１，以表明了子序列〔１，２〕的合并方案是第１堆合并第２堆。
      由此倒推回去，得出第１，第２次合并的方案，每次合并得分
      第一次合并３４６…… 　　　->７
      第二次合并７６……          ->１３
      １３……
      子序列〔１，３〕经２次合并后合并成１堆，２次合并的得分和＝７＋１３＝２０。
      ｃ〔４，３〕＝１，可知由子序列〔４，３〕合并成的一堆石子是由第４堆和子序列〔５，
      ２〕合并而来的。而c〔５，２〕＝１，又表明了子序列〔５，２〕的合并方案是第５堆合并第６堆。由此倒推回去，得出第３、第４次合并的方案
      每次合并得分：
       第三次合并 ……５４２     ->６
      第四次合并 ……５６        ->１１
      ……１１
      子序列〔４，３〕经２次合并后合并成１堆，２次合并的得分和＝６＋１１＝１７。
      第五次合并是将最后两堆合并成１堆，该次合并的得分为２４。
      显然，上述５次合并的得分总和为最小
      ２０＋１７＋２４＝６１

      上述倒推过程，可由一个print（〔子序列〕）的递归算法描述
      procedure print （〔i，ｊ〕）
      begin
      if ｊ〈〉１ then ｛继续倒推合并过程
      begin
      print（〔i，c〔i，j〕〕；｛倒推子序列１的合并过程｝
      print（〔i＋c〔i，j〕－１〕mod n＋１，j－c〔i，j〕）
      ｛倒推子序列２的合并过程｝
      for K：＝１ to N do｛输出当前被合并的两堆石子｝
      if （第K堆石子未从圈内去除）
      then begin
      if（K＝i）or（K＝X）then置第K堆石子待合并标志
      else第K堆石子未被合并；
      end；｛then｝
      第i堆石子数←第i堆石子数＋第X堆石子数；
      将第X堆石子从圈内去除；
      end；｛then｝
      end；｛print｝
      例如，调用print（〔１，６〕）后的结果如下：
                           print（〔１，６〕）⑤
                                ┌──────┴──────┐
                     print（〔１，３〕）②               print（〔４，３〕）④
                ┌─────┴─────┐               ┌─────┴─────┐
          print(〔１，２〕)① print(〔3，1〕)     print(〔4，1〕) print(〔５，２〕)③
       ┌──────┴──────┐                         ┌──────┴──────┐
      print（〔1,1〕）        print（〔2,1〕）               print（〔5,1〕）
      print（〔6,1〕）
      （图6.2-5）
      其中回溯至
      ① 显示３４６５４
      ② 显示７６５４２
      ③ 显示１３５４２
      ④ 显示１３５６
      ⑤ 显示１３１１
      注:调用print过程后，应显示６堆石子的总数作为第５次合并的得分。

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

      Procedure Print(i, j : Byte);{递归打印子序列[i,j]的合并过程}
      Var
      k, x : Shortint;{k-循环变量;x-子序列2中首堆石子的序号}
      Begin
      If j <> 1 Then Begin{继续倒推合并过程}
        Print(i, List[i,j].d);{倒推子序列1的合并过程}
        x := (i + List[i, j].d - 1) Mod N + 1;{求子序列2中首堆石子的序号}
        Print(x, j - List[i, j].d);{倒推子序列2的合并过程}
        For k := 1 to N Do{输出当前合并第i堆,第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);{输出换行符}
        Date[i] := Date[i] + Date[x];{原第i堆和第x堆合并成第ｉ堆}
        Date[x] := - Date[x]{将原第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{仅含一堆石子的序列不存在合并}
          List[i, 1].c := 0;
          List[i, 1].d := 0
        End; {For}
        For j := 2 to N Do{顺推含2堆,含3堆……含N堆石子的各子序列的合并方案}
          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];{最后一次合并的得分为[i,j]子序列的石子总数}
            For k := 1 to j - 1 Do Begin{子序列1的石子堆数依次考虑1堆……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]中选择得分总和最小(或最大)的一个子序列}
        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);{由此出发,倒推合并过程}
        Writeln(F, Sum^[1, N]);{输出最后一次将石子合并成一堆的石子总数}
        Writeln(F);
        Writeln(list[k, N].c)
      End; { Main }

      Begin
        Write('File name = ');{输入文件名串}
        Readln(Fn);
        Assign(F, Fn);{该文件名串与文件变量连接}
        Reset(F);{文件读准备}
        Readln(F, N);{读入石子堆数}
        For i := 1 to N Do Read(F, Date[i]);{读入每堆石子数}
        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;{暂存合并前的各堆石子,结构相同的变量可相互赋值}
        Close(F);{关闭输入文件}
        Assign(F, 'OUTPUT.TXT');{文件变量与输出文件名串连接}
        Rewrite(F);{文件写准备}
        Main(1);{求得分和最小的合并方案}
        Date := Dt;{恢复合并前的各堆石子}
        Main(2);{求得分和最大的合并方案}
        Close(F){关闭输出文件}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lyflower/archive/2008/03/05/2150251.aspx

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

C++博客-I believe-随笔分类-转载

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

基于Socket的UDP和TCP编程介绍

[转载]Vector遍历

java Vector排序及用法

[转载]使用 Java 编程语言实现线程

joj 1092 To the Max 转帖Dp经典

字符串哈希

哈希表 poj 3320 Jessica's Reading Problem

石子合并问题

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