二 实验拓扑

三 实验描述：使用MPLS解决BGP路由黑洞问题

R1、R2、R3、R4、R5、R6运行OSPF，宣告Loopback0，使用全网Loopback0互通
R5与R1建立eBGP邻居，R5宣告55.5.5.0/24网段；R6与R4建立eBGP邻居，R6宣告66.6.6.0/24地址
R1与R4建立iBGP邻居，互相学习到R5、R6的路由

路由黑洞问题：由于R2和R3没有运行BGP，没有学习到55.5.5.0/24和66.6.6.0/24的路由，导致数据包不可达。

解决办法：R1、R2、R3、R4运行MPLS协议，使得数据包到达R1时，由于MPLS根据BGP路由下一跳做标签转发，将数据包传给R2，R2、R3也将根据这个下一跳的标签信息进行数据转发，当数据包到达R4再根据CEF表进行转发，从而使用数据包可达

四 实验步骤

1、R1、R2、R3、R4、R5、R6接口和OSPF基本配置

R1基本配置：

interface Loopback0
 ip address 1.1.1.1 255.255.255.255
!

这里需要使用32位全1的地址掩码，这样保证与邻居学习到的32位路由一致。如果R1 Loopback口地址是 1.1.1.1/24，由于OSPF协议对于Loopback口比较特殊，使得R2学习到的是32位的主机路由。这样两个路由的路由信息不一致，而MPLS是根据路由前缀进行分发标签，如果路由不一致则标签无法正确分发。

interface FastEthernet0/0
ip address 12.1.1.1 255.255.255.0
!
interface FastEthernet1/0
ip address 15.1.1.1 255.255.255.0
!
router ospf 110
router-id 1.1.1.1
network 1.1.1.1 0.0.0.0 area 0
network 12.1.1.0 0.0.0.255 area 0
network 15.1.1.0 0.0.0.255 area 0
!

R2基本配置：

interface Loopback0
ip address 2.2.2.2 255.255.255.255
!
interface FastEthernet0/0
ip address 12.1.1.2 255.255.255.0
!
interface FastEthernet1/0
ip address 23.1.1.2 255.255.255.0
!
router ospf 110
router-id 2.2.2.2
network 2.2.2.2 0.0.0.0 area 0
network 12.1.1.0 0.0.0.255 area 0
network 23.1.1.0 0.0.0.255 area 0
!

R3基本配置：

interface Loopback0
ip address 3.3.3.3 255.255.255.255
!
interface FastEthernet0/0
ip address 34.1.1.3 255.255.255.0
!
interface FastEthernet1/0
ip address 23.1.1.3 255.255.255.0
!
router ospf 110
router-id 3.3.3.3
network 3.3.3.0 0.0.0.255 area 0
network 23.1.1.0 0.0.0.255 area 0
network 34.1.1.0 0.0.0.255 area 0
!

R4基本配置：

interface Loopback0
ip address 4.4.4.4 255.255.255.255
!
interface FastEthernet0/0
ip address 34.1.1.4 255.255.255.0
!
interface FastEthernet1/0
ip address 46.1.1.4 255.255.255.0
!
router ospf 11
router-id 4.4.4.4
network 4.4.4.0 0.0.0.255 area 0
network 34.1.1.0 0.0.0.255 area 0
network 46.1.1.0 0.0.0.255 area 0
!

R5基本配置：

interface Loopback0
ip address 5.5.5.5 255.255.255.255
!
interface Loopback55
ip address 55.5.5.5 255.255.255.0
!
interface FastEthernet1/0
ip address 15.1.1.5 255.255.255.0
!
router ospf 110
router-id 5.5.5.5
network 5.5.5.5 0.0.0.0 area 0
network 15.1.1.0 0.0.0.255 area 0
!

R6基本配置：

interface Loopback0
ip address 6.6.6.6 255.255.255.255
!
interface Loopback66
ip address 66.6.6.6 255.255.255.0
!
interface FastEthernet1/0
ip address 46.1.1.6 255.255.255.0
!
router ospf 110
router-id 6.6.6.6
network 6.6.6.6 0.0.0.0 area 0
network 46.1.1.0 0.0.0.255 area 0
!

2、验证所有路由Loopback 0能互通，且能正常学习到路由

R5#ping 6.6.6.6
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 6.6.6.6, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 104/121/152 ms

3、R5、R1、R4、R6根据拓扑跑BGP协议

R5 BGP配置：

router bgp 5
bgp router-id 5.5.5.5
bgp log-neighbor-changes
 network 55.5.5.0 mask 255.255.255.0
neighbor 1.1.1.1 remote-as 1
neighbor 1.1.1.1 ebgp-multihop 255
neighbor 1.1.1.1 update-source Loopback0

R1 BGP配置：

router bgp 1
bgp router-id 1.1.1.1
bgp log-neighbor-changes
neighbor 4.4.4.4 remote-as 1
neighbor 4.4.4.4 update-source Loopback0
neighbor 4.4.4.4 next-hop-self
neighbor 5.5.5.5 remote-as 5
neighbor 5.5.5.5 ebgp-multihop 255
neighbor 5.5.5.5 update-source Loopback0

R4 BGP配置：

router bgp 1
bgp router-id 4.4.4.4
bgp log-neighbor-changes
neighbor 1.1.1.1 remote-as 1
neighbor 1.1.1.1 update-source Loopback0
neighbor 1.1.1.1 next-hop-self
neighbor 6.6.6.6 remote-as 6
neighbor 6.6.6.6 ebgp-multihop 255
neighbor 6.6.6.6 update-source Loopback0

R6 BGP配置：

router bgp 6
bgp router-id 6.6.6.6
bgp log-neighbor-changes
 network 66.6.6.0 mask 255.255.255.0
neighbor 4.4.4.4 remote-as 1
neighbor 4.4.4.4 ebgp-multihop 255
neighbor 4.4.4.4 update-source Loopback0

4、验证BGP路由正确学习，R5上能学习到66.6.6.0/24

5、R1-f0/0，R2-f0/0、f1/0，R3-f0/0、f1/0，R4-f0/0运行MPLS

在此之前保证路由已经启用ip cef
配置以一个接口为例
R1(config)#ip cef
R1(config)#int f0/0
R1(config-if)#mpls ip

注:如果MPLS不能起邻居，那么强制指定router-id

R1(config)#mpls ldp router-id lo 0 force

6、验证数据包是否正确到达

R5#traceroute 66.6.6.6
Type escape sequence to abort.
Tracing the route to 66.6.6.6
VRF info: (vrf in name/id, vrf out name/id)
  1 15.1.1.1 28 msec 56 msec 16 msec
  2 12.1.1.2 [MPLS: Label 18 Exp 0] 112 msec 104 msec 140 msec
  3 23.1.1.3 [MPLS: Label 18 Exp 0] 80 msec 60 msec 96 msec
  4 34.1.1.4 104 msec 112 msec 108 msec
  5 46.1.1.6 108 msec *  100 msec

注：数据包的转发查找过程：

A R5根据路由将数据包传给R1，由于R1启用MPLS，MPLS根据BGP下一跳4.4.4.4 进行标签转发，如下信息所示，转发到R2
R1#sh ip bgp
Network          Next Hop            Metric LocPrf Weight Path
*> 55.5.5.0/24      5.5.5.5                  0             0 5 i
*>i66.6.6.0/24      4.4.4.4                  0    100      0 6 i

R1#sh ip cef de
4.4.4.4/32, epoch 0, flags need ps clean
local label info: global/18
1 RR source [no flags]
nexthop 12.1.1.2 FastEthernet0/0 label 18

R1#sh mpls forwarding-table
18         18         4.4.4.4/32       0             Fa0/0      12.1.1.2

B R2同样进行标签转发，转发到R3
R2#sh mpls forwarding-table
18         18         4.4.4.4/32       22267         Fa1/0      23.1.1.3

C R3同样进行标签转发，由于是倒数第二跳，弹出标签后再转发给R4
R3#sh mpls forwarding-table
18         Pop Label  4.4.4.4/32       25919         Fa0/0      34.1.1.4

D R4是最后一跳，从而进行路由查找，R4学习到66.6.6.0/24，将数据包传给R6，从而完成整个数据包传递过程

R4#sh ip cef de
66.6.6.0/24, epoch 0, flags rib only nolabel, rib defined all labels
recursive via 6.6.6.6
nexthop 46.1.1.6 FastEthernet1/0

基本大家都会去的地方---天安门，去西单的时候顺便拍了张

.的

王府井，一个逛街的地方。图是小吃街，人超多，广州北京路小吃街和它比起来还是逊色了点

孔子庙，难得天气不错

某广播电视台建筑楼

原来Google中国在中关村，不知道还有人在办公不

部门活动，凤凰岭，天气很阴沉，回家的路上都下雨

玉渊潭，清明节去的，人好多

二 实验拓扑

三 实验描述

使用R2、R3路由器模拟帧中继网络，R1、R4、R5跑OPSF实现全网互通

在帧中继网络中，路由器上跑OSPF实现网络互通可分为以下情况进行讨论：
A  R1、R4、R5通过inverse-arp获得frame-relay map信息，处于同一网段，二层网络类型为广播，三层网络类型默认为NBMA。此网络类型需要在一台路由器手工指邻居才能正常学习到路由条目但是路由器承担的角色不统一，故还需手工指定该路由器为DR。或者修改此网络类型为broadcast。
B  R1、R4、R5处于同一网段，R4二层网络类型通过子接口配置为点到多点，三层网络类型默认为点到多点。注：由于使用子接口R1、R4、R5需要手工配置frame-relay map
C  R4与R1、R4与R5处于同一网段，R4二层网络类型通过子接口配置为点到点，三层网络类型为点到点。注：由于使用子接口R1、R4、R5需要手工配置frame-relay map

下面将根据以上讨论的三种情况分别进行配置

四 实验步骤

1、模拟帧中继

R2上帧中继配置
R2和R3隧道技术以扩展端口数量
interface Tunnel0
no ip address
tunnel source 23.0.0.2
tunnel destination 23.0.0.3

interface Serial0/0
no ip address
encapsulation frame-relay
clock rate 64000
对端lmi-type需匹配
frame-relay lmi-type cisco
frame-relay intf-type dce
S0/0入方向有DLCI号为401，出口为S0/1；
frame-relay route 401 interface Serial0/1 104
S0/0入方向有DLCI号为405，出口为Tunnel0，101为唯一标识隧道的号码
frame-relay route 405 interface Tunnel0 101
！
interface Serial0/1
no ip address
encapsulation frame-relay
clock rate 64000
frame-relay lmi-type cisco
frame-relay intf-type dce
frame-relay route 104 interface Serial0/0 401
frame-relay route 105 interface Tunnel0 200
!
interface FastEthernet1/0
ip address 23.0.0.2 255.255.255.0

R3上帧中继配置
interface Tunnel0
no ip address
tunnel source 23.0.0.3
tunnel destination 23.0.0.2
!
interface Serial0/0
no ip address
encapsulation frame-relay
clock rate 64000
frame-relay lmi-type cisco
frame-relay intf-type dce
frame-relay route 501 interface Tunnel0 200
frame-relay route 504 interface Tunnel0 101
!
interface FastEthernet1/0
ip address 23.0.0.3 255.255.255.0
!

2、R1、R4、R5基本配置
R1基本配置
interface Loopback0
ip address 1.1.1.1 255.255.255.0
!
interface Serial0/0
ip address 10.0.0.1 255.255.255.0
encapsulation frame-relay
serial restart-delay 0
frame-relay lmi-type cisco
!
router ospf 110
router-id 1.1.1.1
log-adjacency-changes
network 1.1.1.1 0.0.0.0 area 0
network 10.0.0.0 0.0.0.255 area 0

R4基本配置
interface Loopback1
ip address 4.4.4.4 255.255.255.0
!
interface Serial0/0
ip address 10.0.0.4 255.255.255.0
encapsulation frame-relay
serial restart-delay 0
frame-relay lmi-type cisco
!
router ospf 110
router-id 4.4.4.4
log-adjacency-changes
network 4.4.4.4 0.0.0.0 area 0
network 10.0.0.0 0.0.0.255 area 0

R5基本配置
interface Loopback0
ip address 5.5.5.5 255.255.255.0
!
interface Serial0/0
ip address 10.0.0.5 255.255.255.0
encapsulation frame-relay
serial restart-delay 0
frame-relay lmi-type cisco
!
router ospf 110
router-id 5.5.5.5
log-adjacency-changes
network 5.5.5.5 0.0.0.0 area 0
network 10.0.0.0 0.0.0.255 area 0
!

3、根据讨论情况A，R4上指定OSPF邻居，且指定为DR

R1和R5接口优先级为0，不参加OSPF角色选举
R1(config)#int s0/0
R1(config-if)#ip os priority 0

R5(config)#int s0/0
R5(config-if)#ip os priority 0

只需在R4上手工指定R1、R5为邻居
R4(config)#router os 110
R4(config-router)#neighbor 10.0.0.1
R4(config-router)#neighbor 10.0.0.5

4、 根据讨论情况B，R4配置点到多点子接口

R4(config)#default int s0/0
R4(config)#int s0/0
R4(config-if)# no ip address
R4(config-if)# encapsulation frame-relay
R4(config-if)#frame-relay lmi-type cisco
需要手工指定frame-relay map
R4(config-if)#no frame-relay inverse-arp
配置点到多点子接口
R4(config)#int s0/0.10 multipoint
R4(config-subif)#ip address 10.0.0.4 255.255.255.0
子接口也配上
R4(config-subif)#no frame-relay inverse-arp

手工指定frame-relay map
R4(config-subif)#frame-relay map ip 10.0.0.1 401 broadcast
R4(config-subif)#frame-relay map ip 10.0.0.5 405 broadcast

R1(config-if)#frame-relay map ip 10.0.0.4 104 broadcast
R1(config-if)#frame-relay map ip 10.0.0.5 105 broadcast

R5(config-if)#frame-relay map ip 10.0.0.1 501 broadcast
R5(config-if)#frame-relay map ip 10.0.0.4 504 broadcast

修改接口网络类型
R1(config)#int s0/0
R1(config-if)#ip os network point-to-multipoint

R5(config)#int s0/0
R5(config-if)#ip os network point-to-multipoint
注：如果R1到R5的frame-relay map没有配置，那么R1不能与R5互通

5、根据讨论情况C，R4配置点到点子接口

注：R4的S0/0口和R1、R4、R5手工指定frame-relay map同4中配置

R4与R1处于同一网段，100.0.0.0/24
R4(config)#int s0/0.100 point-to-point
R4(config-subif)#ip address 100.0.0.4 255.255.255.0
R4(config-subif)#frame-relay interface-dlci 401

R4与R5处于同一网段，101.0.0.0/24
R4(config)#int s0/0.101 point-to-point
R4(config-subif)#ip address 101.0.0.4 255.255.255.0
R4(config-subif)#frame-relay interface-dlci 405

R1和R5修改接口IP地址
R1(config)#int s0/0
R1(config-if)# ip address 100.0.0.1 255.255.255.0

R5(config)#int s0/0
R5(config-if)# ip address 101.0.0.5 255.255.255.0

修改OSPF宣告的网络地址
R4(config)#router os 110
R4(config-router)#no network 10.0.0.0 0.0.0.255 area 0
R4(config-router)#network 100.0.0.0 0.0.0.255 area 0
R4(config-router)#network 101.0.0.0 0.0.0.255 area 0

R1(config)#router os 110
R1(config-router)#no network 10.0.0.0 0.0.0.255 area 0
R1(config-router)#network 100.0.0.0 0.0.0.255 area 0

R5(config)#router os 110
R5(config-router)#no network 10.0.0.0 0.0.0.255 area 0
R5(config-router)#network 101.0.0.0 0.0.0.255 area 0

修改接口网络类型
R1(config)#int s0/0
R1(config-if)#ip os network point-to-point

R5(config)#int s0/0
R5(config-if)#ip os network point-to-point

笔试：

8号晚上去了大学城，在一个同学宿舍那借宿，第二天早上同学带我去笔试地点---中山大学。10点开始发试卷，浏览了下试题，居然都是编程和算法，一道网络题都没有。我以为发错试卷了，再仔细一看，试卷上标明了系统工程师，好吧，只能硬着头皮做了，还好我大一大二基础课还学得可以。印象里笔试题有简答和编程。简答题：两道程序问题分析；知道有哪些RAID，至少写三个；一些看不懂的磁盘算法问题；一道shell编程。编程题：求最长不减子序列的长度；一个数组模拟三个栈；二叉树中两个叶子节点之间的距离；在一个序列中1-N，N<M，求在这个序列中两次相加等于M的数对，要求算法优化。

PS：学科基础课还是要认真学的，特别是算法和编程。

会答的都答了，然后交卷。本来打算下午回校，但是由于周末时间高校联谊的票都被订完了，只能第二天再走了。晚上约了几个高中同学去广州看灯展，回到宿舍10点多。准备洗刷的时候电话响了，拿起电话，“请问你是廖华琼吗？我是百度人力资源XX，明天下午6点能不能到XXX酒店进行面试，......”。这居然是通知面试的，当时都11点半了，百度工作人员真是辛苦了。话说我RP还是很好的，下午没能订到回校的票不然我第二天还得跑趟=_=

一面：

第二天下午5点顺利找到面试地点，面试5点半开始。一对一面试，面试官让我做下自我介绍，问我什么时候对网络有所了解，接着进入技术环节，首先是TCP三次握手；从三次握手引申出了---如果没有收到客户端的ACK，服务器会怎么样；两个mac地址不同网段如何通信；接着面试官问我对Linux掌握得怎么样，我马上如实回答---略懂皮毛。不过还是问了挺多关于Linux的，比如，linux文件系统有什么；etx2和etx3的区别；查看内存使用情况；查看硬件信息；/PROC文件的特殊之处。最后一面以一道编程题结束，找子串。最后了解了下我的发展方向，考研还是直接工作。估计面试官主要是学Linux的，让人感觉蛮和蔼的，一开始还有点紧张，聊着聊着也放松下来了。

PS：这是我的处女面撒，哈哈，给了百度也无憾了。

二面：

12号接到电话面试通知，让我明天下午2点保证电话通畅。这次是电面，面试官是系统部的，问了一堆路由、交换知识和网络协议。依旧以TCP三次握手作为开场白；OSPF知识：建立过程，DR选举，Router-id选举；对BGP的一些理解；BGP属性；STP工作过程；DNS、邮件端口号；DNS使用的协议；linux网络配置命令。面试官对我的回答一直表示很满意，问我是不是清楚我的工作地点是在北京（广东的同学基本上工作岗位都选择百度分公司-深圳）。最后我了解了下系统部目前大概情况，面试官让我等通知。自我感觉应该能通过。

三面：

17号才接到三面通知，这几天上个洗手间都不敢忘了带手机哇。面试时间是19号下午两点，但面试官临时出差了，时间改到了20号。这一次依旧是电话面试，面试官应该是系统部的Boss，让我先进行了自我介绍，并让我简单说下项目的主要内容和职责，以及项目的设计思路。依旧以TCP三次握手进入话题，问TCP协议可能存在的攻击；接下来还是路由知识：OSPF工作过程；BGP自同步问题；路由黑洞解决方法；looback 口作用；router-id 的作用；enable secure 与enable password的区别。最后面试官提醒我这个职位是需要7*24小时服务，有点累，问我是否能接收。这个问题给了我一剂定心丸---拿Offer的概率应该很高吧。

拿Offer：

经过5天地漫长地等待，北京HR终于通知我拿到口头Offer了，并简单说了下待遇....告诉我11月中旬会有HR到广州收三方协议。光棍节那天HR通知我18号到广州暨大交三方。交三方那天岐关车居然迟到40分钟，还好能在约定时间前赶到，顺利交了三方也拿了纸质版Offer，然后跟一起签约的同学们在暨大附近餐厅聚餐。话说去的七个女生里就我一个是做技术了...

百度求职算是划上圆满的句号，毕业论文也已经完成了，打算2月份去百度实习。从没去去北方的我，不知道能不能很快适应那边的天气；第一次去企业实习的我，不知道能不能很快进入工作状态。一切都是未知数，争取做到最好，加油撒！

二 实验拓扑

三 实验描述：

根据拓扑中区域的划分配置OSPF。OSPF的骨干区域在R1的loopback上。配置帧中继，R1与R2在Area 100，网络类型为点到点。R1与R3在Area 300，网络类型为NBMA，且Area 300 为NSSA类型。R2上的loopback在Area 200，且对路由进行汇总。将R3上的loopback口重分布进OSPF中。为了使全网都通，需要在Area 300上创建虚链路。

四 实验步骤：

1 R3上帧中继配置

//1 启动帧中继交换
frame-relay switching
！
//2 进入接口
interface Serial0/0
//3 删除IP地址
no ip address
//4 配置帧中继封装类型
encapsulation frame-relay IETF
//下面两条命令可不加
no ip route-cache cef
no ip route-cache
serial restart-delay 0
//5 配置时钟
clock rate 64000
//6 配置为DCE终端类型
frame-relay intf-type dce
//7 配置帧中继路由
frame-relay route 102 interface Serial0/1 201
frame-relay route 103 interface Serial0/2 301
//8 别忘了要启用接口，这里是不用显示no shutdown命令的
!
interface Serial0/1
no ip address
encapsulation frame-relay IETF
serial restart-delay 0
frame-relay intf-type dce
frame-relay route 201 interface Serial0/0 102
!
interface Serial0/2
no ip address
encapsulation frame-relay IETF
serial restart-delay 0
clock rate 64000
frame-relay intf-type dce
frame-relay route 301 interface Serial0/0 103
!

2  R1基本配置

interface Loopback1
ip address 10.1.1.9 255.255.255.252
ip ospf network point-to-point
!
interface Serial0/1
no ip address
encapsulation frame-relay IETF
serial restart-delay 0
!
interface Serial0/1.102 point-to-point
ip address 10.1.1.1 255.255.255.252
frame-relay interface-dlci 102
!
interface Serial0/1.103 point-to-point
ip address 10.1.1.5 255.255.255.252
frame-relay interface-dlci 103
!

3 R2 基本配置

interface Loopback101
ip address 10.1.1.101 255.255.255.252
ip ospf network point-to-point
!
interface Loopback105
ip address 10.1.1.105 255.255.255.252
ip ospf network point-to-point
!
interface Loopback109
ip address 10.1.1.109 255.255.255.252
ip ospf network point-to-point
!
interface Loopback113
ip address 10.1.1.113 255.255.255.252
ip ospf network point-to-point
!
interface Serial0/1
ip address 10.1.1.2 255.255.255.252
encapsulation frame-relay IETF
serial restart-delay 0
frame-relay interface-dlci 201
!

4 R4基本配置

interface Loopback3
ip address 10.1.1.13 255.255.255.252
!
interface Serial0/1
ip address 10.1.1.6 255.255.255.252
encapsulation frame-relay IETF
serial restart-delay 0
frame-relay interface-dlci 301
!

5 配置Area 0区域

R1(config)#router ospf 1
R1(config-router)#router-id 1.1.1.1
R1(config-router)network 10.1.1.8 0.0.0.3 area 0

6 配置Area100区域，网络类型为点到点

修改Serial0/1.102的接口类型
R1(config)#interface Serial0/1.102 point-to-point
R1(config-subif)ip ospf network point-to-point
注：如果不确定接口类型，可以使用sh ip os int s0/1.102命令进行查看

R1(config)#router ospf 1
R1(config-router)network 10.1.1.0 0.0.0.3 area 100

R2(config)router ospf 1
R2(config-router)router-id 2.2.2.2
R2(config-router)network 10.1.1.0 0.0.0.3 area 100
因为R2上s0/1的接口类型默认为点到点，所以无需修改

7 配置Area300区域，网络类型为NBMA，且为NSSA类型

修改Serial0/1.103的接口类型
R1(config)#interface Serial0/1.103 point-to-point
R1(config-subif)ip ospf network non-broadcast

R1(config)#router ospf 1
R1(config-router)network 10.1.1.4 0.0.0.3 area 300
R1(config-router)area 300 nssa
//在NBMA网络中需手工指点neighbor
R1(config-router)neighbor 10.1.1.6

R4(config)router ospf 1
R4(config-router)router-id 4.4.4.4
R4(config-router)network 10.1.1.4 0.0.0.3 area 300
R4(config-router)area 300 nssa

8 配置Area 200区域，且进行路由汇总

R2(config-router)network 10.1.1.96 0.0.0.31 area 200
R2(config-router)area 200 range 10.1.1.96 255.255.255.224

R1-R2配置为虚链路，实现全网互通
R1(config-router)area 100 virtual-link 2.2.2.2
R2(config-router) area 100 virtual-link 1.1.1.1

9 将R4回环口的路由重分布进OSPF中
R4(config-router)redistribute connected subnets

10 最后查看R1路由条目

R1# show ip route

10.0.0.0/8 is variably subnetted, 5 subnets, 2 masks
C       10.1.1.8/30 is directly connected, Loopback1
O N2    10.1.1.12/30 [110/20] via 10.1.1.6, 00:00:27, Serial0/1.103
C       10.1.1.0/30 is directly connected, Serial0/1.102
C       10.1.1.4/30 is directly connected, Serial0/1.103
O IA    10.1.1.96/27 [110/65] via 10.1.1.2, 00:00:27, Serial0/1.102

二、实验描述

R1和R2都运行RIPv2，让双方都拥有全网拓扑。关闭RIPv2自动汇总功能。为了减少R2上的路由条目，在R1上使用 ip summary-address rip命令进行手工汇总，但是RIPv2中手工汇总所宣告的子网掩码长度只能大于等于主类路由的子网掩码长度。

这样，使用 ip summary-address rip命令肯定是行不通。怎么办呢?下面我将提供另一种方法进行RIPV2的汇总。

三、实验步骤

1 R1基本配置

interface Loopback0
ip address 172.16.1.1 255.255.255.0
!
interface Loopback48
ip address 192.168.48.1 255.255.255.0
!
interface Loopback49
ip address 192.168.49.1 255.255.255.0
!
interface Loopback50
ip address 192.168.50.1 255.255.255.0
!
interface Loopback51
ip address 192.168.51.1 255.255.255.0
!
interface Serial0/0
bandwidth 64
ip address 172.16.12.1 255.255.255.0
serial restart-delay 0
clock rate 64000
!
router rip
version 2
//只让s0/0接口发送更新，减少路由器资源
passive-interface default
no passive-interface Serial0/0
network 172.16.0.0
network 192.168.48.0
network 192.168.49.0
network 192.168.50.0
network 192.168.51.0
no auto-summary
!

2 R2基本配置

interface Loopback0
ip address 172.16.2.1 255.255.255.0
!
interface Serial0/0
bandwidth 64
ip address 172.16.12.2 255.255.255.0
serial restart-delay 0
!
router rip
version 2
passive-interface Loopback0
network 172.16.0.0
no auto-summary
!

3 查看R2路由器条目

R2# show ip route rip
172.16.0.0/24 is subnetted, 4 subnets
R       172.16.1.0 [120/1] via 172.16.12.1, 00:00:29, Serial0/0
R    192.168.51.0/24 [120/1] via 172.16.12.1, 00:00:29, Serial0/0
R    192.168.50.0/24 [120/1] via 172.16.12.1, 00:00:29, Serial0/0
R    192.168.49.0/24 [120/1] via 172.16.12.1, 00:00:29, Serial0/0
R    192.168.48.0/24 [120/1] via 172.16.12.1, 00:00:29, Serial0/0

4 在R1上做路由汇总

R1(config)# interface serial 0/0
R1(config-if)# ip summary-address rip 192.168.48.0 255.255.252.0
Summary mask must be greater or equal to major net

将连续的C类路由在R1的s0/0使用ip summary address rip命令进行路由汇总时，你会发现路由器只允许汇总的子网掩码长度大于等于主类网络。
注：其它路由协议汇总并没有此限制

5 R1上进行静态路由重分布

想一下，EIGRP中汇总路由条目在汇总路由器上的下一跳接口可以指向Null0，那么我们是不是也可以在R1上创建这样一条汇总路由让它下一跳指向Null0，并进行路由重分布呢。

R1(config)# ip route 192.168.48.0 255.255.252.0 null0
R1(config)# router rip
R1(config-router)# redistribute static

6 查看R1和R2路由条目

R1# show ip route

Gateway of last resort is not set

172.16.0.0/24 is subnetted, 4 subnets
C       172.16.12.0 is directly connected, Serial0/0
C       172.16.1.0 is directly connected, Loopback0
R       172.16.2.0 [120/1] via 172.16.12.2, 00:00:27, Serial0/0
C    192.168.51.0/24 is directly connected, Loopback51
C    192.168.50.0/24 is directly connected, Loopback50
C    192.168.49.0/24 is directly connected, Loopback49
C    192.168.48.0/24 is directly connected, Loopback48
S    192.168.48.0/22 is directly connected, Null0

R2# show ip route

Gateway of last resort is not set

172.16.0.0/24 is subnetted, 4 subnets
C       172.16.12.0 is directly connected, Serial0/0
R       172.16.1.0 [120/1] via 172.16.12.1, 00:00:05, Serial0/0
C       172.16.2.0 is directly connected, Loopback0
R    192.168.51.0/24 [120/1] via 172.16.12.1, 00:00:05, Serial0/0
R    192.168.50.0/24 [120/1] via 172.16.12.1, 00:00:05, Serial0/0
R    192.168.49.0/24 [120/1] via 172.16.12.1, 00:00:05, Serial0/0
R    192.168.48.0/24 [120/1] via 172.16.12.1, 00:00:07, Serial0/0
R    192.168.48.0/22 [120/1] via 172.16.12.1, 00:00:07, Serial0/0

可以看到R1和R2都出现汇总路由，但显然4条连续C类路由还是出现在R2上
注：RIP或EIGRP这样的距离矢量路由，要求全网路由表是要同步的。

7 使用prefix list过滤路由条目

为了减少R2路由条目，只能进行路由过滤，这里使用prefix lists过滤路由条目。在R1上使用 prefix list作为分发列表来过滤loopback口上48到51的路由，并允许其他的路由包括总结路由

R1(config)# ip prefix-list RIP-OUT permit 192.168.48.0/22
R1(config)# ip prefix-list RIP-OUT deny 192.168.48.0/22 le 24
R1(config)# ip prefix-list RIP-OUT permit 0.0.0.0/0 le 32

第一条的prefix list允许总结路由，因为它使用22位的子网掩码严格匹配192.168.48.0网络

第二条的prefix list禁止子网掩码长度在22到24的192.168.48.0/22的网络块。这条也会匹配22位的总结路由。

第三条允许其它所有的路由

8 将过滤列表应用在R1的出口方向上

R1(config)# router rip
R1(config-router)# distribute-list prefix RIP-OUT out serial0/0

9 清除路由条目

R2#clear ip route *

R2# show ip route rip
172.16.0.0/24 is subnetted, 4 subnets
R       172.16.1.0 [120/1] via 172.16.12.1, 00:00:12, Serial0/0
R    192.168.48.0/22 [120/1] via 172.16.12.1, 00:00:12, Serial0/0

2、实验环境：C3640-IK9O3S-M Version 12.4(10)

3、实验拓扑

4、实验描述

四个路由器运行BGP，R1与R2、R4与R3为IBGP关系，R1与R4、R2与R3为EBGP关系。四个路由器分别使用环回口建立子网，且让对方互相学习到路由信息，实现全拓扑互通。

按照正常配置，会发现R3到达R1的1.1.1.1/24网段有两种路径，第一种，R3->R4->R1，第二种，R3->R2->R1。根据BGP选路的11个原则（这里就不一一列出来了，需要的话到思科官方网站上查阅），匹配第7条---Prefer EBGP over IBGP paths，故R3会选择第二种路径，经过R2。

但是R3到达1.1.1.1/24网段使用R2作为下一跳并不是最佳路径选择，因为R3与R2是串行链路，而R1与R4是以太网线路，很明显我们应该选择带宽较大的R4作为下一跳。为了让R3选择R4作为下一跳，我们可以分别修改BGP attribute中的weigtht、local preference、AS-path以及MED值来达到目的。

5、实验步骤

A、R1基本配置

interface Loopback0
ip address 1.1.1.1 255.255.255.0
!
interface Serial0/0
ip address 12.0.0.1 255.255.255.0
!
interface FastEthernet1/0
ip address 14.0.0.1 255.255.255.0
!
router rip
version 2
network 1.0.0.0
network 12.0.0.0
!
router bgp 12
no synchronization
bgp router-id 1.1.1.1
bgp log-neighbor-changes
network 1.1.1.0 mask 255.255.255.0
neighbor 2.2.2.2 remote-as 12
neighbor 2.2.2.2 update-source Loopback0
neighbor 2.2.2.2 next-hop-self
neighbor 14.0.0.4 remote-as 34
no auto-summary

B、R2基本配置

interface Loopback0
ip address 2.2.2.2 255.255.255.0
!
interface Serial0/0
ip address 12.0.0.2 255.255.255.0
!
interface Serial0/1
ip address 23.0.0.2 255.255.255.0
!
router rip
version 2
network 2.0.0.0
network 12.0.0.0
no auto-summary
!
router bgp 12
no synchronization
bgp router-id 2.2.2.2
bgp log-neighbor-changes
network 2.2.2.0 mask 255.255.255.0
neighbor 1.1.1.1 remote-as 12
neighbor 1.1.1.1 update-source Loopback0
neighbor 1.1.1.1 next-hop-self
neighbor 23.0.0.3 remote-as 34
no auto-summary

C、R3基本配置

interface Loopback0
ip address 3.3.3.3 255.255.255.0
!
interface Serial0/0
ip address 34.0.0.3 255.255.255.0
!
interface Serial0/1
ip address 23.0.0.3 255.255.255.0
!
router rip
version 2
network 3.0.0.0
network 34.0.0.0
no auto-summary
!
router bgp 34
no synchronization
bgp router-id 3.3.3.3
bgp log-neighbor-changes
network 3.3.3.0 mask 255.255.255.0
neighbor 4.4.4.4 remote-as 34
neighbor 4.4.4.4 update-source Loopback0
neighbor 4.4.4.4 next-hop-self
neighbor 23.0.0.2 remote-as 12
no auto-summary

D、R4基本配置

interface Loopback0
ip address 4.4.4.4 255.255.255.0
!
interface Serial0/0
ip address 34.0.0.4 255.255.255.0
!
interface Serial0/1
no ip address
shutdown
serial restart-delay 0
!
interface FastEthernet1/0
ip address 14.0.0.4 255.255.255.0
!
router rip
version 2
network 4.0.0.0
network 34.0.0.0
no auto-summary
!
router bgp 34
no synchronization
bgp router-id 4.4.4.4
bgp log-neighbor-changes
network 4.4.4.0 mask 255.255.255.0
neighbor 3.3.3.3 remote-as 34
neighbor 3.3.3.3 update-source Loopback0
neighbor 3.3.3.3 next-hop-self
neighbor 14.0.0.1 remote-as 12
no auto-summary

E、查看R3路由信息

R3#sh ip ro

34.0.0.0/24 is subnetted, 1 subnets
C       34.0.0.0 is directly connected, Serial0/0
1.0.0.0/24 is subnetted, 1 subnets
B       1.1.1.0 [20/0] via 23.0.0.2, 00:01:24
2.0.0.0/24 is subnetted, 1 subnets
B       2.2.2.0 [20/0] via 23.0.0.2, 00:10:09
3.0.0.0/24 is subnetted, 1 subnets
C       3.3.3.0 is directly connected, Loopback0
4.0.0.0/24 is subnetted, 1 subnets
R       4.4.4.0 [120/1] via 34.0.0.4, 00:00:21, Serial0/0
23.0.0.0/24 is subnetted, 1 subnets
C       23.0.0.0 is directly connected, Serial0/1

R3#sh ip bgp

Network          Next Hop            Metric LocPrf Weight Path
*> 1.1.1.0/24       23.0.0.2                               0 12 i
* i                 4.4.4.4                  0    100      0 12 i
* i2.2.2.0/24       4.4.4.4                  0    100      0 12 i
*>                  23.0.0.2                 0             0 12 i
*> 3.3.3.0/24       0.0.0.0                  0         32768 i
r>i4.4.4.0/24       4.4.4.4                  0    100      0 i

注：根据BGP路由选择策略，由于默认weight、local preference、AS-path、MED、ORIGIN属性都一样，所以R3会根据第7条路由策略，优先选择EBGP路由，次选择联盟EBGP，最后选择IBGP。R3与R2是EBGP关系而与R4是IBGP，所以选择R2作为下一跳---23.0.0.2

F、使用route-map修改weight属性值

由于weight值只对本路由器有效。所以当R3收到从R4宣告1.1.1.0/24网络时，将weight值改为100（只要比默认值0大就可以），那么R3就会选择R4作为下一跳。

//定义ACL
R3(config)#access-list 1 permit 1.1.1.0 0.0.0.255

//定义route-map，将1.1.1.0/24路由的weight值设为100
R3(config)#route-map set_weight permit 10
R3(config-route-map)#match ip address 1
R3(config-route-map)#set weight 100
R3(config-route-map)#exit
//放过其它的流量
R3(config)#route-map set_weight permit 20
R3(config-route-map)#exit

//将route-map应用于R4对其宣告路由的入方向
R3(config)#router bgp 34
R3(config-router)#neighbor 4.4.4.4 route-map set_weight in

//软清BGP进程
R3#clear ip bgp * soft

注：weight属性是思科私有的，只能配置在本地路由器，不会宣告给任何其它BGP邻居。如果这条路由是本地产生的，weight默认值为32768，否则weight值为0。weight属性用于决定数据流从本地的哪个出口流出AS，选择高者。

G、使用route-map修改local preference属性值

R3收到R2和R4关于1.1.1.0/24 的local preference值都为100。由于local preference只会在同一个AS内传播（只会传播给IBGP邻居），则只需将R4将此路由告诉给R3时，local preference值设为200（选择local preference值高的）。

//定义ACL
R4(config)#access-list 1 permit 1.1.1.0 0.0.0.255

//定义route-map，将1.1.1.0/24路由local-preference值设为200
R4(config)#route-map set_lp permit 10
R4(config-route-map)#match ip address 1
R4(config-route-map)#set local-preference 200
R4(config-route-map)#exit
//放过其它的流量
R4(config)#route-map set_lp permit 20
R4(config-route-map)#exit

//将route-map应用于R1对其宣告路由的入方向
R4(config)#router bgp 34
R4(config-router)#neighbor 14.0.0.1 route-map set_lp in

//软清BGP进程
R4#clear ip bgp * soft

注：local preference属性只会传递给IBGP邻居，默认是100。用于影响数据流如何流出本地自治系统，选择高者

H、使用route-map修改AS-path属性值

R3收到R4和R2关于1.1.1.0/24路由时，AS-Path属性值都只有一个AS号。想要通过AS-Path来影响R3的关于该网络的下一跳，那么可以修改AS-Path值。让R2经过更多一个的AS号。由于AS-Path是用于防止环路的，所以建议R2增加的AS是自己的AS号。（手动添加的AS号是允许重复的）

//定义ACL
R2(config)#access-list 1 permit 1.1.1.0 0.0.0.255

//定义route-map，在1.1.1.0/24路由的AS-path属性上添加两个AS号使路径变长
R2(config)#route-map set_prepend permit 10
R2(config-route-map)#match ip address 1
R2(config-route-map)#set as-path prepend 12 12
R2(config-route-map)#exit
//放过其它的流量
R2(config)#route-map set_prepend permit 20
R2(config-route-map)#exit

//将route-map应用于向R3宣告路由的出方向
R2(config)#router bgp 12
R2(config-router)#neighbor 23.0.0.3 route-map set_prepend out

//软清BGP进程
R2#clear ip bgp * soft

注：在set as-path prepend后添加的AS号，最好是本地自治系统号，否则可能会产生无效路由。
当路由器将信息传给EBGP时会在as-path前面加上自己的AS号，传给IBGP则不加。优先选择AS-PATH最短的路径。

R3的bgp表

R3#sh ip bgp

Network          Next Hop            Metric LocPrf Weight Path
*  1.1.1.0/24       23.0.0.2                               0 12 12 12 i
*>i                 4.4.4.4                  0    100      0 12 i
* i2.2.2.0/24       4.4.4.4                  0    100      0 12 i
*>                  23.0.0.2                 0             0 12 i
*> 3.3.3.0/24       0.0.0.0                  0         32768 i
r>i4.4.4.0/24       4.4.4.4                  0    100      0 i

I、使用route-map修改MED属性值

R3收到原本R2与R4关于1.1.1.0/24网络的MED值都为0。由于MED是通过EBGP进行传播的，且R3会选择MED值小的到达该网络，所以只要将R2关于此网络的MED值设为100（比默认值0高），则R3会选择R4作为下一跳（选择MED值小的）。

//定义ACL
R2(config)#access-list 1 permit 1.1.1.0 0.0.0.255

//定义route-map，将1.1.1.0/24路由metric值设为100
R2(config)#route-map set_med permit 10
R2(config-route-map)#match ip address 1
R2(config-route-map)#set metric 100
R2(config-route-map)#exit
//放过其它的流量
R2(config)#route-map set_med permit 20
R2(config-route-map)#exit

//将route-map应用于向R3宣告路由的出方向
R2(config)#router bgp 12
R2(config-router)#neighbor 23.0.0.3 route-map set_med out

//软清BGP进程
R2#clear ip bgp * soft

注：MED属性只会传递给EBGP peer，也会传播到该peer所在的整个AS内，但是该peer不会将其传递给其它AS。MED属性值默认是0。影响其它的自治系统的数据流，如何流入本地自治系统。选择低者

2、实验环境：C3640-IK9O3S-M Version 12.4(10)

3、实验拓扑

4、实验描述

该网络中，R1、R2同时运行RIP和OSPF，而R3运行OSPF，R4运行RIP，并在R3、R4上模拟两个子网。这样R3和R4并不能互相学习到对方的子网信息，这时我们需要采用路由重分布进行解决。实际上，我们只需在R1或者R2上部署路由重分布就可以让R3与R4互访子网，但我们为了保证网络的高可用性，让R1和R2同时进行路由重分布。

这时问题出现了，当进行R1和R2都进行双向重分布时，会出现R2（R1）访问4.4.4.0/24网络时先经过R3到R1（R2）最后才到达R4。而不是选择最优的路径，直接到达R4。因为在进行双点双向重分布时，R1将重分布进OSPF的4.4.4.0/24的网络传给R2，由于OSPF的AD值110>RIP的AD 值120，所以R2将使用从R1学习到4.4.4.0/24的网络。

为了解决这个问题，那么可以通过修改OSPF的AD值，当R2从R1学到的关于OSPF的AD值>RIP的AD值，即可解决这个问题

5、实验步骤：

A、R1基本配置

interface Serial0/0
ip address 14.0.0.1 255.255.255.0
!
interface Serial0/1
ip address 13.0.0.1 255.255.255.0
!

B、R2基本配置

interface Serial0/0
ip address 23.0.0.2 255.255.255.0
!
interface Serial0/1
ip address 24.0.0.2 255.255.255.0
!

C、R3基本配置

interface Loopback0
ip address 3.3.3.3 255.255.255.0
!
interface Serial0/0
ip address 23.0.0.3 255.255.255.0
!
interface Serial0/1
ip address 13.0.0.3 255.255.255.0
!

D、R4基本配置

interface Loopback0
ip address 4.4.4.4 255.255.255.0
!
interface Serial0/0
ip address 14.0.0.4 255.255.255.0
!
interface Serial0/1
ip address 24.0.0.4 255.255.255.0
!

E、R1路由协议配置

router ospf 1
router-id 1.1.1.1
//将RIP重分布进OSPF
redistribute rip subnets
network 13.0.0.0 0.0.0.255 area 0
!
router rip
version 2
//将OSPF重分布进RIP，并将metric值设为5。如果没有设置，metric值默认是无穷大
redistribute ospf 1 metric 5
network 14.0.0.0
no auto-summary

F、R2路由协议配置

router ospf 1
router-id 2.2.2.2
//将RIP重分布进OSPF
redistribute rip subnets
network 23.0.0.0 0.0.0.255 area 0
!
router rip
version 2
//将OSPF重分布进RIP，并将metric值设为5。如果没有设置，metric值默认是无穷大
redistribute ospf 1 metric 5
network 24.0.0.0
no auto-summary

G、R3路由协议配置

router ospf 1
router-id 3.3.3.3
log-adjacency-changes
network 3.3.3.3 0.0.0.0 area 0
network 13.0.0.0 0.0.0.255 area 0
network 23.0.0.0 0.0.0.255 area 0

H、R4路由协议配置

router rip
version 2
network 4.0.0.0
network 14.0.0.0
network 24.0.0.0
no auto-summary

I、查看R2路由表

3.0.0.0/32 is subnetted, 1 subnets
O       3.3.3.3 [110/65] via 23.0.0.3, 00:00:12, Serial0/0
4.0.0.0/24 is subnetted, 1 subnets
O E2    4.4.4.0 [110/20] via 23.0.0.3, 00:00:12, Serial0/0
23.0.0.0/24 is subnetted, 1 subnets
C       23.0.0.0 is directly connected, Serial0/0
24.0.0.0/24 is subnetted, 1 subnets
C       24.0.0.0 is directly connected, Serial0/1
13.0.0.0/24 is subnetted, 1 subnets
O       13.0.0.0 [110/128] via 23.0.0.3, 00:00:12, Serial0/0
14.0.0.0/24 is subnetted, 1 subnets
O E2    14.0.0.0 [110/20] via 23.0.0.3, 00:00:14, Serial0/0

可以发现4.4.4.0/24的下一跳IP地址是23.0.0.3，这就造成R2出现非最优路径选择问题

J、修改R1和R2互相学习到AD值

因为出现次路由选择是因为R1或者R2学习到的外部路由协议AD值（RIP---120）比内部路由协议（OSPF---90）（R1、R2互相学习对方的路由）值高，所以只要将R1与R2互相学习的AD值改为121（比RIP AD大就可以）

//在R1上将从R2学习的路由AD值设为121，2.2.2.2 0.0.0.0为R2的router-id
distance 121 2.2.2.2 0.0.0.0

//在R2上将从R1学习的路由AD值设为121，1.1.1.1 0.0.0.0为R1的router-id
distance 121 1.1.1.1 0.0.0.0

需要同时在R1和R2上配置，因为R1和R2谁先学习对方的路由信息是随机的。

K、修改AD值后再查看R2的路由表

3.0.0.0/32 is subnetted, 1 subnets
O       3.3.3.3 [110/65] via 23.0.0.3, 00:00:16, Serial0/0
4.0.0.0/24 is subnetted, 1 subnets
R       4.4.4.0 [120/1] via 24.0.0.4, 00:00:08, Serial0/1
23.0.0.0/24 is subnetted, 1 subnets
C       23.0.0.0 is directly connected, Serial0/0
24.0.0.0/24 is subnetted, 1 subnets
C       24.0.0.0 is directly connected, Serial0/1
13.0.0.0/24 is subnetted, 1 subnets
O       13.0.0.0 [110/128] via 23.0.0.3, 00:00:16, Serial0/0
14.0.0.0/24 is subnetted, 1 subnets
R       14.0.0.0 [120/1] via 24.0.0.4, 00:00:09, Serial0/1

问题解决了~

2、实验环境：Packet Tracer 5.3.0

3、实验步骤：

实验拓扑如下图所示

A、根据拓扑图，配置各路由器的ip地址和启动端口。

B、配置各PC机的IP地址。

C、配置ospf协议

R1配置命令：

R1(config)#ro os 100
R1(config-router)#net 172.17.0.0 0.0.255.255 a 0
R1(config-router)#net 10.0.1.0 0.0.0.255 a 0

ro os 100,100是本地ospf的进程号，与其他路由器没有任何关系。为了方便记忆，我还是统一配成一致的。

注：net ip wailcard-mask area 0,0是主干区域号。因为这里是涉及到单区域的配置，而单区域一定要是主干主域，所以这里一定是0

wailcard-mask不能省略，在eigrp中是可以省略的

这条命令“R1(config-router)#net 10.0.1.0 0.0.0.255 a 0”可以用下面命令进行代替。network只是用来告诉路由器那个端口进行处理ospf

R1(config-router) network 10.0.1.1 0.0.0.0 area 0

R2配置命令：

R2(config)#ro os 100
R2(config-router)#net 10.0.0.0 0.0.255.255 a 0

R3配置命令：

R3(config)#ro os 100
R3(config-router)#net 172.17.0.0 0.0.255.255 a 0
R3(config-router)#net 10.0.2.0 0.0.0.255 a0

还需注意一点是，ospf没有自动汇总功能。不用担心不连续子网问题。

2、实验环境：Packet Tracer 5.3.0

3、实验步骤：

实验拓扑如下图所示

注：R1和R2需增加端口模块。单击路由器，选择physical面板，关闭电源，拖动modules下的WIC-1ENEC到右边大小相符的空闲口，打开电源。

A、根据拓扑图，配置各路由器的ip地址和启动端口。

B、配置各PC机的IP地址。

C、配置eigrp协议

R1配置命令：

R1(config)#ro eig 100
R1(config-router)net 172.17.0.0
R1(config-router)net 10.0.0.0

如果后面的wailcard-mask省略，路由器将采用对应有类地址的wailcard-mask

注：这条命令“net 172.17.0.0”可以用下面两条命令进行代替。只宣告路由器对应端口的IP地址

R1(config-router)net 172.17.1.254 0.0.0.0
R1(config-router)net 172.17.2.254 0.0.0.0

“network  IP wailcard-mask”，是一个地址范围，仅仅用于告诉路由器哪一个端口进行处理eigrp

R2配置命令：

R2(config)#ro eig 100
R2(config-router)net 10.0.0.0

R3配置命令：

R3(config)#ro eig 100
R3(config-router)net 172.17.0.0
R3(config-router)net 10.0.0.0

D、关闭路由自动汇总功能。在每台路由器上都执行下面命令

Router(config-router)#no auto

因为此网络出现不连续子网，所以需关闭自动汇总功能，理由见《EIGRP协议：启用与关闭自动汇总功能》

注：路由自动汇总是按有类路由网络地址范围进行汇总，范围过大会出现错误。有需要的话可以使用手动汇总

这里以R3为例进行说明。R3的网段172.17.3.0/24和172.17.4.0/24可汇总为172.17.0.0/21

Router(config-if)#int f0/0
Router(config-if)#ip summary-address eig 100 172.17.0.0 255.255.248.0

R3(config-router)no net 172.17.0.0

已经手动汇总了这两个网段那么就不需要使用network 命令进行宣告

E、启动R1和R3的passive-interface（配不配置不影响网络连接）

让R1的F0/0、E0/0/0和R3的F0/1、E0/0/0接口接收路由更新而不发送路由更新，它们属于末端网络，不需要再将路由更新传递下去。

R1(config-router)#passive-interface f0/0
R1(config-router)#passive-interface e0/0/0

R3(config-router)#passive-interface f0/1
R3(config-router)#passive-interface e0/0/0

F、查看路由协议状态

查看路由器上哪些端口处理erigrp
Router#sh ip eig int

与eigrp建立邻居关系有哪些
Router#sh ip eig nei

查看eigrp建立的拓扑表
Router#sh ip eig to

packet tracker不支持下面这条debug命令
Router#debug ip eigrp

2、实验环境：Packet Tracer 5.3.0

3、实验步骤：

拓扑结构如下所示

注：路由器端口接线顺序是左0右1。如R1与PC1连接的端口是f0/0，与R2连接的端口是f0/1；
设备的IP地址由设备端口的标号和网络号给出。如R1的f0/0端口标着254，处于网段172.16.1.0/24，则R1f0/0端口的ip为172.16.1.254

A、按照拓扑图，启动路由器各端口和配置ip地址（基本功，这里不详细讲了）

B、填写PC1和PC2的IP地址信息

C、确保PC1能ping通R1，PC2能ping通R3再往下做实验

D、配置R1和R3的rip协议

Router(config)#router rip
Router(config-router)#network 10.0.0.0
Router(config-router)#network 172.16.0.0

R1和R3直连的主类网络号是一样的，因此配置命令一样

注：network ip_address中，ip_address为路由器直连的A、B、C网络号。即时你输入子网号（假如为10.1.1.0），路由器依旧将其转化为A、B、C类网络。

E、配置R2的rip协议

R1(config)#router rip
R1(config-router)#network 10.0.0.0

F、配置完rip协议后，你发现PC1并不能ping同PC2。

想想为什么。数据包是根据路由条目进行转化的，所以查看R1和R3的路由表：Router#sh ip ro，是比较有效的一种方法

下面以R1为例说明原因，R1路由表中条目如下：

10.0.0.0/24 is subnetted, 2 subnets
C       10.1.1.0 is directly connected, FastEthernet0/1
R       10.1.2.0 [120/1] via 10.1.1.2, 00:00:18, FastEthernet0/1
172.16.0.0/24 is subnetted, 1 subnets
C       172.16.1.0 is directly connected, FastEthernet0/0

在路由表中没有看到172.16.2.0网络的信息。因为网络中出现了不连续子网，且有类路由信息不能区别子网信息（宣告网络时不带子网掩码）。具体解释见《EIGRP协议：启用与关闭自动汇总功能》

G、有类路由不能有效解决不连续子网问题，那么需使用RIP V2

分别在三个路由器上配置rip为V2版本

Router(config)#ro rip
Router(config-router)#ver 2（启动rip v2版本）
Router(config-router)#no auto（关闭自动汇总）
现在查看R1的路由表：

10.0.0.0/24 is subnetted, 2 subnets
C       10.1.1.0 is directly connected, FastEthernet0/1
R       10.1.2.0 [120/1] via 10.1.1.2, 00:00:06, FastEthernet0/1
172.16.0.0/24 is subnetted, 2 subnets
C       172.16.1.0 is directly connected, FastEthernet0/0
R       172.16.2.0 [120/2] via 10.1.1.2, 00:00:06, FastEthernet0/1

这时应该能看到R1路由表条目出现了172.17.2.0的信息。

H、启动R1和R3的passive-interface

让R1的F0/0和R3的F0/1接口接收路由更新而不发送路由更新，它们属于末端网络，不需要再将路由更新传递下去。

R1(config-router)#passive-interface f0/0
R3(config-router)#passive-interface f0/1

I、观看路由器收发rip包的情况

Router#debug ip rip

仔细观察，对比RIP V1和RIP V2的异同和设置了passive-interface前后数据包的收发情况，加深理解

2、实验环境：Packet Tracer 5.3.0

3、实验步骤：

实验拓扑图如下所示

A、配置R1路由器IP和启用端口

R2(config)#int f0/0
R2(config-if)#ip add 11.0.0.1 255.255.0.0
R2(config-if)#no shut

R2(config-if)#int f0/1
R2(config-if)#ip add 10.1.0.254 255.255.0.0
R2(config-if)#no shut

B、配置R2路由器IP和启用端口

R2(config)#int f0/0
R2(config-if)#ip add 11.0.0.2 255.255.0.0
R2(config-if)#no shut

R2(config-if)#int f0/1
R2(config-if)#ip add 10.2.0.254 255.255.0.0
R2(config-if)#no shut

C、配置PC1、PC2的IP

PC1：
IP Address：10.1.0.1
Subnet Mask：255.255.0.0
Default Gateway：10.1.0.254

PC2：
IP Address：10.2.0.1
Subnet Mask：255.255.0.0
Default Gateway：10.2.0.254

D、测试PC1与R1的连通性

PC1>ping 11.0.0.1（能通）
PC1>ping 11.0.0.2（不能通）
注：PC1能把包发给R2的11.0.0.2，但是R2不能返回给PC1，想想为什么

E、配置静态路由

R1(config)#ip route 10.2.0.0 255.255.0.0 11.0.0.2
R2(config)#ip route 10.1.0.0 255.255.0.0 11.0.0.1

F、配置默认路由

R1(config)#ip route 0.0.0.0 0.0.0.0 11.0.0.2
R2(config)#ip route 0.0.0.0 0.0.0.0 11.0.0.1
注：在配置默认路由时需开启”ip classless“，默认是开启的

注：E和F步骤是任选其一进行配置。

4、实验测试：

R#show ip route
使用这条命令进行对比两种配置的异同

PC1>ping 10.2.0.1
PC1能ping通PC2，实验成功

Router(config)#no ip domain-lookup

在实验环境中，当输入错误命令时，会进行域名查询。需要等待它查询完成返回结果才能继续进行实验，的确很烦，建议手动关掉

B、防止输入命令被输出信息冲断

Router(config)#line console 0
Router(config-line)#logging synchronous

在启动debug命令时，控制台会输出信息，这时，你刚好在输入命令，debug信息出现会把你输入命令冲断

例如像这样的情况：

Router#show ip roRIP: sending  v1 update to 255.255.255.255 via FastEthernet0/0 (10.1.1.2)

C、防止超时退出

Router(config)#line console 0
Router(config-line)#exec-timeout 0 0

在你一段时间没有进行操作时，控制台会自动退出到用户模式。在实验环境中，不考虑安全性，可输入这命令较少繁琐操作

2、实验环境：Packet Tracer 5.3.0

3、实验步骤：

拓扑如下图所示

A、配置R1的f0/0端口地址

Router(config)#int f0/0

Router(config-if)#no shutdown

Router(config-if)#ip address 192.168.1.254 255.255.255.0

B、配置S1的IP地址

（1）左键单击S1，选择“Desktop”->点击“IP Configuration”

（2）填写IP地址，IP Address为192.168.1.1；Subnet Mask为255.255.255.0

C、测试R1与S1的连通性

Router#ping 192.168.1.1；能ping通再继续下面的实验。

D、查看IOS的版本

Router#show version
Cisco IOS Software, 1841 Software (C1841-ADVIPSERVICESK9-M), Version 12.4(15)T1, RELEASE SOFTWARE (fc2)......

注：升级后可通过对比，看是否已升级成功

E、Router#show flash

System flash directory:
File  Length   Name/status
3   33591768 c1841-advipservicesk9-mz.124-15.T1.bin（这个文件在升级前需先进行保存，如果你比较懒可以不保存）
2   28282    sigdef-category.xml
1   227537   sigdef-default.xml
[33847587 bytes used, 30168797 available, 64016384 total]
63488K bytes of processor board System flash (Read/Write)

F、升级前先对IOS保存

Router#copy flash tftp
Source filename []? c1841-advipservicesk9-mz.124-15.T1.bin
Address or name of remote host []? 192.168.1.1（S1的IP）
Destination filename [c1841-advipservicesk9-mz.124-15.T1.bin]?（直接回车）

注:当你看到一大堆叹号说明已成功地再进行保存了

D、进入升级

Router#copy tftp flash
Address or name of remote host []? 192.168.1.1（S1的IP）
Source filename []? c2800nm-advipservicesk9-mz.124-15.T1.bin
Destination filename [c2800nm-advipservicesk9-mz.124-15.T1.bin]?（直接回车）

注：在S1上先查看TFTP服务器都有什么IOS文件

打开S1，点击config->services->TFTP，在File里可查看都有什么文件

E、完成后，保存配置，重启

Router#wr

Router#reload

实验测试：使用下面两条命令查看是否已修改

Router#show version

Router#show flash

附：想使用Packet Tracer实现在rommon模式下进行升级实验，没成功，但在真机上没问题

写下在真机上的实验操作，这种方法适合在IOS已损坏的情况进行

A、同样地需要让R1和S1能互通，步骤我就不祥说了

B、进入Rommon模式。在启动设备的60s内使用组合键"CTRL+BREAK"

C、配置使用命令“tftpdnld”所需要的参数

rommon 2 >  IP_ADDRESS=192.168.1.254
rommon 3 > IP_SUBNET_MASK=255.255.255.0
rommon 4 > DEFAULT_GATEWAY=192.168.1.254
rommon 5 > TFTP_SERVER=192.168.1.1
rommon 6 > TFTP_FILE=C2800NM-ADVIPSERVICESK9-MZ.124-15.T1.BIN

注：这几个都是必配参数，少哪个都不行

D、开始升级

rommon 2 > tftpdnld

E、检查是否升级成功

rommon 2 > dir flash:

更正说明：slyar做了实验，其实Packet Tracer可以实现在ROMMON模式下进行版本升级。我之前失败是因为没有将设备的第一个以太网接口与服务器建立连接。因为进入ROMMON模式，设备接口处于DOWN状态，这时设备会试图通过第一个接口与外部建立连接。（个人理解）

2、实验环境：Packet Tracer 5.3.0

设备说明：采用Router 1841进行口令恢复操作

3、实验步骤：

A、启动设备，在启动设备的60s内使用组合键"CTRL+BREAK"执行中断进入ROM-monitor模式

注：如果设备已启用完成，可在设备全局模式下输入命令”reload“重新启动设备

B、修改配置寄存器的值

rommon 1> confreg 0x2142

C、重载路由器

rommon 2>reset

D、进入特权模式，将startup-config文件复制到running-config文件

Router>enable

Router#copy startup-config running-config

E、进入特权模式，修改口令

Router#conf t

Router(config)#enable secret joan

F、将配置寄存器重设为默认值

Router(config)#config-register 0x2102

G、回到特权模式，保存路由器的配置

Router(config)#exit

Router#copy running-config startup-config

H、重载路由器

Router#reload

4、实验测试：

查看寄存器是否已修改

Router#show version

查看密码是否已设置

Router#show running-config

注：寄存器中0x2102和0x2104的区别：

前者设备启用后在NVRAM中查找有效的配置文件。如果NVRAM中有startup-config文件，路由器将加载并运行此文件。后者启动设备后将忽略NVRAM中的内容，直接进入”configuration dialog“

2、实验环境：Packet Tracer 5.3.0

3、实验步骤：

A、用console方式登陆

（1）将PC1与R1通过console线连接起来

（2）用面板中“connections”中的“console"线，将其分别连接到PC1的"RS 232”接口和R1的“console”接口。如下图所示

（3）左键单击PC1，选择“Desktop”->点击“Terminal”，点击“ok”按钮。出现“Continue with configuration dialog? [yes/no]: ”这条语句，意味着已经成功登陆R1

（4）输入：no。进入R1用户模式。

B、下面开始进行路由器的基本配置

（1）进入特权模式
Router>en

（2）进入全局配置模式
Router#conf t

（3）配置主机名（可配可不配，只是为了便于区别设备）
Router(config)#hostname joan

（4）启用口令，密码以明文记录在路由器的配置文件中
joan(config)#enable password cisco

（5）启用加密口令，密码使用MD5加密算法将结果记录在路由器的配置文件中
joan(config)#enable secret joan

注：如果（4）和（5）条命令同时配置，后一条命令起作用

C、配置控制台管理密码

（1）进入控制台端口

joan(config)#line console 0

（2）配置控制台口令

joan(config-line)#login

joan(config-line)#password joan

D、配置远程管理密码

（1）进入远程登陆虚拟端口

joan(config)#line vty 0 15

（2）配置远程登陆口令

joan(config-line)#login

joan(config-line)#password joan

（3）设置登陆后提示信息

joan(config-line)#banner motd #Welcome to joansky.com#

注：如果想需要让信息换行显示，直接在输入第一个”#“后按回车

注：使用”password“参数配置启用口令、控制台口令和登陆口令时，如需将密码以密文形式记录在路由器的配置文件中，那么可使用“enable password 7 082B434F07”替代，或者在全局模式下使用“service password-encryption”命令。（082B434F07是”joan“字符串经过cisco加密算法后得到的密文）。这两条命令都是使用cisco加密算法进行加密。

4、实验测试：

测试目标：测试远程登录口令是否设置成功

A、使用”copper cross-over“线将PC1的”FastEthernet“口和R1的”FastEthernet 0/0“连接。如下图所示

B、配置R1的IP地址

（1）进入R1的f0/0口

joan(config)#int f0/0

（2）启用端口

joan(config-if)#no shutdown

（3）配置端口IP地址

joan(config-if)#ip address 192.168.1.254 255.255.255.0

C、配置PC1的IP地址

（1）左键单击PC1，选择“Desktop”->点击“IP Configuration”，点击“ok”按钮。

（2）填写IP地址，IP Address为192.168.1.1；Subnet Mask为255.255.255.0； Default Gateway为192.168.1.254（这里也可以不填）

D、在PC1上使用“Terminal”工具进行测试

（1）打开“Terminal”工具，输入“telnet 192.168.1.254”

（2）回车，输入设置的密码，这里为“joan”

注：输入的密码并不会显示出来，直接回车就可以了

假设授权的域名服务器是主域服务器，IP地址：192.168.56.2

配置步骤如下：

1、打开DNS管理器，选择slyar2，单击右键，选择“属性”->“转发器”，填写“IP地址：192.168.56.2”（主域服务器IP），点击“应用”，确定。唯缓服务器配置完成。

测试唯缓服务器配置是否成功，步骤如下：

1、在唯缓服务器上使用CMD，使用命令：ping www.bnuep.com（主域服务可解析的域名）

2、在DNS管理器菜单栏，点击查看，选择高级，出现缓存的查找项，可以看到已经存储了关于域名解析的缓存记录

主域服务器IP地址：192.168.56.2，区域名称为：bnuep.com

辅助服务器IP地址：192.168.56.4

具体配置如下：

1、先配置主域服务器的区域复制权限。在主域服务器上，打开DNS管理器，单击右键，选择“属性”->选择“区域复制项”，选择“到所有服务器”，确定。

2、开始配置辅助服务器。在辅助服务器上，打开DNS管理器，点击DNS，选择“slyar2”，单击右键，选择“新建区域”

3、点击“下一步”，选择“辅助区域”，取消“在Active Directory中存储区域”

4、点击“下一步”，填写“区域名称：bnuep.com”

5、点击“下一步”，填写“IP地址：192.168.56.2”（主域服务器IP地址），点击下一步，完成

6、点击“bnuep.com”可以看到主域服务器相关域名解析的记录，辅助服务器配置完成。

在cmd下使用命令：nslookup www.bnuep.com 192.168.56.4 （辅助服务器IP地址）测试辅助域名服务器配置是否成功。

委派服务器的IP地址：192.168.56.3

具体配置如下：

1、首先主域服务器需对信息技术学院的域名解析进行委派。打开主域服务器的DNS管理器，点击DNS，选择“slyar1”，右键点击“bnuep.com”，选择“新建委派”

2、点击“下一步”，选择“主要区域”

3、点击“下一步”，填写“委派的域：itc”

4、点击“下一步”，填写“服务器完全合格的域名：itc.bnuep.com”，IP地址填写192.168.56.3（委派服务器的IP地址），点击确定

5、点击“下一步”，完成

6、如下图所示，主域服务的委派任务配置完成。接下来配置委派服务器

7、打开委派服务器的DNS管理器。委派服务器的配置跟配置主域服务器的步骤一样（可参见配置DNS服务器之主域服务器——Windows Server 2003），选择“新建区域”，填写“区域名称：itc.bnuep.com”

8、接下来开始添加主机记录。选择“新建主机”
填写“名称：www，IP地址：1.1.1.1”，点击添加主机，确定
添加，“名称：ftp，IP地址：2.2.2.2”，点击添加主机，确定
添加，“名称：mail，IP地址：3.3.111.222”，点击添加主机，确定
添加所有需要的子域名后，点击完成。

如下图所示，委派服务器配置完成

在cmd下使用命令：nslookup ftp.itc.bnuep.com 测试主域服务配置是否成功

学校的二级域名：bnuep.com ，IP地址：111.111.111.111

文学院的子域名：wxy.bnuep.com，IP地址：222.222.222.222

国际商学部的子域名：ibm. bnuzh.edu，IP地址：111.222.111.222

具体配置如下：

1、打开DNS管理器，点击DNS，选择“slyar1”，单击右键，选择“新建区域”->点击“下一步”，选择“主要区域”，取消“在Active Directory中存储区域”

2、点击下一步，选择正向查找区域

3、点击下一步，填写“区域名称：bnuep.com”（学校二级域名）

4、点击下一步，直至完成

5、点击正向查找区域中，选择bnuep.com，点击右键->选择新建主机

6、填写“名称：www，IP地址：111.111.111.111”，点击添加主机，确定

添加，“名称：wxy，IP地址：222.222.222.222”，点击添加主机，确定

添加，“名称：ibm，IP地址：111.222.111.222”，点击添加主机，确定

添加所有需要的子域名后，点击完成。

7、如下图，主域服务器配置完成

在cmd下使用命令：nslookup www.bnuep.com 测试主域服务配置是否成功

network IP_address wildcard_mask area area_#

在配置ACL时，使用命令：

access-list numbers permit|deny source_IP_address wildcard_mask

这两条配置命令的wildcard_mask参数有点小区别：

OSPF的wildcard_mask参数（反掩码），必须是由连续的0组成，不能被1断开。
ACL的wildcard_mask参数（通配符），可以使用不连续的0组成，只需对应的位置匹配即可。

例如：access-list 1 permit 192.168.1.0 0.0.0.10

表示允许192.168.1.0、192.168.1.2、192.168.1.8、192.168.1.10这4个IP地址通过（假设192.168.1.0是主机地址）

All in One SEO Pack must be configured. Go to the admin page to enable and configure the plugin.
All in One SEO Pack now supports Custom Post Types.

到底是哪里没有启动呢。插件面板，确定All in One SEO Pack已处于启动状态，设置面板修改的All in One SEO Pack设置也保存了。难道是All in One SEO Pack必须全部填满？但是如果是必须设置的话应该会以"*"提示。

仔细检查了下设置发现Plugin Status 没有选择enabled，选择并保存，错误提示消失了。

这错误还是挺低级的，下回注意点。

等一下，也许你会问什么是连续子网和不连续子网？

连续子网：主类网络号相同，子网掩码相同

不连续子网=把连续子网隔开

如下图，172.17.2.0/24,172.17.1.0/24网段被192.168.0.0/16网段隔开，成为不连续子网

下面用这个图来详细说明启用与关闭汇总功能出现的情况。

1、如果被隔开网段所在的路由器开启了汇总功能auto-summary ，那么路由器会自动将路由条目汇总为主类网络发送出去。例如，Router1配置了network 172.17.2.0 0.0.0.255，但是进行网络宣告时，发现送出端口f0/0的网段是192.168.1.0/24，与172.17.2.0/24不处于同一连续子网就把172.17.2.0/24总结为主类网络172.17.0.0/16.

Router1的路由条目

172.17.0.0/16 is variably subnetted, 2 subnets, 2 masks
D       172.17.0.0/16 is a summary, 00:06:47, Null0
C       172.17.2.0/24 is directly connected, FastEthernet0/1
C    192.168.1.0/24 is directly connected, FastEthernet0/0
D    192.168.2.0/24 [90/30720] via 192.168.1.1, 00:07:06, FastEthernet0/0

进行自动汇总时，Router1收到来着Router2宣告的网络号172.17.0.0/16（Router3已经将172.17.1.0/24进行自动总结），发现自己已经有了该网段，就忽略该宣告信息。因此Router1无法了解到Router3的172.17.1.0/24网段，只能ping通主类网段172.17.1.0/16中的子网络172.17.2.0/24

Router2的路由条目

D    172.17.0.0/16 [90/30720] via 192.168.2.2, 00:00:29, FastEthernet0/1
[90/30720] via 192.168.1.2, 00:00:29, FastEthernet0/0
C    192.168.1.0/24 is directly connected, FastEthernet0/0
C    192.168.2.0/24 is directly connected, FastEthernet0/1

Router2收到Router1和Router3关于主类网络172.17.0.0/16的宣告信息，简单认为存在两条路径能同时达到该网络，并进行负载均衡。事实上Router2从F0/0口发送的数据包只能到达172.17.1.0/24网段，从F0/1口发送的数据包只能到达172.17.2.0/24网段，当Router2有数据包发往172.17.2.0/24以及172.17.1.0/24网段时都会出现丢包情况。

Router3的路由条目

172.17.0.0/16 is variably subnetted, 2 subnets, 2 masks
D       172.17.0.0/16 is a summary, 00:02:19, Null0
C       172.17.1.0/24 is directly connected, FastEthernet0/0
D    192.168.1.0/24 [90/30720] via 192.168.2.1, 00:01:41, FastEthernet0/1
C    192.168.2.0/24 is directly connected, FastEthernet0/1

Router3跟Router1同理。

2、如果被隔开网段所在的路由器关闭了汇总功能no auto-summary ，那么路由器会如实地将配置的网络信息进行宣告。例如，Router1配置了network 172.17.2.0 255.255.255.0，进行网络宣告时将172.17.2.0/24网络从F0/0口发送出去。

Router1的路由条目

172.17.0.0/16 is variably subnetted, 3 subnets, 2 masks
D       172.17.0.0/16 [90/33280] via 192.168.1.1, 00:26:20, FastEthernet0/0
D       172.17.1.0/24 [90/33280] via 192.168.1.1, 00:17:14, FastEthernet0/0
C       172.17.2.0/24 is directly connected, FastEthernet0/1
C    192.168.1.0/24 is directly connected, FastEthernet0/0
D    192.168.2.0/24 [90/30720] via 192.168.1.1, 00:26:20, FastEthernet0/0

Router2的路由条目

172.17.0.0/16 is variably subnetted, 3 subnets, 2 masks
D       172.17.0.0/16 is a summary, 00:27:01, Null0
D       172.17.1.0/24 [90/30720] via 192.168.2.2, 00:17:55, FastEthernet0/1
D       172.17.2.0/24 [90/30720] via 192.168.1.2, 00:27:01, FastEthernet0/0
C    192.168.1.0/24 is directly connected, FastEthernet0/0
C    192.168.2.0/24 is directly connected, FastEthernet0/1

Router3的路由条目

172.17.0.0/16 is variably subnetted, 2 subnets, 2 masks
D       172.17.0.0/16 [90/33280] via 192.168.2.1, 00:18:26, FastEthernet0/1
C       172.17.1.0/24 is directly connected, FastEthernet0/0
D    192.168.1.0/24 [90/30720] via 192.168.2.1, 00:18:26, FastEthernet0/1
C    192.168.2.0/24 is directly connected, FastEthernet0/1

从上面三个Router条目可看到路由表条目都对应这具体的网络号。只要存在该网络，路由器都将正确发送到目的地址。

细心的你可能会发现，路由条目多了

D       172.17.0.0/16 is a summary, 00:27:01, Null0

这样一条转发端口为Null0的伪接口，是为了避免产生路由环路，当匹配这条路由的数据包会被路由器丢弃。

假如Router1上有一个数据包，其目的地址为172.17.3.1/24，则router1会将数据包从f0/0口发送出去，到了Router2时，数据包目的地址与Router2的172.17.0.0/16匹配，则将数据包发往Null0口，即丢弃。
如果没有NUll0这一条路由条目，那么数据包会在三个路由器中来回地不停传送。

1、报了全国计算机等级考试——四级网络工程师，考试时间在三月末，虽说基础还行但是概念什么的还是得看得背，开学后就忙这了。考试成绩在前两天已经出来了，算飘过了。

2、三月底参加信息技术学院举办的ACM校内赛，拿了一等奖。

3、4月份忙着做项目——POJ题数统计系统。主要负责网站的前台开发，虽然之前学过Html，Css基本知识，但这个项目涉及Ajax，Jquery技术，我花了一星期泡图书馆看书，便开工了，边学边做，再加上文档的编写花了几个星期的时间。

4、参加了计算机技术与软件专业技术资格（水平）考试——中级软件工程师，这东西知识范围真广，又是各种备考。成绩要在6月底才公布，应该能过吧。

5、报了通创CCNP的班，送了CCNA，CCNA的培训班是5月14号开始，每个周日就耗在通创那边学习了。虽然NA已经学过了，但多听一遍当加强基础也不错。等着上完思科网院的课拿上考试折扣号，就把NA考了。

6、参加了通创公司的社团。下学期也没什么课，锻炼一下还是有必要的。
7、5月份中旬参加了信息技术学院组织的计算机作品大赛，一共交了2个作品，POJ题数统计系统和微型FTP服务器，FTP拿了一等奖，POJ拿了二等奖。

8、前天晚上学院进行颁奖晚会，拿了三个奖状，还有一些小礼品，什么16G的U盘，300块移动话费，还有一个夜灯。

过几个星期就是CET和期末考试了，接下来又是各种备考.....

今天是Slyar生日，生日快乐哈。下星期是珊和小妹生日，在这里提前祝她们生日快乐！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>鼠标点击时动态加载显示表格的下一行</title>
<script type="text/javascript" src="js/jquery-1.3.2.js"></script>
<script type="text/javascript">
    $("table tr td").click( function () {
	//获取点击行的id选择器值
        var target = $(this).parent().children().children().attr("id");
	//取得下一行的id选择器
        var subId = "#";
        subId += target.substr(5, target.length);
        //获取点击行的用户名
        var temp = $(this).parent().children("td:eq(1)").html();
	//发出请求
        $(document).ready(function () {
            $.ajax({
                type: "post",
                url: "query.php",
                data: { action: "detail", username: temp },
                dataType: "text",
		//在返回数据前用进度条显示，提高用户体验
                beforeSend: function (XMlhttprequest) {
                    $(subId).children().html("<img src=\"load.gif\"></img>");
                },
		//返回数据，操作htm值
                success: function (data) {
                    $(subId).children().html(data);
                }
            });
	//显示行
	$(subId).toggle();
    });
</script>
</head>
<body>
<table>
<tr><td>ID</td><td>用户名</td><td id="index0">题目总数</td></tr>
<tr><td>1</td><td>joan</td><td id="index1">4</td></tr>
<tr display="none" id="0"><td colspan="3"></td></tr>
<tr><td>2</td><td>joansky</td><td id="index1">3</td></tr>
<tr display="none" id="0"><td colspan="3"></td></tr>
</table>
</body>
</html>

这个表格显示用户基本情况，下一行显示用户题目信息。

我想把这个表格设计为当鼠标点击用户的基本情况时，根据用户名动态查询用户题目信息后显示出来

怎么获取鼠标点击的是哪一行呢？

利用$(this).parent().children().children().attr("id")可以获取鼠标点击该行的id选择器值，然后使用获得的id选择器去获取下一行的元素，最后使用.toggle()让其交替显示隐藏。

解析$(this).parent().children().children().attr("id")

$(this).parent()取得<td>1</td><td>joan</td><td id="index1">4</td>

$(this).parent().children()取得<td>1</td>

$(this).parent().children().children()取得<td id="index1">4</td>

$(this).parent().children().children().attr("id") = "index1"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>循环处理ajax事件问题</title>
<script type="text/javascript" src="js/jquery-1.3.2.js"></script>
<script type="text/javascript">
    $(document).ready(function () {
        $("#test a").click(function () {
            for (var i = 0; i < 3; ++i) {
                alert("for循环获取的:" + i);
                $.ajax({
                    type: "post",
                    url: "joan.php",
                    data: { action: "adddata", username: i },
                    dataType: "text",
                    success: function (data) {
                        //处理成功时的操作
                        alert("ajax处理事件后的" + i);
                    }
                    //,async: false //实现同步机制
                });
            }
        });
    });
</script>
</head>
<body>
<div id="test"><a>点击我</a></div>
</body>
</html>
 
//joan.php
<?php
for ($i=0; $i<=100000; $i++)
{
}
?>

运行程序:页面连续弹出3个”for循环获取的i“,i值从0到3，然后再弹出3个"ajax处理事件后的i",i值一直是3。因为ajax是异步机制，在ajax在后台进行处理时，前台的for循环照常进行。

当你想让运行的顺序按照你写程序顺序执行，或者需要在ajax处理完成后，即在success: function (data) { }需要正确调用i值处理事情时，那么就用同步机制吧。

在.ajax加上async参数，async: false，就可以实现同步了。

这时，你会看到页面顺序弹出”for循环获取的i“、"ajax处理事件后的i"。

从诏安坐大巴到厦门岛内，在车站一下车顺手牵走一张地图。研究了下，决定先到普陀寺。厦门岛内的公车都是1RMB，真便宜~

普陀寺，烧香拜佛的地方，入门费3RMB，准备走人的时候发现可以登山，看天气蛮适合登山的，便上去了，登完山第二天腿酸死了，那个后悔...在普陀寺买了素饼，10RMB一盒，当午餐吃掉，味道还不错，绿茶味的，呵，我是绿茶控啦。普陀寺下来附近就是赫赫有名的厦门大学，里面的学院又多又复杂，建筑很复古，在里面绕了半圈就出来了，背着背包，肩酸的走不下去...

出来后坐上公车到中山步行街，一下车就看到仙草南路店，来之前就听同学介绍这个很好吃，嘴馋了。真的好好吃，回来还念念不忘，回家上网查了下，只有厦门才有这种连锁店。唔，以后有钱了在广州投资个，呵呵。

在步行街买了几盒饼还有一些干果，又吃了鱼丸，薄饼，都是一些厦门小吃，好饱=_=

第二天，古浪鼓。直接公车到轮渡，轮渡下了车到对面坐轮船，到鼓浪屿的轮船是免费的。在过渡口有两个入口处，一个需要船票一个不需要，自己多转悠下就知道是哪个了，我也不知道这有什么区别。
鼓浪屿有六个景点区，日光岩、琴园、淑庄花园、皓月园、风琴博物馆、刻字馆，跟我同来的已经去过日光岩，说也没啥看头，网上都推荐淑庄花园，就只去了这个景点。其实我觉得鼓浪屿的特色不在这些景点上，而是那些边边角角的小商店和建筑...很多商店装饰得很有个性，一间七八十年代的老房子也能装饰得让你觉得很有看头。古浪鼓里面有商业街，什么厦门特产，小吃，创意店...到了晚上6点海风很大，厦门又值降温中，超冷，冻得手都起冻疮了。买了回去的船票，8RMB

第三天，园博园，人真少，整个园博园就遇到十几个人在逛，整条小吃街就剩店主，很多博物馆都没开，不过这样也好，拍的照片都没有人肉背景了。

第四天，回到室友家休息了天坐大巴回家，就是起冻疮的手现在还在脱皮中

早上7点30分到了福田口岸，过关花了半个小时，比去澳门排两个多小时队强太多了。

第一站：尖沙咀1881 heritage和海港城

1881 heritage主题：A Christmas of Classical Wonders

海港城：巨型蛋糕装饰

这两个地方的圣诞主题装饰很漂亮，晚上看的话应该更美

从海港城出来刚好遇到haagendazs店，那个时候差不多11点，但还没开门，后来辗转了好几个地方都为了找haagendazs，没GPS，没WIFI，RP还不好，没找到...返程时，还想着回海港城这边吃，不过C姐支持不住，时间也不早了，只能作罢。说了这么多，其实不是我想吃，是嘴馋的S姐....=_=

第二站：星光大道

海风吹得真爽，那个时候我终于理解为什么人们为什么都喜欢来海边散心。那天海风超大超冷，吹得头皮发麻，大脑都麻木没感觉，自然就没烦恼了。之前虽然也去海边吹吹风，但远不如这次遇到的大、冷...

观光船，看起来像海盗船

第三站：中环歌赋街、石板街、桂兰坊、皇后像广场

好不容易找到歌赋街，但没节目，周日才有，囧。

皇后像广场——Swarovski 2010圣诞

第四站：铜锣湾

计划里没铜锣湾这站，但是行程提早结束。铜锣湾基本上每个广场都有关于圣诞的装饰。最好看的最属时代场了，是Michael Lau的Gardener十周年盛典——将Michael Lau设计的人物制作出来在时代广场

和圣诞老人和了张照，鉴于本人上镜效果太差，还是不贴出来好

这张挺美的...

PS：在一个人口比较密集的城市，事实上无论是否是节日还是举办盛大活动，感觉人流量都差不多。

好吧，用小学写作文经常写到的词来结束它吧：累并快乐着=_=

一、系统引导过程简介

系统引导过程主要由以下几个步骤组成（以硬盘启动为例）

1. 开机
2. BIOS加电自检（POST——Power On Self Test），内存地址为0fff：0000
3. 将硬盘第一个扇区（0头0道1扇区，也就是Boot Sector）读入内存地址0000：7c00处
4. 检查（WORD）0000：7dfe是否等于0xaa55.若不等于则转去尝试其他介质；如果没有其他启动介质，则显示 “No ROM BASIC” ，然后死机
5. 跳转到0000：7c00处执行MBR中的程序
6. MBR先将自己复制到0000：0600处，然后继续执行
7. 在主分区表中搜索标志为活动的分区。如果发现没有活动分区或者不止一个活动分区，则停止
8. 将活动分区的第一个扇区读入内存地址0000：7c00处
9. 检查（WORD）0000：7dfe是否等于0xaa55，若不等于则显示 “Missing Operating System”，然后停止，或尝试软盘启动
10. 跳转到0000：7c00处继续执行特定系统的启动程序
11. 启动系统

流程图如下

当系统首次引导时，或系统被重置时，处理器会执行一个位于已知位置处的代码。在个人计算机（PC）中，这个位置在基本输入/输出系统（BIOS）中，它保存在主板上的闪存中（内存地址为0fff：0000），完成以上步骤中（2），（3），（4），（5）。

当找到一个引导设备之后，第一阶段的引导加载程序就被装入 RAM 并执行。这个引导加载程序MBR在大小上小于 512 字节（一个扇区），其作用是加载第二阶段的引导加载程序，完成以上步骤中（6），（7），（8），（9），（10）。

当第二阶段的引导加载程序被装入 RAM 并执行时，通常会显示一个动画屏幕，并将 Linux 和一个可选的初始 RAM 磁盘（临时根文件系统）加载到内存中。在加载映像时，第二阶段的引导加载程序就会将控制权交给内核映像，然后内核就可以进行解压和初始化了。在这个阶段中，第二阶段的引导加载程序会检测系统硬件、枚举系统链接的硬件设备、挂载根设备，然后加载必要的内核模块。完成这些操作之后启动第一个用户空间程序（init），并执行高级系统初始化工作。

这就是 Linux 引导的整个过程。现在让我们深入挖掘一下这个过程，并深入研究一下 Linux 引导过程的一些详细信息。

二、系统启动

在 PC 中，引导 Linux 是从 BIOS 中的地址 0xFFFF0 处开始的。BIOS 的第一个步骤是加电自检（POST代码，这段代码完成对硬件检测后会被从内存中清除）POST程序通过对内存及其它硬件的诊断确定硬件的存在并可操作性。BIOS 的第二个步骤是进行本地设备的枚举和初始化（运行时服务代码）。BIOS运行行服务代码（这段代码保留在内存中，供目标操作系统使用）找到用户配置的启动设备后，将主引导记录（MBR）加载到RAM中，然后BIOS将控制权交给“第一个引导程序”（MBR）。

BIOS从上电到现在忙活了大半天，主要目的就是为了找到引导设备，并将引导设备的引导程序加载到RAM中来运行。

如何找到用户配置的启动设备（即引导一个操作系统）呢？

BIOS 运行时会按照 CMOS 的设置定义的顺序来搜索处于活动状态并且可以引导的设备。引导设备可以是软盘、CD-ROM、硬盘上的某个分区、网络上的某个设备，甚至是 USB 闪存。

三、第一阶段引导加载程序

BIOS交出系统的执行控制权，跳转到引导程序（MBR）的头部执行。引导记录开头是一条无条件转移指令，它将立即跳转到地址0x03e执行引导程序，主引导加载程序的工作是查找并加载次引导加载程序（第二阶段）。它是通过在分区表中查找一个活动分区来实现这种功能的。当找到一个活动分区时，它会扫描分区表中的其他分区，以确保它们都不是活动的。当这个过程验证完成之后，就将活动分区的引导记录从这个设备中读入 RAM 中并执行它。

注：
主引导记录（MBR）中包含主引导加载程序。MBR 是一个 512 字节大小的扇区，位于磁盘上的第一个扇区中（0 道 0 柱面 1 扇区）。

MBR 中的主引导加载程序是一个 512 字节大小的映像，其中包含程序代码和一个小分区表。前 446 个字节是主引导加载程序，其中包含可执行代码和错误消息文本。接下来的 64 个字节是分区表，其中包含 4 个分区的记录（每个记录的大小是 16 个字节）。MBR 以两个特殊数字的字节（0xAA55）结束。这个数字会用来进行 MBR 的有效性检查。

四、第二阶段引导加载程序

次引导加载程序（第二阶段引导加载程序）可以更形象地称为内核加载程序。这个阶段的任务是加载 Linux 内核映像和可选的初始 RAM 磁盘到内存中。

将第二阶段的引导加载程序加载到内存中之后，就可以对文件系统进行查询了，并将默认的内核映像和 initrd 映像（arch/i386/boot/下的setup.S文件）加载到内存中。当这些映像文件准备好之后，阶段 2 的引导加载程序就可以调用内核映像了。

为什么需要加载 initrd 映像（arch/i386/boot/下的setup.S文件），其作用是什么?
i386的体系结构的CPU分保护模式和实模式两种，在实模式下只能使用低端的640K内存。系统在加载引导程序时CPU是处在实模式下，而现在的内核映象文件一般都超过了640K的限制，即使是经过压缩过的内核映象，这个内核映象文件通常是bzImage,我们在编译内核时通常要用到这个文件。由于bzImage超出了640K这一限制，所以linux设计了一个 bootsect_helper子程序(定义在arch/i386/boot/setup.S中)，引导程序通过循环调用bootsect_helper 将内核映象一块一块的装入内存，当内核加载完毕，系统跳转到setup.S的开始位置开始执行，setup.S仍在实模式下运行，主要功能是设置系统参数 (如：内存、磁盘等),并为进入保护模式做准备,最后进入到保护模式并跳转到内核映象文件的头部开始执行内核。

这里提一下有关linux的引导程序 lilo和grub，在 x86 PC 环境中，第一阶段和第二阶段的引导加载程序一起称为 Linux Loader（LILO）或 GRand Unified Bootloader（GRUB）。lilo和grub可以引导多个系统，如果机器上要装多系统的话一般都会用到它们，这一引导程序也储存在引导扇区中或者存放在主引导记录中(MBR)，lilo和grub都许允用户自己配置，它们在系统安装时建立了关于系统内核占用磁盘数据块的位置对照表。当用户选择启动linux系统后，同样也跳转到setup.S上运行。

五、内核初始化

当内核映像被加载到内存中，并且阶段 2 的引导加载程序释放控制权之后，内核阶段就开始了。

head.s中的start（在/arch/i386/boot/下）开始执行一些基本的硬件设置—〉head.S 中的 startup_32 （在/arch/i386/boot/compressed/下）设置一个基本的环境（建立堆栈等），并清除 Block Started by Symbol（BSS）—〉 decompress_kernel （在 /arch/i386/boot/compressed/misc.c 中）来解压内核。—〉head.S（在arch/i386/kernel/下）负责数据区(BBS)、中断描述表(IDT)、段描述表(GDT)、页表和寄存器的初始化。—〉进入start_kernel()（在nit/main.c中）会调用一系列初始化函数来设置中断，执行进一步的内存配置，并加载初始 RAM 磁盘。—〉调用 kernel_thread（在 arch/i386/kernel/process.c 中）来启动 init 内核线程，进行系统配置，创建其他完成系统初始他的进程—〉调用do_basic_setup()来初始化外部设备及加载驱动程序。—〉释放初始化函数据占用的内存—〉打开/dev/console
设备重新定向控制台—〉用系统调用execve来执行用户态程序/sbin/init

注：内核映像并不是一个可执行的内核，而是一个压缩过的内核映像。通常它是一个 zImage（压缩映像，小于 512KB）或一个 bzImage（较大的压缩映像，大于 512KB），它是提前使用 zlib 进行压缩过的。

start_kernel()主要内容：

• setup_arch():执行与体系结构相关的设置
• trap_init():设置各种入口地址
• init_IRQ():初始化IRQ中断处理机制
• sched_init():设置并启动第一个进程init_task()
• softirq_init():对软中断子系统进行初始化
• console_init():初始化控制台、显示器
• init_modules():初始化kernel_module
• fork_init():定义系统最大进程数
• rest_init():调用kernel_thread()创建init内核线程

do_basic_setup()初始化工作包括：

• PCI总线初始化
• 网络初始化
• 文件系统初始化
• 加载文件系统

六、Init

当内核被引导并进行初始化之后，内核就可以启动自己的第一个用户空间应用程序了。这是第一个调用的使用标准 C 库编译的程序。在此之前，还没有执行任何标准的 C 应用程序。

在桌面 Linux 系统上，第一个启动的程序通常是 /sbin/init。init程序程读取/etc/inittab文件来决定它具体的工作。
在inittab中比较重要的几条是：

1. id:5:initdefault 决定操作系统启动时缺省的执行级别(这里说讲的是系统的运行级别，而不同于CPU的级别)
2. si:sysinit:/etc/rc.d/rc.sysinit 执行/etc/rc.d/rc.sysinit的脚本。rc.sysinit主要的工作是 激活交换分区、检查磁盘、加载硬件模块
3. 1:2345:respawn:/sbin/mingetty tty1 显示登录界面

至此，整个系统的引导过程就完成了。

晾下证，真的比院级质量好很多

而客户端只需要一个套接字，用来与与服务器建立连接——ClientSocket。

在这两个套接字中只有ClientSocket需要实现串行化读写信息功能来发送和接收数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//CMessage.h
//封装一个可以串行化的消息类，
//这样消息的发送和接收只需使用流操作符对缓冲区进行存取。
class CMessage : public CObject
{
public:
       void Serialize(CArchive& ar);
 
       CMessage();
       CMessage(int nType);
       CMessage(int nType, CString strBuff, DWORD dwBuffSize);
 
       virtual ~CMessage();
public:
       int m_nType;
 
       CString m_strBuff;
       DWORD m_dwBuffSize;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

//CMessage.cpp
#include "stdafx.h"
#include "Message.h"
 
//默认的构造函数
CMessage::CMessage()
{
       m_nType = -1;
 
       m_strBuff = _T("");
       m_dwBuffSize = 0;
}
 
//只需发送消息类型时使用
CMessage::CMessage(int nType)
{
       m_nType = nType;
 
       m_strBuff = _T("");
       m_dwBuffSize = 0;
}
 
//需要消息内容和长度时使用
CMessage::CMessage(int nType, CString strBuff, DWORD dwBuffSize)
{
       m_nType = nType;
 
       m_strBuff = strBuff;
       m_dwBuffSize = dwBuffSize;
}
 
CMessage::~CMessage()
{
}
 
void CMessage::Serialize(CArchive &ar)
{
       if (ar.IsStoring())
       {
              ar << m_nType;
 
              ar << m_strBuff;
              ar << m_dwBuffSize;
       }
       else
       {
              ar >> m_nType;
 
              ar >> m_strBuff;
              ar >> m_dwBuffSize;
       }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//CListenSocket.h
//CListenSocket服务器用来侦听连接请求的套接字
 
#include "FileTransfersDlg.h"
class CListenSocket : public CSocket
{
public:
       CListenSocket();
       CListenSocket(CFileTransfersDlg* pdlgMain);
       virtual ~CListenSocket();
 
       virtual void OnAccept(int nErrorCode);
 
protected:
       //建立对话框类与套接字类的关联
       CFileTransfersDlg* m_pdlgMain;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// CListenSocket.cpp
 
#include "stdafx.h"
#include "ListenSocket.h"
 
CListenSocket::CListenSocket()
{
       m_pdlgMain = NULL;
}
 
CListenSocket::CListenSocket(CFileTransfersDlg* pdlgMain)
{
       m_pdlgMain = pdlgMain;
}
 
CListenSocket::~CListenSocket()
{
}
 
void CListenSocket::OnAccept(int nErrorCode) 
{       
       m_pdlgMain->ProcessAccept();
       CSocket::OnAccept(nErrorCode);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// CClientSocket.h
//CClientSocket套接字真正与客户端套接字建立连接，用来发送与接收数据
 
#include "FileTransfersDlg.h"
#include "Message.h"
 
class CClientSocket : public CSocket
{
public:
       CClientSocket();
       virtual ~CClientSocket();
 
       void Init();
       void Abort();
 
       BOOL SendMsg(CMessage* pMsg);
       void ReceiveMsg(CMessage* pMsg);
 
       CClientSocket(CFileTransfersDlg* pdlgMain);
       virtual void OnReceive(int nErrorCode);
 
//为套接字添加串行化读写信息的功能
public:
       CSocketFile* m_pFile;
       CArchive* m_pArchiveIn;
       CArchive* m_pArchiveOut;
protected:
       CFileTransfersDlg* m_pdlgMain;
 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

// ClientSocket.cpp
 
#include "stdafx.h"
#include "FileTransfers.h"
#include "ClientSocket.h"
 
CClientSocket::CClientSocket(CFileTransfersDlg* pdlgMain)
{
       m_pdlgMain = pdlgMain;
       m_pFile = NULL;
       m_pArchiveIn = NULL;
       m_pArchiveOut = NULL;
}
 
CClientSocket::CClientSocket()
{
       m_pdlgMain = NULL;
 
       m_pFile = NULL;
       m_pArchiveIn = NULL;
       m_pArchiveOut = NULL;
}
 
CClientSocket::~CClientSocket()
{
}
 
//串行化的初始化
void CClientSocket::Init()
{
       m_pFile = new CSocketFile(this);
       m_pArchiveIn = new CArchive(m_pFile,CArchive::load);
       m_pArchiveOut = new CArchive(m_pFile,CArchive::store);
}
 
void CClientSocket::Abort()
{
       if (m_pArchiveOut != NULL)
       {
              m_pArchiveOut->Abort();
              delete m_pArchiveOut;
              m_pArchiveOut = NULL;
       }
}
 
BOOL CClientSocket::SendMsg(CMessage *pMsg)
{
       if (m_pArchiveOut != NULL)
       {
              TRY
              {
                     pMsg->Serialize(*m_pArchiveOut);
                     m_pArchiveOut->Flush();
 
                     return TRUE;
              }
              CATCH(CFileException, e)
              {
                     m_pArchiveOut->Abort();
                     delete m_pArchiveOut;
                     m_pArchiveOut = NULL;
              }
              END_CATCH
       }
 
       return FALSE;
}
 
void CClientSocket::ReceiveMsg(CMessage *pMsg)
{
       pMsg->Serialize(*m_pArchiveIn);
}
 
void CClientSocket::OnReceive(int nErrorCode) 
{
       m_pdlgMain->ProcessReceive(this);
       CSocket::OnReceive(nErrorCode);
}

简单记录下Radio Button使用方法

有两个Radio Button，一个是IDC_RADIO_SERVER，设置其属性为Group，Auto（有Group属性，说明IDC_RADIO_SERVER是这一组Button的标识）。另一个是IDC_RADIO_CLIENT，设置属性为Auto。这样，使得这两个button为一组

给这一组button关联一个int类型变量：

打开MFC ClassWizard 选择control IDs中的IDC_RADIO_SERVER（IDC_RADIO_CLIENT是看不到的，因为它与IDC_RADIO_SERVER关联起来了），点击Add Variable，添加Member variable name为m_nServerType ，Category：Value ,Varriable type：int。

这时，假设两个button的消息处理函数分别是OnRadioServer()和OnRadioClient()，当点击IDC_RADIO_SERVER时，即触发了OnRadioServer()，则m_nServerType 的值默认设为0。当点击IDC_RADIO_CLIENT时，触发了OnRadioClient()，m_nServerType的值默认设为1。

当在写程序需要判断启动的是哪个服务类型，直接判断m_nServerType的值是0还是1就行了。

电脑刚出现问题是在国庆前。有时候玩着玩着就出现花屏，死机。打电话问了brother，他说可能是你使用方法不当，宿舍断电前电源还插着的话，第二天来电的时候一下子电流太大，损坏电源。我觉得他说的挺有道理，于是乎，在每天晚上睡觉前都不忘关电源（还是有几次忘记了）。

后来情况越来越严重。直到前天用电脑，发现电脑只要一插上电源就出现花屏、死机。但是光用电池就没什么事。暂时只能先充上电用，用完了关机再继续充电，真郁闷......

上网G了下，说是电源适配器的原因，既然是硬件问题那就只能拿去维修了。

周五上完早课，跑去东芝官方指定的维修点。开机看了一下，维修人员说，可能是装系统问题。插上电源，进入BIOS，电脑处于正常运行状态，又排除系统问题。那位哥说要不开机检查下，检查费用是140RMB，那估计就是主板问题，直接换主板一两千，昏，换主板我还不如直接买新的呢。决定还是自己先彻底排除软件问题吧。

brothe说上回他是跑去专卖店修的，换了一小块芯片300RMB。在东芝维修点附近刚好有个东芝专卖店，既然都来了那就试一试吧。那店员检查了一会，终于把软件因素排除了，让我们到他合作的维修点去修。

到了维修点，一说原因，这师傅就知道问题出现在什么地方了，他说遇到东芝这样的情况已经很多了。他的解释是主板上有一小块芯片（用于交流电转换成直流电）坏了，换一块就行了，费用300RMB，保修期一个月，这比所谓的官方维修点有价值多了......直接换，连检查的步骤都省了。

三个小时后去取电脑，检查一切没问题，希望这电脑能用到大四毕业吧，看工作需要再买合适的电脑。

在家“休养生息”，闲来无事看了5本小说，分别如下

《灿烂千阳》、《追风筝的人》这两本书是同个作者——卡勒德·胡赛尼，以阿富汗为背景

《偷书贼》、《真希望我20岁就知道的事》——感觉很一般，估计是翻译的缘故、

《明朝那些事儿》比较喜欢这本，毕竟是国人写的，比较符合中国人的思路，就是相对比较长了点。

看了部连续剧《珠光宝气》粤语版，到了校外听不懂粤语是很悲剧的，所以就拿它来锻炼听力了。现在差不多能听懂70%吧，有空再慢慢学了

我算是宅得够彻底了，就去了趟汕头。不过怎么就见皮肤变白呢。。。。。。

听说Bnuep变化很大，恩，应该越来越贵族化了，回校再一探究竟

我左顾右盼终于等到四级的放榜，434，险过啊，奖学金有望了

准备12月份考CET-6，不过看我这样的水平想过CET-6得花上些功夫才行，加油吧！！！

第一天，黄大仙——紫荆广场——太平山顶——浅水湾——星光大道——维多利亚港，除了维多利亚港，其它景点逗留时间都不超过二十分钟，很小也没什么看头。从珠海九州港乘船出发到达中港城码头，打车到达黄大仙，ps，香港打的超贵。黄大仙很小，不到二十分钟就浏览完了，然后就是紫荆广场，紫荆广场是香港回归的见证地，广场是进不了的，除非你受邀，在紫荆广场外面有朵紫荆花，和这朵花合照下就可以离开了。太平山顶上都是富豪们的住宅，所谓游览太平山顶就是到达山顶的一小块歇脚地，俯瞰香港，留个影。浅水湾其实就是沙滩，人造的，没啥好说的，照个相，闪人。星光大道——名人们留下的手印，找到你的偶像，趴在滚烫的地板上，抚摸下他留下的手印，我不追星，免招这罪了。晚上游维多利亚港，夜景还不错。

听说这朵花超值钱。。。

上面不小心拍到的那对情侣拍照的时候超会摆pos，偷偷观察了他们好久。

第二天，迪斯尼。蛮好玩的，迪斯尼里的游戏不刺激，基本上8岁以上的小孩都能玩，7点离开乐园，看不到晚上的烟花，有点遗憾。

第三天，逛旺仔，接下来这两天我都是一个人独自出门，卓越，莎莎都去了，发现卓越更平民化点，价格比莎莎便宜。发现旺仔这个地方并不适合我逛，因为有几个广场都是可以讲价的那种，我不善于讲价。。。旺仔有一条街都是adidasi，naki，lining，puma，不见得有比大陆便宜。
第四天，逛铜锣湾，铜锣湾有几个大型商场，都是一些大牌子，价格很高。大家都说香港是购物的天地，不得不说，香港是有钱人逛街的天地。除非你买的是国际品牌，For example，LV，香奈儿，这些，在香港买确实会觉得便宜，但是就真维斯，班尼路，naki，阿迪达斯这些低端牌子，还不如在广州，深圳便宜。

晚上八点多从深圳皇岗口岸出境，本来打算在免税商场买两瓶洋酒回家。但是朋友刚好有车可以接送，在车上检查证件直接出境，没有机会让我下车购买。。。。。亏死我了

总的感觉，香港很小，除了逛街、迪斯尼没啥好玩的，消费水平很高。

这次出去纯粹为了放松心情，所以没去shoping，找了个可以散步的地方顺便拍拍照留念下——园博圆。那里蚊子好多啊，刚好穿着七分裤，可怜我的手脚起了好多包，现在还痒。我觉得网上应该提供这样的信息，蚊子很多，请游客们自带驱蚊剂~~~

call妹家有单反，太沉了，不想带，so，我的小8派上用场了

园博圆的logo

纯属无聊

第一次遇到这么空的地铁

迫于设备太差，想买单片机，佳能的，不知道大家有没好的建议？

感谢call家、m姐妹这两天的款待。ps：再过几天是call妹的生日了，顺祝你生日快乐哦。

接下来是CET4和期末考试，该是好好准备的时候了，我一定要一次过CET4，还有我的奖学金！

【问题描述】
几十年前全世界就流行一种数字游戏，至今仍有人乐此不疲．在中国我们把这种游戏称为“算24点”。您作为游戏者将得到4个1~9之间的自然数作为操作数，而您的任务是对这4个操作数进行适当的算术运算，要求运算结果等于24。

您可以使用的运算只有：+，-，*，/，您还可以使用（）来改变运算顺序。注意：所有的中间结果须是整数，所以一些除法运算是不允许的（例如，(2*2)/4是合法的，2*(2/4)是不合法的）。下面我们给出一个游戏的具体例子：

若给出的4个操作数是：1、2、3、7，则一种可能的解答是1+2+3*7=24。

【输入】

只有一行，四个1到9之间的自然数。

【输出】

如果有解的话，只要输出一个解，输出的是三行数据，分别表示运算的步骤。其中第一行是输入的两个数和一个运算符和运算后的结果，第二行是第一行的结果和一个输入的数据、运算符、运算后的结果；第三行是第二行的结果和输入的一个数、运算符和“=24”。如果两个操作数有大小的话则先输出大的。

如果没有解则输出“No answer!”

【输入样例】
1 2 3 7

【输出样例】
2+1=3
7*3=21
21+3=24

解题思路：

这道题的目的是求出四个数所有的组合运算的结果，满足24点就输出。
首先我们应该找出这四个数的所有排列顺序，再按已经排好的顺便进行加、减、乘、除运算，结果是24点，就输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

#include<stdio.h>
 
int x[100];
//保存四个数的所有组合 
int arrange[100][100];
//保存读入的四个数 
int num[100];
//标记该数是否被访问过 
int a[100] = {0};
 
char sym[5]={'0','+','-','*','/'};
//保存使用的算术运算符 
int bol[100];
// 标记运算符是否被访问过 
int b[100]={0};
 
//保存四个数的组合总数 
int sum = 0;
int n,r;
int ok=1;
 
//保存所有可能的组合数 
void save(int sum)
{
    int i;
    for(i=0;i<4;++i)
    {
        arrange[sum][i] = x[i];
 
    }
}
 
 
//判断使用该运算符是否合法 
int symbollegal(int t,int i,int sum,int layer)
{
    switch(i)
    {
    case 1:
        if(arrange[layer][t]+sum>24)
            return 0;
        else return arrange[layer][t]+sum;
    case 2:
        if(sum-arrange[layer][t]<0)
            return 0;
        else return sum-arrange[layer][t];
    case 3:
        if(arrange[layer][t]*sum>24)
            return 0;
        else return arrange[layer][t]*sum;
    case 4:
        if(arrange[layer][t]!=0&&sum%arrange[layer][t]!=0)
            return 0;
        else return sum/arrange[layer][t];
 
    }
}
// 打印结果 
void pri(int layer)
{
    int i,temp;
    int totle = arrange[layer][0];
    for(i= 1;i<=3;++i)
    {
        if(totle > arrange[layer][i])
        {
            temp = symbollegal(i,bol[i],totle,layer);
            printf("%d %c %d = %d\n",totle,sym[bol[i]],arrange[layer][i],temp);
        }
        else
        {
            temp = symbollegal(i,bol[i],totle,layer);
            printf("%d %c %d = %d\n",arrange[layer][i],sym[bol[i]],totle,temp);
        }
        totle = temp;
 
    }
    printf("\n");
}
 
//回溯计算四个组合数出现的情况 
void backtrack(int t)
{
    int i;
    //遍历四个数 
    for(i = 1;i<= 4;++i)
    {
        x[t] = num[i];
        //如果当前这个数没有被选择  
        if(a[i]==0)
        {
            //标记该数已经选择 
            a[i] = 1;
            //结束条件：已经找到符合条件的四个数 
            if(t == 3 )
            {
                save(sum);
                ++sum;
 
            }
            else
            {
                backtrack(t+1);     
            }
            //不符合条件，恢复该数的访问权限 
            a[i] = 0;
        }
    }
}
 
// 计算该组合数能得出24的情况 
void find(int sum,int t,int layer)
{
    int i,temp,sign;
    //遍历加、减、乘、除四个符合 
    for(i=1;i<=4;++i)
    {
        bol[t] = i;
        //如果选择的符号满足条件 
        if( (temp = symbollegal(t,i,sum,layer)))
        {
            //标记该符号已经选择并修改sum值 
            b[i] = 1;
            sign = sum;
            sum = temp;
            //结束条件：四个数都已经完成运算 
            if(t == 3)
            {
                //结果是24点，则打印 
                if(sum==24)
                {
                    ok=0;
                    pri(layer);
                }
            }
            else
            {
                find(sum,t+1,layer);
            }
            //不符合条件，恢复该符号的访问权限与sum的值 
            b[i] = 0;
            sum = sign;
        }
    }
}
int main()
{
    int i,j;
    for(i=1;i<=4;++i)
        scanf("%d",&num[i]);
    backtrack(0);
    // 遍历所有的组合数 
    for(i=0;i<sum;++i)
    {
        find(arrange[i][0],1,i);
    }
    if(ok)
    {
        printf("No answer!\n");
    }
    system("pause");
    return 0;
}

Description

Keeping track of all the cows can be a tricky task so Farmer John has installed a system to automate it. He has installed on each cow an electronic ID tag that the system will read as the cows pass by a scanner. Each ID tag's contents are currently a single string with length M (1 ≤ M ≤ 2,000) characters drawn from an alphabet of N (1 ≤ N ≤ 26) different symbols (namely, the lower-case roman alphabet).

Cows, being the mischievous creatures they are, sometimes try to spoof the system by walking backwards. While a cow whose ID is "abcba" would read the same no matter which direction the she walks, a cow with the ID "abcb" can potentially register as two different IDs ("abcb" and "bcba").

FJ would like to change the cows's ID tags so they read the same no matter which direction the cow walks by. For example, "abcb" can be changed by adding "a" at the end to form "abcba" so that the ID is palindromic (reads the same forwards and backwards). Some other ways to change the ID to be palindromic are include adding the three letters "bcb" to the begining to yield the ID "bcbabcb" or removing the letter "a" to yield the ID "bcb". One can add or remove characters at any location in the string yielding a string longer or shorter than the original string.

Unfortunately as the ID tags are electronic, each character insertion or deletion has a cost (0 ≤ cost ≤ 10,000) which varies depending on exactly which character value to be added or deleted. Given the content of a cow's ID tag and the cost of inserting or deleting each of the alphabet's characters, find the minimum cost to change the ID tag so it satisfies FJ's requirements. An empty ID tag is considered to satisfy the requirements of reading the same forward and backward. Only letters with associated costs can be added to a string.

Input

Line 1: Two space-separated integers: N and M
Line 2: This line contains exactly M characters which constitute the initial ID string
Lines 3..N+2: Each line contains three space-separated entities: a character of the input alphabet and two integers which are respectively the cost of adding and deleting that character.

Output

Line 1: A single line with a single integer that is the minimum cost to change the given name tag.

Sample Input

3 4
abcb
a 1000 1100
b 350 700
c 200 800

Sample Output

900

题目大意：
长度为M的字符串，可以增加或删除字符，使其构成回文，增加或删除不同的字符有不同的花费，求最小花费。

解题思路：

f[i,j]表示在i，j区间内构成回文数的最小花费。

如果str[i]!=str[j],有四种情况可构成回文数，在f[i,j-1]添加或删除str[i]和在f[i-1,j]添加或删除str[j]。添加和删除性质是一样的，选择添加还是删除取决于两者的花费大小，因此在保存字母花费值时，只需保存较小的。这样只要在f[i,j-1]+cost[str[j]]和f[i+1,j]+cost[str[i]]选择最小，问题就解决了。

如果str[i]=str[j]，那么有两种情况构成回文数，即字符串保持不变和删除第i和第j个，也就是选择f[i,j]与f[i+1,j-1]中的最小值

动态转移方程：

f[i,j]= min{f[i,j-1]+cost[str[j]],f[i+1,j]+cost[str[i]]} ; str[i]!=str[j]
f[i,j] = min{f[i,j],f[i+1,j-1]}                                    ; str[i] =str[j]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>
#include <string>
 
using namespace std;
 
const int size = 2005;
int f[size][size] = {0};
 
int main()
{
    int n,m,add,cut;
    char s;
    string str;
    int cost[150];    
    cin>>n>>m;
    cin>>str;
    for (int i=0;i<n;++i)
    {
        cin>>s>>add>>cut;
        if (add>cut)
        {
            cost[s] = cut;
        }
        else cost[s] = add;
    }
    for (int j=0;j<m;++j)
    {
        for (int i =j-1;i>=0;--i)
        {
            if (f[i][j-1]+cost[str[j]]>f[i+1][j]+cost[str[i]])
            {
                f[i][j] = f[i+1][j]+cost[str[i]];
            }
            else f[i][j] = f[i][j-1]+cost[str[j]];
 
            if (str[i]==str[j]&&f[i][j]>f[i+1][j-1])
            {
                f[i][j] = f[i+1][j-1];
            }
        }
    }
    cout<< f[0][m-1] <<endl;
    return 0;
}

Description

........7
......3   8
....8   1   0
..2   7   4   4
4   5   2   6   5

Figure 1 shows a number triangle. Write a program that calculates the highest sum of numbers passed on a route that starts at the top and ends somewhere on the base. Each step can go either diagonally down to the left or diagonally down to the right.

Input

Your program is to read from standard input. The first line contains one integer N: the number of rows in the triangle. The following N lines describe the data of the triangle. The number of rows in the triangle is > 1 but <= 100. The numbers in the triangle, all integers, are between 0 and 99.

Output

Your program is to write to standard output. The highest sum is written as an integer.

Sample Input

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

Sample Output

30

题目大意：

给定一个具有N层的数字三角形，从顶至底有多条路径，每一步可沿左斜线向下或沿右斜线向下，路径所经过的数字之和为路径得分，请求出最大路径得分。

状态转移方程:

f[k] = max{f[k+i+1],f[k+i]}

f[k]表示第k个数字到最底部的最大路径之和，i表示第i层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include<stdio.h>
 
int main()
{
    int n,k,i,j,sum,f[10010];
    scanf("%d",&n);
    sum = (n*n+n)/2;
    k = sum-n;
    for(i = 1;i<=sum;++i)
    {
        scanf("%d",&f[i]);
    }
 
    for(i=n-1;i>=1;--i)
    {
        for(j=1;j<=i;++j)
        {
            //找出第k个数字到底部的最短路径得分 
            if(f[k+i]<f[k+i+1])
            {
                f[k] += f[k+i+1];
            }
            else 
            {
                f[k] += f[k+i];
            }
            --k;
        }
 
    }
    printf("%d\n",f[1]);
    system("pause");
    return 0;
}

吃完早餐，前往漓江，乘竹筏观赏——“桂林山水甲天下 ，阳朔山水甲桂林，群山倒水山浮影，无山无水不入神”。

我还是喜欢使用船桨划动的竹筏。发动机的汽油味让我感到很不舒服。

下午参观了银子岩

银子岩贯穿于十二座山峰，属层楼式溶洞，现已开发游程约2000米，分为下洞、大厅、上洞三个部分，汇集了不同地质年代发育生长的钟乳石，像银子、似钻石，晶莹剔透、雄奇幽美。特色景点数十个，以音乐石屏、瑶池仙境、雪山飞瀑“三绝”和佛祖论经、独柱擎天、混元珍珠伞 “三宝”等为代表，让您领略到大自然的鬼斧神工。被法国地质岩溶专家誉为“世界溶洞奇观”。

我觉得这混元珍珠伞更像一种海鱼

第二天，从旅店出发，骑单车前往图腾古道，位于广西壮族自治区桂林市阳朔县著名的“十里画廊”中，属国家AAA级旅游区。

图腾古道景区展出的有石器、陶器、自然图腾柱、古老的弓弩、让人听不懂念念有词充满野性诱惑的肢体语言等原始生活场景，再现了反映了12000-7000年前桂林先民甄皮岩人居住、生活、宗教、狩猎和墓穴文化。

最后一个景点区——大榕树，相传是广西壮族歌仙留三姐与情人阿牛哥的定情处。

在寺庙里拿了生肖符，许了个愿。其实大榕树没什么看头

留了个Logo

ps：阳朔——减肥之旅，意外生病。

1
2
3
4
5
6
7
8
9
10
11
12
13

//comple.h
class comple
{
    friend comple operator+(const comple& lhs,const comple& rhs);
public:
    comple(void);
    comple(int);
    ~comple();
    comple(const comple& orig);
private:
    int real;
 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

//comple.cpp
#include "stdafx.h"
#include <iostream>
#include "comple.h"
using namespace std;
comple::comple( void )
:real(0)
{
    cout<<this <<" of "<<this->real <<" constructor is called"<<endl;
 
}
 
comple::comple( int a)
:real(a)
{
    cout<<this <<" of "<<this->real<<" constructor is called"<<endl;
 
}
 
comple::comple( const comple& orig )
{
    cout<<this <<" of "<<orig.real<<" assignment is called"<<endl;
    this->real = orig.real;
}
comple::~comple()
{
    cout<<this <<" of "<<this->real<<" destructor is called"<<endl;
 
 
}
comple operator+(const comple& lhs,const comple& rhs)
{
    cout<< "operator+ is called"<<endl;
    comple a(lhs.real+rhs.real);
    return a;
}

1
2
3
4
5
6
7
8
9
10
11
12

//main.cpp
#include "stdafx.h"
#include "comple.h"
#include <iostream>
 
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
    comple a(2);
    a+5;
    return 0;
}

程序输出

001CFB90 of 2 constructor is called
001CFAAC of 5 constructor is called
operator+ is called
001CFA70 of 7 constructor is called
001CFAB8 of 7 assignment is called
001CFA70 of 7 destructor is called
001CFAB8 of 7 destructor is called
001CFAAC of 5 destructor is called
001CFB90 of 2 destructor is called

解释下这个程序的执行过程：首先调用带int的构造函数，然后执行a+5时，编译器会自动调用带int的构造函数对5进行隐式转化。接下来调用operater+，在这个函数中实例化了一个匿名对象，并将该对象复制一份返回。该函数结束后销毁局部栈上的变量，首先销毁复制的实例，再销毁匿名实例（先进后出）。程序结束后，销毁在本地栈上的元素。

能不能在comple后面加&，即返回comple的引用。这样做是不行的，因为a是在局部栈上创建的变量，当该函数结束时，局部栈被销毁，即a被销毁，那么返回的对象将指向未知的内存；

如果变量是创建在堆上，那么可以返回该变量的引用，因为堆上的变量时需要程序员手动销毁的。

Description

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。
现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。
有人用两种说法对这N个动物所构成的食物链关系进行描述：
第一种说法是"1 X Y"，表示X和Y是同类。
第二种说法是"2 X Y"，表示X吃Y。
此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。
1） 当前的话与前面的某些真的话冲突，就是假话；
2） 当前的话中X或Y比N大，就是假话；
3） 当前的话表示X吃X，就是假话。
你的任务是根据给定的N（1 <= N <= 50,000）和K句话（0 <= K <= 100,000），输出假话的总数。

Input

第一行是两个整数N和K，以一个空格分隔。
以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。
若D=1，则表示X和Y是同类。
若D=2，则表示X吃Y。

Output
只有一个整数，表示假话的数目。

Sample Input

100 7
1 101 1
2 1 2
2 2 3
2 3 3
1 1 3
2 3 1
1 5 5

Sample Output

3

注：

rank[x]   表示x与father[x]的关系：

rank[x] == 0 表示x与 father[x] 是同类

rank[x] == 1 表示x吃 father[x]

rank[x] == 0 表示 father[x] 吃x

A吃B， B吃C，C吃A的关系可用矩阵表示如下

A B C
A 0  1  2
B  2  0  1
C  1  2  0

A吃B，即B是A的食物，假设 B为A的父节点，那么rank[A] = 1；

即 rank[A] = (rank[B] - rank[A] +3 +relation) %3 (relation 为B与A之间的关系)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include<stdio.h>
#define MAX 50005
 
void Make_Sent(int x);
int Find_set(int x);
void Union(int x,int y,int d);
 
int father[MAX];
int rank[MAX];
int main()
{
    int totle=0;
    int i,n,k,x,y,d,xf,yf;
    scanf("%d%d",&n,&k);
    for(i=1;i<=n;++i)
    {
        Make_Sent(i);
    }
    while(k--)
    {
        scanf("%d%d%d",&d,&x,&y);
        //如果x或y比n大，或x吃x，是假话 
        if(x>n||y>n||(d==2 && x == y))
        {
            ++totle;                 
        }
        else
        {
            xf = Find_set(x);
            yf = Find_set(y);
            //如果x，f的父节点相同 ，那么可以判断给出的关系是否正确的 
            if(xf == yf)
            {
                if((rank[x]-rank[y]+3)%3 != d-1)
                    ++totle;                              
            }
            else
            {
                //否则合并x，y 
                Union(x,y,d-1);
            }
        }
    }
    printf("%d\n",totle);
    //system("pause");
}
 
//初始化集合 
void Make_Sent(int x)
{
    father[x]=x;
    rank[x]=0;
}
 
//查找x的集合，回溯时压缩路径，并修改x与father[x]的关系 
int Find_set(int x)
{
    int t; 
    if(x!=father[x])
    {
        t = father[x];
        father[x]= Find_set(father[x]);
        //更新x与father[X]的关系 
        rank[x] = (rank[x]+rank[t])%3;
    }
    return father[x];
}
//合并x,y所在的集合 
void Union(int x,int y,int d)
{
    int xf = Find_set(x);
    int yf = Find_set(y);
    //将集合xf合并到yf集合上 
    father[xf] = yf;
    //更新 xf 与father[xf]的关系 
    rank[xf]=(rank[y]-rank[x]+3+d)%3;
}

Description

There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of four adjacent tiles. But he can't move on red tiles, he can move only on black tiles.

Write a program to count the number of black tiles which he can reach by repeating the moves described above.

Input
The input consists of multiple data sets. A data set starts with a line containing two positive integers W and H; W and H are the numbers of tiles in the x- and y- directions, respectively. W and H are not more than 20.

There are H more lines in the data set, each of which includes W characters. Each character represents the color of a tile as follows.

'.' - a black tile
'#' - a red tile
'@' - a man on a black tile(appears exactly once in a data set)
The end of the input is indicated by a line consisting of two zeros.

Output

For each data set, your program should output a line which contains the number of tiles he can reach from the initial tile (including itself).

Sample Input

6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
...@...
###.###
..#.#..
..#.#..
0 0

Sample Output

45
59
6
13

题意：一个矩阵，‘#’表示砖块不能走，‘.’表示此砖块可走，问从‘@’处出发，有多少砖块能走（遍历到）

解题思路：广度搜索；向四个方向搜，已搜过的砖块需要标记下，不能重复计算走过的砖块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#include <iostream>
using namespace std;
 
char a[21][21];
int w,h;
 
int  find(int x,int y);
 
int main()
{
 
    while(1)
    {
        cin>>w>>h;
        if (w==0 || h ==0)
        {
            break;
        }
        for (int i=0;i<h;++i)
        {
            cin>>a[i];
        }
        for(int i = 0;i<h;++i)
        {
            for(int j = 0;j<w;++j)
            {
                if (a[i][j]=='@')
                {
                    printf("%d\n",find(i,j));
                }
            }
        }
    }
    return 0;
}
 
//bfs运用
int  find(int x,int y)
{
    //如果x,y超出矩阵范围，结束递归
    if (x<0 || x>=h || y<0 || y>=w)
    {
        return 0;
    }
    //遇到红色块，结束递归
    if (a[x][y]=='#')
    {
        return 0;
    }
    else
    {
        //标记当前砖块已走过
        a[x][y]='#';
        //分别向四个方面搜索
        return 1+find(x+1,y)+find(x-1,y)+find(x,y+1)+find(x,y-1);
    }
}

There is a pile of n wooden sticks. The length and weight of each stick are known in advance. The sticks are to be processed by a woodworking machine in one by one fashion. It needs some time, called setup time, for the machine to prepare processing a stick. The setup times are associated with cleaning operations and changing tools and shapes in the machine. The setup times of the woodworking machine are given as follows:
(a) The setup time for the first wooden stick is 1 minute.
(b) Right after processing a stick of length l and weight w , the machine will need no setup time for a stick of length l' and weight w' if l <= l' and w <= w'. Otherwise, it will need 1 minute for setup.
You are to find the minimum setup time to process a given pile of n wooden sticks. For example, if you have five sticks whose pairs of length and weight are ( 9 , 4 ) , ( 2 , 5 ) , ( 1 , 2 ) , ( 5 , 3 ) , and ( 4 , 1 ) , then the minimum setup time should be 2 minutes since there is a sequence of pairs ( 4 , 1 ) , ( 5 , 3 ) , ( 9 , 4 ) , ( 1 , 2 ) , ( 2 , 5 ) .

Input

The input consists of T test cases. The number of test cases (T) is given in the first line of the input file. Each test case consists of two lines: The first line has an integer n , 1 <= n <= 5000 , that represents the number of wooden sticks in the test case, and the second line contains 2n positive integers l1 , w1 , l2 , w2 ,..., ln , wn , each of magnitude at most 10000 , where li and wi are the length and weight of the i th wooden stick, respectively. The 2n integers are delimited by one or more spaces.

Output

The output should contain the minimum setup time in minutes, one per line.

Sample Input

3
5
4 9 5 2 2 1 3 5 1 4
3
2 2 1 1 2 2
3
1 3 2 2 3 1

Sample Output

2
1
3

题意：

有n根木棍，每根木棍有不同的长度和重量。用一台机器来处理这些木棍，当第i+1根木棍的长度>=第i根木棍的长度 && 第i+1根木棍的重量>=第i根木棍的重量时，机器处理木棍的单位时间setup time加1，求出处理完n根木棍所需要的最少时间

解题思路：

按木棍的长度从小到大排序，当木棍长度相等时，按重量小到大排序。然后依次选择比当前长度大的木棍（已经对木棍进行排序，每次选择都是对后面影响最小的），对选过的木棍进行标记。一轮之后，setup time+1，再对剩下的木棍进行选择，即可得到最优解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#include <iostream>
using namespace std;
 
int work(int m);
struct wood   
{
    int l;
    int w;
}st[5005];
 
//比较函数
int cmp(const void *a ,const void *b)
{
    if((*(wood *)a).l==(*(wood*)b).l)
        return (*(wood *)a).w -(*(wood *)b).w;
    return (*(wood *)a).l - (*(wood *)b).l;
}
 
int main()
{
    int n,m;
    cin>>n;
    while (n--)
    {
        cin>>m;
        for (int i=0;i<m;++i)
        {
            cin>>st[i].l>>st[i].w;
        }
        qsort(st,m,sizeof(st[0]),cmp);
        cout<<work(m)<<endl;
    }
    return 0;
}
 
 
int work(int m)
{
    int temp;
    int sum=0;
    for (int i =0;i<m;++i)
    {
        if (st[i].w!=-1)
        {
            temp = st[i].w;
            sum++;
            for (int j=i+1;j<m;++j)
            {
                if (st[j].w>=temp)
                {
                    temp=st[j].w;
                    st[j].w=-1;
                }
            }
        }
    }
    return sum;
}

思想：用快速排序定位数组中其中一个元素a按从小到大确定它在数组中的位置temp

当temp等于k时，那么这个元素就是我们要找的第k个大的元素

当temp大于k时，说明第k大的元素一定在a元素的左边，向左缩小查找范围

当temp小于k时，说明第k大的元素一定在a元素的右边，向右缩小查找范围

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#include "stdafx.h"
#include <iostream>
using namespace std;
 
int quickSort(int *a,int left,int right);
int search(int *a,int i,int j,int k);
 
//主函数
int _tmain(int argc, _TCHAR* argv[])
{
     int n,k_max;
     int a[100];
     cin >> n ;
 
     for (int i = 1; i <= n; ++i)
     {     
          cin >> a[i];
     }
     cin >> k_max;
     cout << search(a,1,n,k_max)<<endl;
 
     return 0;
}
 
//一次快速排序，返回被定位元素的位置
int quickSort(int *a,int left,int right)
{
     int i,j,temp;
     i=left;
     j=right;
     temp=a[left];
     if(left>right)
          return -1;
     while(i!=j)
     {
          while(a[j]>=temp && j>i)
               j--;
          if(j>i)
               a[i++]=a[j];
          while(a[i]<=temp && j>i)
               i++;
          if(j>i)
               a[j--]=a[i];
 
     }
     a[i]=temp;
     return i;
}
 
//分治查找第k大的元素
int search(int *a,int i,int j,int k)
{
     int temp;
     if (j < i)
     {
          return -1;
     }
     if (i == j)
     {
          return a[i];
     }
     //得到第i个元素被定位的下标
     temp = quickSort(a,i,j);
     //相等说明找到第k个大的元素
     if (temp == k)
     {
          return a[k];
     }
     //比k大，往左缩小查找范围
     else if (temp > k )
     {
          return search(a,i,temp-1,k);
     }
     //比k大，往右缩小超找范围
     else 
     {
          return search(a,temp+1,j,k-temp);
     }
}

本地主机的用户名是joan1和joan2，根文件夹分别是/home/joan1/www，/home/joan2/ww，IP是192.168.106.130，选择使用vsftpd这个软件，下面这些命令要求你拥有root权限

1：安装vsftpd软件

apt-get install vsftpd

2：编辑/etc/vsftpd.conf文件

vi /etc/vsftpd.conf

按‘i’，进入编辑状态

3：修改文本参数值

不让匿名用户使用，在anonymous_enable=YES 前加‘#’

本地用户可用，去掉#local_enable=YES 前的‘#’

允许进行读写操作，去掉#write_enable=YES 前的‘#’

显示登录到ftp的提示，去掉#ftpd_banner=Welcome to blah FTP service 前的‘#’

限制用户浏览的目录，一般我们只允许他在自家目录下乱窜，那么就需要启动chroot列表，去掉#chroot_list_enable=YES 前加‘#’

指定chroot列表位置，去掉#chroot_list_file=/etc/vsftpd.chroot_list 前‘#’

更改用户的根目录，默认的根目录是此时登陆ftp用户的家目录，在文件最后一行加入 ，user_config_dir=/etc/local_root

4：保存修改，退出

依次按‘Esc’‘：’‘w’‘q’

5：新建/etc/vsftpd.chroot_list 文件，列出所要限制用户浏览文件的用户名

vi /etc/vsftpd.chroot_list ，然后按‘i’

输入

joan1

joan2

保存修改，退出

5：新建文件夹 ，以确定ftp用户所在的根目录

mkdir /etc/local_root

新建以用户名命名的文件，（这里有两个用户，所以重复两次操作）

vi /etc/local_root/joan1，然后按‘i’

输入

local_root=/home/joan1/www

保存修改，退出

vi /etc/local_root/joan2，然后按‘i’

输入

local_root=/home/joan2/www

保存修改，退出

7：修改文件夹的权限，使拥有修改权限

chmod 777 /home/joan1/www

chmod 777 /home/joan2/www

8：重新启动ftp服务（这一步很重要）

/etc/init.d/vsftpd restart

9：测试设置是否成功

ftp 192.168.106.130

输入你的用户名和密码

看到提示 230 Login successful......那就对了

1：编辑/etc/hosts文件

vi /etc/hosts

然后按‘i’键

2：添加主机名

在127.0.0.1       localhost 的下一行添加

192.168.106.130 www.joan1.com

192.168.106.130 www.joan2.com

3:保存修改，退出

依次按’Esc’，‘:’，’w ’，‘q‘

4：打开/etc/apache2/httpd.conf 用户配置文件

vi /etc/apache2/httpd.conf

然后按’i‘键

如果你一安装完什么都没干的话，应该是个空文件

5：修改文件。直接复制以下代码到文件中就行啦

1
2
3
4
5
6
7
8
9
10
11
12

#NameVirtualHost apache虚拟主机的ip
#ServerName 网站名称
#DocumentRoot 网站文件存放目录
NameVirtualHost 192.168.106.130
<VirtualHost www.joan1.com>
	ServerName www.joan1.com:80
	DocumentRoot /home/joan1
</VirtualHost>
<VirtualHost www.joansky.com>
	ServerName www.joan2.com:80
	DocumentRoot /home/joan2
</VirtualHost>

6：保存修改，退出

依次按’Esc’，‘:’，’w ’，‘q‘

7：重启apache

/etc/init.d/apache2 restart

8：写测试文件。在已有的/home/joan1，/home/joan2 的目录下写测试文件

呃，这里直接复制文件了

cp /var/www/index.html /home/joan1/demo1.html

cp /var/www/index.html /home/joan2/demo2.html

9:测试是否成功设置

w3m http://www.joan1.com/demo1.html

w3m http://www.joan2.com/demo2.html

当你看到两个网页都显示This is the default web page for this server......那就说明大功告成了

/etc/apache2 是apache2配置文件目录

apache2.conf主配置文件

httpd.conf 用户配置文件

sites-enabled 虚拟主机配置文件

下面这些指令是用来设置Apache2的虚拟主机，使其Ip与主机名字（假设要设置的主机名是 www.joan.com）对应，更改网页文件存放目录（假设要更改为 /home/joan），使用下面命令的前提，你拥有root权限，已安装了apache2

1：编辑/etc/hosts

vi /etc/hosts

然后按‘i’键

2：将主机名写入/etc/hosts 文件中

在127.0.0.1       localhost 的下一行添加  127.0.0.1 www.joan1.com

3：保存修改，退出

依次按’Esc’，‘:’，’w ’，‘q‘

4：编辑 /etc/apache2/sites-enabled /default 文件

vi /etc/apache2/sites-available/default

然后按 ’i’ 键

3：增加主机名字项

在ServerAdmin webmaster@localhost 的下一行添加 ServerName www.joan.com

4：修改网站文件存放目录

DocumentRoot /var/www 改为 DocumentRoot /home/joan

<Directory /var/www> 改为 <Directory /home/joan>

5:保存修改，退出

依次按’Esc’，‘:’，’w ’，‘q‘

6：重启Apache2（这一步很重要，不要忘）

/etc/init.d/apache2 restart

7:写测试文件。比较懒，直接复制了

cp /var/www/index.html /home/joan/demo.html

8：测试修改是否成功

w3m http://www.joan.com/demo.html

能看到 This is the default web page for this server.....那就说明设置成功啦

放假前打算学下Linux。呃，回到家啥计划都是假的，学习效率很低，回校再继续看了。

再次签了香港通行证，琢磨着下学期找个时间玩玩。上次去澳门玩得稀里糊涂的，去香港之前可得好好计划下。

配了副隐形眼镜。大一的时候就想去弄副隐形眼镜了，可家人一直说隐形眼镜不安全不让我戴，一直拖到现在。隐形眼镜还真难戴，在那里试了40分钟左右才成功戴上，那个服务员也还真有耐心。

花了￥450买了一个320G的笔记本硬盘。

跟朋友聚聚。今年的班级聚会只有一个，高三的，依旧没去。到现在只要是班级聚会我都没理睬，恩，不喜欢群聚。

这个寒假很无聊，没啥可说的。恩，明天坐包车回校。这回宿舍轮我最早回。

一开始觉得大家每天上网都在浏览各式各样的网页，带着好奇心想从网页制作入手。朋友给我指点了入门之道，先让我熟悉Dreamweaver的使用，了解网站设计与建设的基本知识。大一下学期选了火爷的网站设计与制作的课，火爷讲的东西与实际互联网上的网页根本不是一回事，但当是一次“扫盲”活动吧。

想要做出符合3WC标准的网页，学CSS是必不可少的，于是我又开始研究起CSS来，在网上买了本《CSS商业网站布局之道》。当自己想练习写一个简单漂亮的网站出来时，需要一些图片的搭配，可网上找的图片都不符合自己要求，朋友也想让我学PS帮他做logo，于是乎，我把css丢在一边，开始学起ps。到现在我都很羡慕那些能做出精美图片的人，原因很简单，我的审美很差，一个看似简单的东西，但是就是调不出那种我要的效果——对颜色的把握不好。

而后，我把焦点转到了编程上，无论是培养一个人的思维方式还是提高对编程的熟练度和算法的运用，编程在计算机专业有着举足轻重的地位。开始在poj上刷题，刷到现在是60多道。其实刷题还有一个原因，那就是我想参加珠海赛，但当得知参加珠海赛的队伍有能力去参加省赛时队伍的成员是不能改变的，我就开始纠结了，跟我组队的成员肯定能参加省赛，参加省赛意味着我必须接受长达4个月的训练，且我又不想扎根于编程中，毕竟我的方向不在编程上。

恩，继续转移学习的方向——PHP与数据库的操作，因为之前无聊的时候看过关于php的书，只是缺乏动手经验，所以刚开始写些小小的程序还是比较容易的。朋友的主意比较多，让我写些符合他要求的小程序，他的要求刚好在我的能力范围内，也能让我逐渐接触新知识。我现在学会的也只是对PHP跟数据库最基本的运用。

从网页——PS——编程——PHP与数据库，每一门都是刚刚入门然后就放弃，于是我成了那种啥也了解一点，但是啥也不精。还有半年的时间让我鼓捣我感兴趣的东西，因为大三的时候或许会更早，开始学网络方面的东西。我要把重点学习的东西放在PHP和数据库上，半年时间肯定不能让我成为什么php大师，但是起码应该做到脱掉菜鸟称号吧。

2010年已经起航，希望在这一年能有更大的进步。

粗心，是我的一个最大缺点 。

去年的新生赛B题就因为没仔细看题，没理解清题意，就在那做题，结局肯定很悲剧的。这次依旧，看题不仔细，做出来不检查就想直接提交通过。

A题，输出的时候没有多加中括号，加了中括号后，判断输出时还写错，交了3次才过。E 题，开始提交的时候没有写头函数，第二次提交发现多加了system("pause");，改过来后提交发现答案错误，检查发现没加'\0'，觉得加了' \0'应该对了，于是就赶紧提交，其实这连样例输出都没过，因为我直接把输出的字符串检查略过，看最后统计的结果，连交了5次，还是没A掉。比赛结束后，朋友跟我说你是不是看题又不仔细，没看到这里有“（如果两个字符串完全相同的情况就不叫山寨）”，恩，我再次悲剧了。一开始看题是仔细看了，看到做题的时候就把这条件给忘了。

还发现，无论看什么东西，很容易跳过符号，即算看了也压根没引起重视。

不能老在同一地方跌倒，吸取教训~~

好像这是最后一届女生赛，发下图片记录下

白天没时间看蜗居，一般都是宿舍断网后开始看，看到本没电就去睡觉，终于把蜗居看完。

给人议论最多的是海藻跟宋思明，在我看来，我对海藻的做法很不齿，借个6万就觉得自己欠人家很多，自己还不了，得用肉体还。。。跟着宋思明出入高级餐厅，打扮得跟贵妇一样，慢慢的习惯宋思明给的这些荣耀，步入二奶行列，海藻口口声声说她是爱宋思明的，我倒不见得，见了几次面，连身子都献出去，这里面真的有爱吗，结局的时候，海藻潜意识里想的都是小贝。海萍说得对了，海藻不过是被宋头上的光环迷恋住了。

我的室友整天都说，“以后找老公一定要找个有钱的，要不是我现在没碰到比他更好的，我早把他甩了”。一个多么现实的女生，是的，她的想法并没有错，每个人都想有个美好的未来，美好是建立金钱基础上的。当女人把未来放在男人身上时，找个有钱的老公比找个真正爱自己关心自己的人重要得多了。

宋思明很聪明，很有远见，也很有才能，宋思明能制服海藻也算很正常。见到一个男生的个性签名写着这样一句话“做人要做宋思明”，的确，虽然宋的结局是悲剧的，但是现在一个80后的男人能有宋的一切，那么他就算是很成功了。

其实我觉得小贝要比宋悲剧得多了，一个对海藻如此付出的人，却因为物质条件差而失去爱情。恩，现实生活中的“小贝”应该不少，因为生活中存在着太多的“海藻”。

蜗居其实是围绕着房子展开的，一切都是因房子而起，房地产的现状，让我们不得不蜗居啊。

Description

Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these currencies. There can be several points specializing in the same pair of currencies. Each point has its own exchange rates, exchange rate of A to B is the quantity of B you get for 1A. Also each exchange point has some commission, the sum you have to pay for your exchange operation. Commission is always collected in source currency.
For example, if you want to exchange 100 US Dollars into Russian Rubles at the exchange point, where the exchange rate is 29.75, and the commission is 0.39 you will get (100 - 0.39) * 29.75 = 2963.3975RUR.
You surely know that there are N different currencies you can deal with in our city. Let us assign unique integer number from 1 to N to each currency. Then each exchange point can be described with 6 numbers: integer A and B - numbers of currencies it exchanges, and real RAB, CAB, RBA and CBA - exchange rates and commissions when exchanging A to B and B to A respectively.
Nick has some money in currency S and wonders if he can somehow, after some exchange operations, increase his capital. Of course, he wants to have his money in currency S in the end. Help him to answer this difficult question. Nick must always have non-negative sum of money while making his operations.

Input

The first line of the input contains four numbers: N - the number of currencies, M - the number of exchange points, S - the number of currency Nick has and V - the quantity of currency units he has. The following M lines contain 6 numbers each - the description of the corresponding exchange point - in specified above order. Numbers are separated by one or more spaces. 1<=S<=N<=100, 1<=M<=100, V is real number, 0<=V<=103.
For each point exchange rates and commissions are real, given with at most two digits after the decimal point, 10-2<=rate<=102, 0<=commission<=102.
Let us call some sequence of the exchange operations simple if no exchange point is used more than once in this sequence. You may assume that ratio of the numeric values of the sums at the end and at the beginning of any simple sequence of the exchange operations will be less than 104.

Output

If Nick can increase his wealth, output YES, in other case output NO to the output file.

Sample Input

3 2 1 20.0
1 2 1.00 1.00 1.00 1.00
2 3 1.10 1.00 1.10 1.00

Sample Output

YES

题目大意

有多种汇币，汇币之间可以交换，这需要手续费，当你用100A币交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到(100 - 0.39) * 29.75 = 2963.3975 B币。问s币的金额经过交换最终得到的s币金额数能否增加

货币的交换是可以重复多次的，所以我们需要找出是否存在正权回路，且最后得到的s金额是增加的

怎么找正权回路呢？（正权回路：在这一回路上，顶点的权值能不断增加即能一直进行松弛）

1：当s金额没有增值时，我们才进行查找；

2：当所有的顶点都不能进行松弛时，说明不存在正权回路；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include<stdio.h>
#define eps 1e-8
typedef struct 
{
     double r;
     double c;
     int x;
     int y;
}E;
E e[204];
double d[102],v;
int s,temp;
 
int dijkstra()
{
     int i,sign;
     memset(d,0,sizeof(d));
     d[s]=v;
     /*当s金额没有增值时进行松弛*/
     while(d[s]<=v+eps)
     {
          sign=1;
          for(i=0;i<temp;++i)
          {
               /*松弛条件*/
               if(d[e[i].y]+eps<(d[e[i].x]-e[i].c)*e[i].r)
               {
                    sign=0;
                    d[e[i].y]=(d[e[i].x]-e[i].c)*e[i].r;
               }
          }
          /*所有的顶点都不能进行松弛时，退出并判断s金额是否已增值*/
          if(sign)
          {
               return d[s]-v;
          }
     }
     return 1;
}
int main()
{
     int n,m,i,a,b;
     double xrate,xcom,yrate,ycom;
     while(scanf("%d%d%d%lf",&n,&m,&s,&v)!=EOF)
     {
          temp=0;
          for(i=0;i<m;++i)
          {
               scanf("%d%d%lf%lf%lf%lf",&a,&b,&xrate,&xcom,&yrate,&ycom);
               e[temp].x = a;
               e[temp].y = b;
               e[temp].r = xrate;
               e[temp].c = xcom;
               ++temp;
               e[temp].x = b;
               e[temp].y = a;
               e[temp].r=yrate;
               e[temp].c=ycom;
               ++temp;
          }
          if(dijkstra())
          {
               printf("YES\n");
          }
          else
          {
               printf("NO\n");
          }
     }
     system("pause");
     return 0;
}

Description

Sam and Ella run a catering service. They like to put on a show when serving meatballs to guests seated at round tables. They march out of the kitchen with pots of meatballs and start serving adjacent guests. Ella goes counterclockwise and Sam goes clockwise, until they both plop down their last meatball, at the same time, again at adjacent guests. This impressive routine can only be accomplished if they can divide the table into two sections, each having the same number of meatballs. You are to write a program to assist them.

At these catering events, each table seats 2 <= N <= 30 guests. Each guest orders at least one and at most nine meatballs. Each place at the table is numbered from 1 to N, with the host at position 1 and the host's spouse at position N. Sam always serves the host first then proceeds to serve guests in increasing order. Ella serves the spouse first, then serves guests in decreasing order. The figures illustrate the first two example input cases.

Input

Input consists of one or more test cases. Each test case contains the number of guests N followed by meatballs ordered by each guest, from guest 1 to guest N. The end of the input is a line with a single zero.

Output

For each table, output a single line with the ending positions for Sam and Ella, or the sentence indicating an equal partitioning isn't possible. Use the exact formatting shown below.

Sample Input

5 9 4 2 8 3
5 3 9 4 2 8
6 1 2 1 2 1 2
6 1 2 1 2 1 1
0

Sample Output

Sam stops at position 2 and Ella stops at position 3.
No equal partitioning.
No equal partitioning.
Sam stops at position 3 and Ella stops at position 4.

题意：找出Sam和Ella负责分发相同数量的meatballs时，各自需要负责的客人数

其实题很简单，只要题目意思看懂了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include<stdio.h>
 
int main()
{
     int n,i,j,a[32],sum,sumtemp,temp,sign;
     while(1)
     {
          scanf("%d",&n);
          if(n==0) break;
          sum=0;
          for(i=0;i<n;++i)
          {
               scanf("%d",&a[i]);
               sum+=a[i];
          }
          if(sum%2==0)
          {
               temp=sum/2;
               sign=1;
               sumtemp=0;
               for(j=0;j<n;++j)
               {
                    if(temp==sumtemp)
                    {
                         sign=0;
                         printf("Sam stops at position %d and Ella stops at position %d.\n",j,j+1);
                         break;
                    }
                    sumtemp+=a[j];
 
               }
               if(sign)
               {
                    printf("No equal partitioning.\n");
               }
          }
          else
          {
               printf("No equal partitioning.\n");
          }
 
     }
     system("pause");
     return 0;
}

Description

You are given a number of case-sensitive strings of alphabetic characters, find the largest string X, such that either X, or its inverse can be found as a substring of any of the given strings.

Input

The first line of the input contains a single integer t (1 <= t <= 10), the number of test cases, followed by the input data for each test case. The first line of each test case contains a single integer n (1 <= n <= 100), the number of given strings, followed by n lines, each representing one string of minimum length 1 and maximum length 100. There is no extra white space before and after a string.

Output

There should be one line per test case containing the length of the largest string found.

Sample Input

2
3
ABCD
BCDFF
BRCD
2
rose
orchid

Sample Output

2
2

题目大意

找出n个字符串中相同的最大子串长度，其子串的逆序也可以作为子串

考察到字符串函数 strncpy,strlen,strrev,strstr的运用，一开始我按顺序查找前两个的最大子串长度，再找出子串与下一个字符串最大子串长度，这显然是RA，因为两个字符串中可能存在次子串，匹配到最后时，次子串可能比最大子串的长度大。

正确解法的思路已经做了注释，直接看代码吧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include<stdio.h>
#include<string.h>
#define MAX 105
 
int n;
char str[MAX][MAX];
 
int work(char s[])
{
     int i,j,scourelen,laterlen,sign;
     char scorestr[MAX],laterstr[MAX];
     scourelen=strlen(s);
     laterlen=strlen(s);
     /*按长度递减对字符串进行分割*/
     while(laterlen>0)
     {
          for(i=0;i<=scourelen-laterlen;i++)
          {
               strncpy(scorestr,s+i,laterlen);
               strncpy(laterstr,s+i,laterlen);
               scorestr[laterlen]=laterstr[laterlen]='\0';
               strrev(laterstr);
               /*让子串与所有字符串进行匹配*/
               sign=1;
               for(j=0;j<n;++j)
               {
                    /*当字符串中正反顺序都没有匹配成功时退出*/
                    if(strstr(str[j],scorestr)==NULL&&strstr(str[j],laterstr)==NULL)
                    {
                         sign=0;
                         break;
                    }
               }
               /*当所有的字符串都匹配时，说明这已经是最大的字串了*/
               if(sign)
               {
                    return laterlen;
               }
          }
          laterlen--;
     }
     return 0;
}
int main()
{
     int t,maxlength,i;
     char substr[MAX];
     scanf("%d",&t);
     while(t--)
     {
          scanf("%d",&n);
          maxlength = MAX;
          for(i=0;i<n;++i)
          {
               scanf("%s",&str[i]);
               /*找出长度最短的字符串*/
               if(maxlength>strlen(str[i]))
               {
                    strcpy(substr,str[i]);
                    maxlength=strlen(str[i]);
 
               }
          }
          printf("%d\n",work(substr));
     }
     system("pause");
     return 0;
}

顺便总结下，在使用print、print()、echo、echo()需要注意的地方，它们在使用上没什么区别，只是print、print()有返回值

1：当你要输出多个变量时，要么以“.”符号把多个值连接起来，要么用双引号把多个值包含起来

print ("$t $t");

print $t.$t ;

这些都是可行的

2：使用

print <<<EOT
EOT;

或

echo<<<EOT

在这里直接输入打印的内容，不需要加分号。打印的内容有引号时也不需要加转义字符

EOT;

末尾的EOT一定要放在行首，且前面不能有空格。不要忘记后面还有个分号

一般使用“print<<<EOT 输出语句 EOT;” 来打印html代码和JavaScript

1， 正则表达式在正常情况下包含在两个斜杠（"/"）之间，所以一个最基本的正则表达式如"/php/"

2，用正则表达式查找文本中的匹配的字符串时，正则表达式用单引号表示所要查找的字符串，这样可以避免一些特殊的字符需要转义的情况

3，采用函数时，关注下它的试用期，eregi函数已不建议使用；这里php帮助文档，每天都在更新，你可以从这里得到最新的信息。

preg_match('/(?<=p\()\d+(?=\))/',$subject,$matches)，最近在写PHP时用到正则表达式，简单解释下这是什么意思:
先解释下preg_match函数的作用

在$subject字符串中查找与正则表达式"/(?<=p\()\d+(?=\))/"想匹配的内容，把查找的结果保存在$matches数组中,数组$matches中第一个元素包含与整个模式匹配的文本，第二个元素包含与第一个元素匹配的文本，依次类推。
正则表达式：/(?<=p\()\d+(?=\))/
1：最左边和最右边的"/"是每个表达式所必需的

2：(?<=p\()：可以把它提取成(?<表达式)，这就是所谓的零宽度正回顾后发断言，查找表达式后面出现的字符。"p\("：这个就是我们需要查找的表达式，这里查找的是"p(";但是在正则表达式中括号是元字符，所以需要加转义字符"\"

3：\d+；"\d"表示数字（0-9），"\d+"表示匹配一个或多个数字

4：(?=\))：一样把它提取出来(?=表达式)，这就是零宽度正预测先行断言，查找表达式前面出现的字符。"\)",这里查找时")"，同样需要加转义字符"\"

这整个表达就是匹配出现在 p()，括号中间出现的数字，如果括号中间出现非数字的字符，这就不匹配了；

如，$subject = 'p(12345)www';
那么得到$matches[0] = 12345，

留几张照片记录下

去澳门前没啥计划，浪费时间又浪费精力，以后出门前可得好好计划下行程才行。

从大陆进澳门时，需要过两个关口，中国边检检查与澳门关闸。由于我们是中午11点才到过境边检，赶上人流高峰期，排了足足两个小时的队，把我的心情都磨掉了~

没事先换澳币，过境后直接搭乘新葡京的免费车到赌城。赌，在大陆是违法行为，一般人都一种“反逆”心理，你不让我干，我偏要干。大陆居民们对澳门这个一个开放赌场的行为产生强烈的好奇心，这也是澳门吸引了大量大陆游客的地方。要不然，澳门地方小，物价贵，就算是逛街，拍风景来一次已足已，大陆居民们没必要一直办签证来澳门。

新葡京的豪华就不说了，逛了一圈后，顺便在里面的取款机取了澳币后离开，来到大三巴街，基本上每个店面都是专卖店，手表，珠宝也比较多，价格没大陆便宜，所以没啥收获~

后来逛了一些文化建筑特色，时间有限，只到了妈阁庙，圣若瑟修远圣堂，在附近有些教学区，建筑风格保有圣堂的特征。大三巴牌坊，大炮台，旧城墙遗址和哪吒庙。这些地方都相隔都比较近。

在每个大马路的拐角处都有个澳门的地图，有一点点建筑特色的遗址在地图上都罗列了，我们就是一直按着地图上找这些地方，也绕了不少没必要路，来之前没详细计划的后果~

有玩的肯定有吃的，除了新葡京，一直往殷皇子大马路可以找到一些有名的小吃，葡挞，双皮奶，牛杂串串烧（其实跟OK里做法差不多，就是品种多样化了）、牛扒包，珍珠奶茶（估计是没找到正宗的，没觉得有啥特别之处）。听说海蟹粥也是一大特色，已经饱腹感十足的我，只好放过了~

从澳门到大陆依旧需要通过两个关口，澳门出境和中国边检，出境的时候是晚上7点，也就比较容易了。

ps：大陆的中国移动卡到了澳门是没有信号的，其它类型的卡估计也是吧，不过在海拔较高（大炮台）的地方能接受到信号。

Bellman-Ford算法，找出各个顶点间的最短路径，路径权值可以是负数，但是不能存在负权回路（在这一回路中存在负权路径）。
而Dijkstra算法，是找出某个顶点到其它顶点的最短路径。当然Dijkstra也可以找出各个顶点间的最短路径，只要做n次Dijkstra就行了。

思路：
对每对顶点i、j，不断缩小i到j的最短路径的权。在i、j中加入顶点k，判断从i到k和k到j路径的和是否小于i到j的路径长度，如果是将k加入，并调整i到j的路径长度。

缩小的条件: a[i][j]>a[i][k]+a[k][j]; （a：每对顶点的路径长度）

下面两组测试数组，前一组没构成负权回路，后一组是负权回路，无法得出正确结果

第一组：

5
1 2 6
2 3 5
3 2 -2
5 3 -3
4 3 7
2 4 -4
5 4 9
1 5 7
4 1 2
2 5 8
0 0 0

第二组：

3
1 2 2
2 3 3
3 1 -8
0 0 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#include<stdio.h>
#define MAX 10000
 
/*路径长度矩阵*/
int a[100][100];
/*路径后继矩阵*/ 
int path[100][100];
/*路径权值矩阵*/ 
int c[100][100];
 
void Floyd(int n)
{
    int i,j,k;
    /*初始化a，path*/
    for(i=1;i<=n;++i)
    {
        for(j=1;j<=n;++j)
        {
            if(c[i][j]!=MAX)
            {
                path[i][j]=j;
            }
            else 
            {
                path[i][j]=-1;
            }
            a[i][j]=c[i][j];
        }
    }
    /*尝试将顶点k扩充到已求得的从i到j的最短路径p上*/
    for(k=1;k<=n;++k)
    {
        for(i=1;i<=n;++i)
        {
            for(j=1;j<=n;++j)
            {
                if(a[i][j]>a[i][k]+a[k][j])
                {
                    /*修改路径长度*/
                    a[i][j]=a[i][k]+a[k][j];
                    /*修改路径*/
                    path[i][j]=path[i][k];
                }
            }
        }
    }
}
 
/*判断是否是负权回路*/
int isNegationLoop(int n)
{
    int i,j,k;
    for(k=1;k<=n;++k)
    {
        for(i=1;i<=n;++i)
        {
            for(j=1;j<=n;++j)
            {
                /*如果存在顶点k，从i到j存在一条更短的路径，则构成负权回路*/
                if(a[i][j]>a[i][k]+a[k][j])
                {
                    return 0;
                }
            }
        }
    }
    return 1;
}
 
/*打印各对顶点的路径情况*/
void Print(int n)
{
    int i,j,next;
    for(i=1;i<=n;++i)
    {
        for(j=1;j<=n;++j)
        {
            /*naxt为path的后续顶点*/
            next=path[i][j];
            if(next==-1)
            {
                printf("%d - %d no path\n",i,j);
            }
            else 
            {
                /*每对顶点i、j的路径长度*/
                printf("%d ",a[i][j]);
                printf("%d ",i);
                while(next!=j)
                {
                    printf("-> %d ",next);
                    /*继续找下一后续顶点*/
                    next=path[next][j];
                }
                printf("-> %d\n",j);
            }
        }
    }
}
 
int main()
{
    int n,i,j,x,y,value;
    scanf("%d",&n);
    /*初始化c*/ 
    for(i=0;i<=n;++i)
    {
        for(j=0;j<=n;++j)
        {
            if(i==j)
            {
                c[i][j]=0;
            }
            else 
            {
                c[i][j]=MAX;
            }
        }
    }
    while(1)
    {
        /*读入权值*/
        scanf("%d%d%d",&x,&y,&value);
        if(x==0&&y==0&&value==0)
        {
            break;
        }
        c[x][y]=value;
    }
    Floyd(n);
    if(isNegationLoop(n))
    {
        Print(n);
    }
    else 
    {
        printf("the short loop isn't exit\n"); 
    }
    system("pause");
    return 0;
}