REQg


  • 首页

  • 标签

  • 分类

  • 归档

  • 搜索

操作系统

发表于 2019-11-27

概述

  1. 操作系统
    是管理系统资源、控制程序执行,改善人机界面,提供各种服务,合理组织计算机工作流程和为用户有效使用计算机提供良好运行环境的最基本的一种系统软件。
  2. 操作系统中最基础的抽象
    进程抽象–是对已进入主存正在运行的程序在处理器上操作的状态集的抽象 。
    虚存抽象–是对物理主存的抽象,进程可获得一个硕大的连续地址空间来存放可执行程序和数据,可使用虚拟地址来引用物理主存单元。
    文件抽象–是对磁盘之类存储设备的抽象 。
  3. 操作系统的主要特性
    并发性
    指两个或两个以上的事件或活动在同一时间间隔内发生
    发挥并发性能够消除系统中部件和部件之间的相互等待,有效地改善系统资源的利用率,改进系统的吞吐率,提高系统效率
    共享性
    共享指操作系统中的资源可被多个并发执行的进程所使用
    第三个特性–异步性
  4. 操作系统的发展和形成
    人工操作阶段
    缺点:
    用户上机独占全机资源,造成资源利用率不高,系统效率低下
    手工操作多,浪费处理机时间,也极易发生差错
    数据的输入,程序的执行、结果的输出均联机进行,从上机到下机的时间拉得非常长
    管理程序阶段
    多道程序设计与操作系统的形成
    多道程序设计
    是指允许多个程序同时进入一个计算机系统的主存储器并启动进行计算的方法
    采用多道程序设计提高了效率,即增长了单位时间的算题量,但对每道程序来说,却延长了计算时间。
    多道程序设计技术提高资源利用率和系统吞吐率是以牺牲用户的响应时间为代价的。
    程序等待I/O操作的时间占其运行时间的比例为p,当主存中有n道程序时,所有程序都等待I/O的概率是pn,那么,
    CPU利用率=1-p^n
    有点和缺点:
    提高了CPU的利用率
    提高了主存和I/O设备的利用率
    改进了系统的吞吐率
    充分发挥了系统的并行性
    其主要缺点是: 作业周转时间延长
    操作系统的分类
    1 批处理操作系统
    批处理系统的主要特征:
    用户脱机工作
    成批处理作业
    多道程序运行
    作业周转时间长
    2 分时操作系统
    分时系统的特征
    同时性
    独立性
    及时性
    交互性
    3 实时操作系统
    新一代微机操作系统
    具有以下特点:
    (1)开放性
    (2)通用性
    (3)高性能
    (4)采用微内核结构
  5. 操作接口
    又称作业级接口,操作系统为用户提供的操作控制计算机工作和提供服务手段的集合,通常有操作控制命令、图形操作界面(命令)、以及批处理系统提供的作业控制语言(命令)等等。
  6. 内核的基本属性
    内核是由中断驱动的
    内核是不可抢占的
    内核部分程序在屏蔽中断状态下执行
    内核可以使用特权指令
  7. 虚拟机具有的特性
    内核和裸机组成的虚拟机具有以下特性:
    1)虚拟机没有中断,
    2)虚拟机为每个进程提供了一台虚拟处理器,
    3)虚拟机为进程或模块提供了功能较强的指令系统。

进程管理

  1. 进程控制块PCB,程序段,数据段构成进程镜像(进程实体)。
  2. PCB是进程存在的唯一标志。
  3. 进程:进程是进程实体的运行过程,是系统进行资源分配和调度的一个独立单位。
  4. 是一个动态的,过程性的概念。
  5. 特征:
    动态性:进程是程序的一次执行。
    并发性:指多个进程实体,同存于内存中,能在一段时间内同时运行。
    独立性:进程实体是一个能独立运行,独立获得资源和独立接受调度的基本单位。
    异步性:由于进程相互制约,使进程具有执行的间断性。
    结构性:每个进程都配置一个PCB对其进行描述,从结构上看,进程实体是由程序段,数据段和进程控制段组成。
  6. 状态
    运行状态:进程正在处理机上运行。
    就绪状态:进程已处于准备运行的状态,即进程获得了除处理机之外的一切所需资源,一旦得到处理机即可运行。
    阻塞/等待状态:进程正在等待某一事件而暂停运行。
    创建状态:进程正在被创建,尚未转到就绪状态。
    结束状态:进程正从系统中消失。
  7. 特权指令
    是指只能提供给操作系统的核心程序使用的指令,
    如启动I/O设备、设置时钟、控制中断屏蔽位、清主存、建立存储键,加载PSW等
  8. 中断的定义
    中断是指程序执行过程中,遇到急需处理的事件时,暂时中止CPU上现行程序的运行,转去执行相应的事件处理程序,待处理完成后再返回原程序被中断处或调度其他程序执行的过程。
  9. 外中断(中断或异步中断)–是指来自处理器之外的中断信号,包括时钟中断、键盘中断、它机中断和设备中断等
  10. 内中断(异常或同步中断)–是指来自处理器内部,通常由于程序执行中,发现与当前指令关联的、不正常的、或是错误的事件。
  11. 中断和异常的区别
    • 中断是由与现行指令无关的中断信号触发的(异步的),且中断的发生与CPU处在用户模式或内核模式无关,在两条机器指令之间才可响应中断,一般来说,中断处理程序提供的服务不是为当前进程所需的;
    • 异常是由处理器正在执行现行指令而引起的,一条指令执行期间允许响应异常,异常处理程序提供的服务是为当前进程所用的。异常包括很多方面,有出错(fault),也有陷入(trap)等。
  12. 进程的定义和性质
    进程是可并发执行的程序在某个数据集合上的一次计算活动,也是操作系统进行资源分配和保护的基本单位。
    进程是一个既能用来共享资源,又能描述程序并发执行过程的一个基本单位。
  13. 操作系统为什么要引入进程概念?
    原因1-刻画系统的动态性,发挥系统的并发性,提高资源利用率。
    原因2-它能解决系统的“共享性”,正确描述程序的执行状态。
  14. 进程的属性
    •结构性:
    •共享性:
    •动态性:
    •独立性:
    •制约性:
    •并发性:
  15. 进程三态模型及其状态转换

    进程三态模型及其状态转换

    具有挂起功能的进程状态及其转换
  16. 进程的描述和组成
    进程映象
    进程控制块
    进程程序块
    进程核心栈
    进程数据块
  17. 进程控制块P C B
    是操作系统用于记录和刻划进程状态及有关信息的数据结构。也是操作系统掌握进程的唯一资料结构,它包括了进程执行时的情况,以及进程让出处理器后所处的状态、断点等信息。
    进程控制块包含三类信息
    标识信息
    现场信息
    控制信息
    处于同一状态的所有PCB链接在一起的数据结构称为进程队列。
    同一状态进程的PCB既可按先来先到的原则排成队列;也可按优先数或其它原则排成队列。
  18. 进程切换
    是让处于运行态的进程中断运行,让出处理器,这时要做一次进程上下文切换、即保存老进程状态而装入被保护了的新进程的状态,以便新进程运行
  19. 线程的概念
    操作系统中引入进程的目的是为了使多个程序并发执行,以改善资源使用率和提高系统效率,
    操作系统中再引入线程,则是为了减少程序并发执行时所付出的时空开销,使得并发粒度更细、并发性更好。
  20. 线程
    是操作系统进程中能够独立执行的实体(控制流),是处理器调度和分派的基本单位。线程是进程的组成部分,每个进程内允许包含多个并发执行的实体(控制流),这就是多线程。
  21. 线程的实现
    •用户级线程ULT(如Java ,Informix)
    •内核级线程KLT(如OS/2)。
    •混合式线程(如,Solaris)。
  22. 处理机调度的层次
    作业从进入系统成为后备作业开始,直到运行结束退出系统为止,需经历不同级别的调度。
    •高级调度
    •中级调度
    •低级调度
  23. 选择调度算法的原则
    l 资源利用率
    CPU利用率=CPU有效工作时间/CPU总的运行时间,
    CPU总的运行时间=CPU有效工作时间+CPU空闲等待时间。
    2 响应时间
    •交互式进程从提交一个请求(命令)到接收到响应之间的时间间隔称响应时间。
    •使交互式用户的响应时间尽可能短,或尽快处理实时任务。
    •这是分时系统和实时系统衡量调度性能的一个重要指标。
    3 周转时间
    •批处理用户从作业提交给系统开始,到作业完成为止的时间间隔称作业周转时间,应使作业周转时间或平均作业周转时间尽可能短。
    •这是批处理系统衡量调度性能的一个重要指标。
    4 吞吐率
    单位时间内处理的作业数。
    5 公平性
    确保每个用户每个进程获得合理的CPU份额或其他资源份额,不会出现饿死情况。
  24. 如果作业i提交给系统的时刻是ts,完成时刻是tf,该作业的周转时间ti为:
    ti = tf - ts
    实际上,它是作业在系统里的等待时间与运行时间之和。
    为了提高系统的性能,要让若干个用户的平均作业周转时间和平均带权周转时间最小。
    平均作业周转时间 T = (Σti) / n
    如果作业i的周转时间为ti,所需运行时间为tk,则称wi=ti /tk为该作业的带权周转时间。
    ti是等待时间与运行时间之和,故带权周转时间总大于1。
    平均作业带权周转时间W = (Σwi) / n
  25. 低级调度的基本类型
    第一类称剥夺式:
    两种处理器剥夺原则,
    一是高优先级进程/线程可剥夺低优先级进程/线程,
    二是当运行进程/线程时间片用完后被剥夺。
    第二类称非剥夺式:
  26. 作业调度和低级调度算法
    1 先来先服务算法
    三个作业同时到达系统并立即进入调度:作业名/所需CPU时间:作业1/28,作业2/9,作业3/3。采用FCFS算法,平均作业周转时间为35。
    若三个作业提交顺序改为作业2、1、3,平均作业周转时间约为29。
    若三个作业提交顺序改为作业3、2、1,平均作业周转时间约为18。
    FCFS调度算法的平均作业周转时间与作业提交的顺序有关。
    2 最短作业优先算法
    SJF算法以进入系统的作业所要求的CPU时间为标准,总选取估计计算时间最短的作业投入运行。
    算法易于实现,效率不高,主要弱点是忽视了作业等待时间。
    会出现饥饿现象。
    SJF的平均作业周转时间比FCFS要小,故它的调度性能比FCFS好。
    实现SJF调度算法需要知道作业所需运行时间,否则调度就没有依据,要精确知道一个作业的运行时间是办不到的。
    四个作业同时到达系统并进入调度: 作业名/所需CPU时间:作业1/9,作业2 ,作业3/10,作业4/8。
    SJF作业调度顺序为作业2、4、1、3,
    平均作业周转时间T = 17,平均带权作业周转时间W= 1.98。
    如果施行FCFS调度算法,平均作业周转时间T =19,平均带权作业周转时间
    W = 2.61。
    3 最短剩余时间优先算法
    SRTF把SJF算法改为抢占式的。一个新作业进入就绪状态,如果新作业需要的CPU时间比当前正在执行的作业剩余下来还需的CPU时间短,SRTF强行赶走当前正在执行作业。称最短剩余时间优先算法
    此算法不但适用于JOB调度,同样也适用于进程调度。
    4 响应比最高者优先算法
    FCFS与SJF是片面的调度算法。FCFS只考虑作业等候时间而忽视了作业的计算时问,SJF只考虑用户估计的作业计算时间而忽视了作业等待时间。
    HRRF是介乎这两者之间的折衷算法,既考虑作业等待时间,又考虑作业的运行时间,既照顾短作业又不使长作业的等待时间过长,改进了调度性能。
    响应比 =1+已等待时间/估计运行时间
    •短作业容易得到较高响应比,
    •长作业等待时间足够长后,也将获得足够高的响应比,
    •饥饿现象不会发生。
  27. 时间片轮转调度算法
    时间片调度做法是:调度程序每次把CPU分配给就绪队列首进程使用一个时间片,例如100ms,就绪队列中的每个进程轮流地运行一个时间片。当这个时间片结束时,强迫一个进程让出处理器,让它排列到就绪队列的尾部,等候下一轮调度
    轮转策略可防止那些很少使用外围设备的进程过长的占用处理器而使得要使用外围设备的那些进程没有机会去启动外围设备
    轮转策略与间隔时钟
  28. 多级反馈队列调度
    又称反馈循环队列或多队列策略。主要思想是将就绪进程分为两级或多级,系统相应建立两个或多个就绪进程队列,较高优先级的队列一般分配给较短的时间片。
    处理器调度先从高级就绪进程队列中选取可占有处理器的进程,只有在选不到时,才从较低级的就绪进程队列中选取。
  29. 彩票调度算法
    基本思想:为进程发放针对各种资源(如CPU时间)的彩票。调度程序随机选择一张彩票,持有该彩票的进程获得系统资源。
    进程都是平等的,有相同的运行机会。如果某些进程需要更多的机会,可被给予更多彩票,增加其中奖机会。
  30. 实时调度算法
    实时系统是那些时间因素非常关键的系统。
    实时系统包括监控系统、自动驾驶系统、安全控制系统等,这些系统中,迟到的响应即使正确,也和没有响应一样糟糕。
    实时系统通常分为硬实时系统和软实时系统。
    前者意味着存在必须满足的时间限制;后者意味着偶尔超过时间限制时可以容忍的。
  31. Linux调度算法
    1 进程调度策略
    1) policy:
    SCHED_OTHER普通类任务
    SCHED_FIFO先进先出实时类任务
    SCHED_RR轮转法实时类任务
    2) priority进程静态优先级
    3) nice进程可控优先级因子
    4) rt_priority实时进程静态优先级
    5) counter进程目前时间片配额,也称进程动态优先级
    2 动态优先级的产生和变化
    当counter递减到0时,运行进程被迫出让CPU;当可运行队列中所有进程的counter值变为0后,表明一轮调度已经结束。
    等待态进程的动态优先级通常会逐渐增加,当所有可运行进程的counter都为0时,系统重新计算所有进程的counter,计算公式为:
    p->counter=(p->counter>>1)+NICE_TO_TICKS(P->nice)
    对于就绪态进程来说,因其counter都为0,计算结果就是nice转换过来的时钟滴答数;对于等待态进程就不一样,它们的counter都不为0,计算结束后,等待态进程的动态优先级会大于nice值。
  32. 进程的顺序性
    一个进程在顺序处理器上的执行是严格按序的,一个进程只有当一个操作结束后,才能开始后继操作
    顺序程序设计是把一个程序设计成一个顺序执行的程序模块,顺序的含义不但指一个程序模块内部,也指两个程序模块之间。
    顺序程序设计特点:
    程序执行的顺序性
    程序环境的封闭性
    程序执行结果的确定性
    计算过程的可再现性
  33. 进程的并发性
    进程执行的并发性:一组进程的执行在时间上是重叠的。
    从宏观上看,并发性反映一个时间段中几个进程都在同一处理器上,处于运行还未运行结束状态。
    从微观上看,任一时刻仅有一个进程在处理器上运行。
    并发的实质是一个处理器在几个进程之间的多路复用,并发是对有限的物理资源强制行使多用户共享,消除计算机部件之间的互等现象,以提高系统资源利用率。
  34. 并发程序设计的优点
    •对于单处理器系统,可让处理器和各I/O设备同时工作,发挥硬部件的并行能力。
    •对于多处理器系统,可让各进程在不同处理器上物理地并行,加快计算速度。
    •简化了程序设计任务。
    采用并发程序设计的目的:
    充分发挥硬件的并行性,提高系统效率。硬件能并行工作仅有了提高效率的可能性,硬部件并行性的实现需要软件技术去利用和发挥,这种软件技术就是并发程序设计。
    并发程序设计是多道程序设计的基础,多道程序的实质就是把并发程序设计引入到系统中
  35. 与时间有关的错误
    结果不唯一
    永远等待

  36. 进程的交往:竞争与协作
    第一种是竞争关系
    系统中的多个进程之间彼此无关
    系统中的多个进程之间彼此相关
    资源竞争的两个控制问题:
    一个是死锁(Deadlock)问题,
    一个是饥饿(Starvation) 问题,既要解决饥饿问题,又要解决死锁问题。
    第二种是协作关系
    某些进程为完成同一任务需要分工协作。
    进程同步指为完成共同任务的并发进程基于某个条件来协调它们的活动,因为需要在某些位置上排定执行的先后次序而等待、传递信号或消息所产生的协作制约关系。

  37. 进程互斥(Mutual Exclusion)
    进程互斥是指若干个进程因相互争夺独占型资源时所产生的竞争制约关系。

  38. 进程同步
    指两个以上进程基于某个条件来协调它们的活动。一个进程的执行依赖于协作进程的消息或信号,当一个进程没有得到来自于协作进程的消息或信号时需等待,直到消息或信号到达才被唤醒。
    进程互斥关系是一种特殊的进程同步关系,即逐次使用互斥共享资源,是对进程使用资源次序上的一种协调。
  39. 互斥与临界区
    并发进程中与共享变量有关的程序段叫“临界区”, 共享变量代表的资源叫“临界资源”。
    与同一变量有关的临界区分散在各进程的程序段中,而各进程的执行速度不可预知。
    如果保证进程在临界区执行时,不让另一个进程进入临界区,即各进程对共享变量的访问是互斥的,就不会造成与时间有关的错误。
    一次至多一个进程能够进入临界区内执行;
    如果已有进程在临界区,其他试图进入的进程应等待;
    进入临界区内的进程应在有限时间内退出,以便让等待进程中的一个进入。
    临界区调度原则:
    互斥使用、有空让进,忙则等待、有限等待,择一而入,算法可行

名词解释

  1. 解释并发与并行,并说明两者关系。
    若干个事件或活动在同一时刻发生称为并行;若干个事件或活动在同一时间间隔内发生称为并发。
    关系:并行是并发的特例,并发是并行的扩展。

  2. 解释模式切换与进程切换,并说明两者关系。
    模式切换:进程运行中,当执行系统调用或发生中断时,CPU 模式从用户态切换到内核态,
    去执行操作系统例程的过程,或者在完成系统处理后,通过逆向 CPU 状态切换来继续执行
    被中断进程的过程。进程切换:是将 CPU 的使用权从一个进程转给另一个进程。(1)
    关系:模式切换不一定产生进程切换,但进程切换必定有模式切换伴随。

  3. 解释硬中断和软中断,并说明两者关系。
    通过硬件设施来产生中断请求,称作硬中断。
    利用硬件中断的概念,用软件方式进行模拟,实现宏观上的异步执行效果的中断称作软中断。
    关系:两者在中断请求、中断屏蔽、中断触发、中断服务等概念与设施方面十分相似。

  4. 解释“死锁”与“饥饿”,并说明两者关系。
    如果在一个进程集合中的每个进程都在等待只能由该集合中的其他进程才能引发的事件,而无限期僵持的局面称死锁。
    一个可运行进程由于其他进程总是优先于它,而被无限期拖延而不能被执行的现象称饥饿。
    死锁进程必然处于饥饿状态,但处于饥饿状态的进程未必陷入死锁。

  5. 列出操作系统中常用的安全机制(中文及其英文名)。
    认证机制(authentication)
    授权机制(authorization)
    加密机制(encryption)
    审计机制(audit 或 auditing)

  6. 解释自主访问控制机制与强制访问控制。
    前者指资源属主可按照自已意愿指定系统中的其他用户对其资源的访问权限的访问控制机制。
    后者指将系统中的信息分密级和范畴进行管理, 保证用户只能够访问那些被标明能够由他访问的信息的访问控制机制。

解答题

  1. 试述操作系统中最基础的三个抽象,并回答为什么要引入它们?
    进程是对处理器的抽象、虚存是对主存的抽象、文件是对设备的抽象。
    于是可面向进程而不是处理器、面向虚存而不是主存、面向文件而不是设备,方便了系统对
    资源的管理、控制和调度。

  2. 试从进程管理、进程通信、中断处理、文件管理、存储管理、设备管理的角度考虑,
    列出进程控制块中应包含的主要项目。
    从进程管理角度应有:进程标识、进程状态、进程优先级、队列指针等。
    从进程通信角度应有:消息队列首指针、访问消息队列互斥信号量、消息计数等。
    从中断处理角度应有:现埸信息(上下文)、中断源及类型等。
    从文件管理角度应有:保存进程使用文件的 FCB 等。
    从存储管理角度应有:保存进程使用的程序和数据的内外存地址或页表位置等。
    从设备管理角度应有:保存进程分配到的资源及所需资源情况等。

  3. 叙述 LRU、 NRU 和 LFU 三种页面置换算法的基本思想,并各给出一种可能的实现方案。
    LRU 选择最近最久未使用过的页面予以淘汰。实现方案: 为页面设置访问字段,记录该
    页面自上次被访问以来所经历的时间 T,需要淘汰一个页面时,总是选择现有页面面中 T 值
    最大的页面淘汰。
    NRU 选择在最近一个时期内未被访问过的页面予以淘汰。实现方案:为页面设置访问位,
    当某页被访问时其访问位置 1,系统周期性地对所有访问位清 0。需要淘汰页面时,总是从
    访问位为 0 的页面中选择一个予以淘汰。
    LFU 选择在最近时期使用最少的页面予以淘汰。实现方案:为页面设置访问计数器,页
    面被访问时其访问计数器加 1。需要淘汰页面时,总是淘汰计数器值最小的页面,同时,所
    有计数器清 0。

  4. 简述操作系统虚化技术在设备管理中的应用。
    在设备管理中,通过用—类物理设备来模拟另一类物理设备,即通过共享设备磁盘来模拟独
    占设备,把一个物理实体变成若干逻辑上的对应物。例如借助 SPOOLing 技术,把独占设备
    (纸带、打印机等)虚化出许许多多台逻辑设备供用户使用。

  5. 简述逻辑文件和物理文件,及其分类。
    逻辑文件是从用户观点出发,考虑信息的组织及配置方式,它分为流式文件和记录式文件。
    物理文件是从系统观点出发,考虑文件在物理介质上的组织和存放方式,它分串连文件、连
    续文件、索引文件和哈希文件。

  6. I/0 软件分四个层次,试说明以下各个工作是在哪一层完成的?(3 分)
    (1) 向设备寄存器发写命令。
    (2) 设备缓冲区管理。
    (3) 逻辑地址转换为物理地址。
    (4) 唤醒请求 I/O 的进程。
    (5) 检查设备状态寄存器内容。
    (6) 将二进制整数转化成 ASCII 码以便打印。
    (1)和(4)在设备驱动程序。
    (2)和(3)在操作系统 I/O 软件。
    (5)在 I/O 中断处理程序。
    (6)在用户层 I/O 软件。

  7. 试说明多级反馈队列调度算法的基本思想,为什么说这是一种较好的进程调度算法?
    本算法能全面满足不同类型作业的需求,较好实现公平性与资源利用率之间的平衡。
    对分时交互型短作业,系统通常可在第一队列(最高优先级队列)规定的时间片内完成工作,
    使终端型用户感到满意;
    对短批处理作业,通常,只需在第一和第二队列中各执行一个时间片就能完成工作,周转时
    间仍然很短;
    对长批处理作业,它将依次在第一、第二、第三等各个队列中获得时间片运行,不必担心长
    时间得不到处理。因而这是一种较好的进程调度算法。

英语二

发表于 2019-11-24

2010

Section I

detect
declare
deeignate
alert
severity
director
general
overwhelming
symptom
a full
recovery
absence
crop up
at the height of
virtually
cause
magnificent

Section II

test 1

Test 4
jury
n. 陪审团; (比赛的) 评判委员会,裁判委员会;
concrete
adj. 混凝土制的; 确实的,具体的(而非想象或猜测的); 有形的; 实在的;
n. 混凝土;
v. 用混凝土覆盖;
crucial
adj. 至关重要的; 关键性的;
literacy
n. 读写能力;

Translation

desperate
dilemma
translate

2011

Section I

compromise
n. 妥协; 折中; 互让; 和解; 妥协(或折中)方案; 达成妥协(或和解);
establish
v. 建立; 创立; 设立; 建立(尤指正式关系); 确立; 使立足; 使稳固;
administration
n. (企业、学校等的) 管理,行政; 施行; 执行; (企业、学校等的) 管理部门,行政部门;
compulsory
adj. (因法律或规则而) 必须做的,强制的,强迫的;
mentality
n. 心态; 思想状况; 思想方法;
generous
adj. 慷慨的; 大方的; 慷慨给予的; 丰富的; 充足的; 大的; 宽厚的; 宽宏大量的; 仁慈的;
envision
v. 展望; 想象;
proposal
n. 提议; 建议; 动议; 求婚;
interference
n. 干涉; 干预; 介入; (无线电信号的) 干扰;
dismiss
v. 不予考虑; 摒弃; 对…不屑一提; 去除,消除,摒除(思想、感情等); 解雇; 免职; 开除;
in vain
[词典] 徒劳; 白费力气; 无用的; 无意义的; 无价值的;
modernized
v. 使(制度、方法等)现代化; 使(设备、概念等)现代化;
thriving
v. 兴旺发达; 繁荣; 蓬勃发展; 旺盛; 茁壮成长;
defendable
网络 可防御的;
invisible
adj. 看不见的; 隐形的; 无形的(与服务而非商品有关);
n. 看不见的人;

Section II

Test 1
be supposed to do
[词典] 应当,应该;
weather
n. 天气; 气象; 气象预报;
v. (因受风吹、日晒、雨淋等,使) 退色,变色,变形; 经受住,平安地渡过(困难);
restate
v. 重申; 重新表述;
suggestive
adj. 使人想起…的; 引起联想的; 性暗示的; 性挑逗的;
blow
v. 吹; 刮; (被) 刮动,吹动;
n. (用手、武器等的) 猛击; 打击; 挫折; 吹;
be accustomed to
[词典] 习惯于…;
trade up
[词典] 变卖(旧物)换进同类中更贵的东西;
attract
v. 吸引; 使喜爱; 引起…的好感(或爱慕); 招引; 引起(反应);
compensation
n. 补偿(或赔偿)物; (尤指) 赔偿金,补偿金; 赔偿; 使坏的情况变好的事物; (对不利局面的) 补偿;
compensate
v. 补偿; 弥补; 给(某人)赔偿(或赔款);
unremarked
adj. 未被注意;
take up
[词典] 开始从事; 喜欢上; 开始处理; 讨论…的处理方法; 开始干(工作); 接受,答应(提议或挑战); 占用,花费(时间、空间或精力); 占领,占据,占有(位置、阵地); 继续; 把…接着进行下去;
board
n. 板; (尤指) 木板; …用木板(或板材); (公司或其他机构的) 董事会,委员会,理事会;
v. 上船(或火车、飞机、公共汽车等); 让乘客登机(或上船等); 付费(在某人家里)膳宿;
reputation
n. 名誉; 名声;
crises
n. 危机; 危急关头; 危难时刻; 病危期;
[词典] crisis的复数;
concentrate
v. 集中(注意力); 聚精会神; 使…集中(或集合、聚集); (使) 浓缩;
n. 浓缩物;
subsequently
adv. 随后; 后来; 之后; 接着;
correlation
n. 相互关系; 相关; 关联;
incentive
n. 激励; 刺激; 鼓励;
incent
网络 激励;
attractive
adj. 性感的; 妩媚的; 英俊的; 诱人的; 吸引人的; 令人愉快的; (事物) 有吸引力的;
permissive
adj. 放任的; 纵容的; 姑息的; (尤指两性关系) 放纵的;
positive
adj. 积极乐观的; 自信的; 积极的; 建设性的; 朝着成功的; 表示赞同的; 拥护的;
n. 优势; 优点; 正片; 阳性结果(或反应);
scornful
adj. 轻蔑的; 鄙夷的;
passive
adj. 消极的; 被动的; (动词形式) 被动语态的;
n. 动词被动形式; 被动语态;

Test 2
a round of
网络 一连串的; 一场;
recession
n. 经济衰退; 经济萎缩; 退后; 撤回;
fled
v. 迅速离开; (尤指害怕有危险而) 逃避,逃跑;
[词典] flee的过去分词和过去式;
chronicling
v. 把…载入编年史; 按事件发生顺序记载;
[词典] chronicle的现在分词;
chronicle
n. 编年史; 历史;
v. 把…载入编年史; 按事件发生顺序记载;
shrugged
v. 耸肩(表示不知道或不在乎);
margin
n. 页边空白; 白边; (获胜者在时间或票数上领先的) 幅度,差额,差数; 余地; 备用的时间(或空间、金钱等);
reckon
v. 想; 认为; 被普遍认为是; 被看作是; 料想; 预计; 指望;
nerve
n. 神经; 神经质; 神经紧张; 勇气; 气魄;
v. 鼓足勇气; 振作精神;
overboard
adv. 从船上落下;
inhabit
v. 居住在; 栖居于;
stay afloat
n. 顺利运营;
shrug off
[词典] 把…不当回事; 对…置之不理; 对…满不在乎;
have the nerve to do sth
有勇气做某事
desperate
adj. (因绝望而) 不惜冒险的,不顾一切的,拼命的; 绝望的; 孤注一掷的; 铤而走险的; 非常需要; 极想; 渴望;
reliance
n. 依赖; 依靠; 信任;
whirlwind
n. 旋风; 旋流; 一片忙乱;
adj. 快速的; 匆匆忙忙的; 旋风似的;
concentrated
adj. 决心要做的; 全力以赴的; 浓缩的; 密集的; 集中的;
v. 集中(注意力); 聚精会神; 使…集中(或集合、聚集); (使) 浓缩;
[词典] concentrate的过去分词和过去式;
distinctive
adj. 独特的; 特别的; 有特色的;
distinctiveness
n. 特殊性;区别性;辨别性;
savagely
adv. 野蛮地;
completeness
n. 完整性;完全(度);完备(性);完善;结束;
virtue
n. 高尚的道德; 正直的品性; 德行; 美德; 优秀品质; 良好习惯; 优点; 长处; 用处;
counterpart
n. 职位(或作用)相当的人; 对应的事物;
thriving
v. 兴旺发达; 繁荣; 蓬勃发展; 旺盛; 茁壮成长;
[词典] thrive的现在分词;
thrive
v. 兴旺发达; 繁荣; 蓬勃发展; 旺盛; 茁壮成长;

Test 3
marriage
n. 结婚; 婚姻; 婚姻生活; 已婚状态; 婚礼;
line up
[词典] (使) (某一批人)排成行; (使) 列队; 使(某一批物)排列成行; (使) 对齐; 组织; 邀集;
by the million
以百万计
depression
n. 抑郁症; 精神忧郁; 抑郁; 沮丧; 消沉; 萧条期; 经济衰退; 不景气;
in combination with
网络 结合;
restraint
n. 约束力; 管制措施; 制约因素; 控制; 限制; 克制; 抑制; 约束;
stylish
adj. 时髦的; 新潮的; 高雅的; 雅致的;
positively
adv. 绝对地; 肯定地; 乐观地; 积极地; 赞成地;
stimulus
n. 促进因素; 激励因素; 刺激物; (使生物产生反应的) 刺激;
take up post
占用岗位
course
n. (有关某学科的系列) 课程,讲座; (大学中要进行考试或取得资格的) 课程; (船或飞机的) 航向,航线;
v. 快速地流动; 奔流;
belief
n. 相信; 信心; 看法; 信念; 信仰; 宗教信仰;
architect
n. 建筑师; 设计师; 缔造者; 创造者;
associated
adj. 有关联的; 相关的; 有联系的; (用于联合企业的名称) 联合的;
v. 联想; 联系; 交往; (尤指) 混在一起; 表明支持; 表示同意;
[词典] associate的过去分词和过去式;
associate
v. 联想; 联系; 交往; (尤指) 混在一起; 表明支持; 表示同意;
adj. 非正式的; 准的; 副的; 联合的; 有关联的;
n. 同事; 伙伴; 合伙人; 准学士(获得两年制高校学位);
emigrated
v. 移居国外; 移民;
[词典] emigrate的过去分词和过去式;
architecture
n. 建筑学; 建筑设计; 建筑风格; 体系结构; (总体、层次) 结构;
exert
v. 运用; 行使; 施加; 努力; 竭力;
signature
n. 签名; 署名; 签字; 签署; 明显特征; 鲜明特色; 识别标志;
elegance
n. 优美,高雅,典雅,优雅,雅致;
derive
v. 获得; 取得; 得到; (使) 起源; (使) 产生;
derive from
[词典] 由…起源;
abundance
n. 大量; 丰盛; 充裕;
laminated
adj. 由薄层粘制成的; 层压的; 粘合的; 用透明塑料薄膜覆盖的;
laminate
n. 薄片制成的材料; 层压(或粘合)材料;
symbolized
v. 象征; 是…的象征; 代表;
[词典] symbolize的过去分词和过去式;
symbolize
v. 象征; 是…的象征; 代表;
sophisticated
adj. 见多识广的; 老练的; 见过世面的; 复杂巧妙的; 先进的; 精密的; 水平高的; 在行的;
sophisticate
n. 老于世故的人; 见多识广的人;
elegant
adj. 优美的; 文雅的; 漂亮雅致的; 陈设讲究的; 精美的; 简练的; 简洁的; 简明的;
commissioned
v. 正式委托(谱写或制作、创作、完成); 任命…为军官;
[词典] commission的过去式;
mask
n. 面具; 面罩; 假面具; 护肤膜; 面膜;
v. 掩饰; 掩藏;
presentation
n. 提交; 授予; 颁发; 出示; 提出(或展示、解释等)的方式; 展示会; 介绍会; 发布会;
forthright
adj. 直率的; 直截了当的; 坦诚的;
employ
v. 雇用; 应用; 运用; 使用;
n. 雇用,受雇; 服务; 工作,职业;
n. 直路;
abandance
n. 大量; 丰盛; 充裕;
restraint
n. 约束力; 管制措施; 制约因素; 控制; 限制; 克制; 抑制; 约束;
affect
v. 影响; 侵袭; 使感染; (感情上) 深深打动; 使悲伤(或怜悯等);
airy
adj. 通风的; 空气流通的; 无忧无虑的; 无所谓的; 漫不经心的; 轻率的; 不切实际的;
equivalent
adj. (价值、数量、意义、重要性等) 相等的,相同的;
n. 相等的东西; 等量; 对应词;
drive
v. 驾驶; 开车; 驾车送(人); 拥有(或驾驶)…汽车;
n. 驱车旅行; 驾车路程; 传动(或驱动)装置; (从街道通向住宅的宽阔或私人的) 车道;
modest
adj. 些许的; 不太大(或太贵、太重要等)的; 谦虚的; 谦逊的; 庄重的; 朴素的; 不性感的;适中的;
landscape
n. (陆上,尤指乡村的) 风景,景色; 乡村风景画; 乡村风景画的风格; (文件的) 横向打印格式;
v. 对…做景观美化; 给…做园林美化; 美化…的环境;
reliant
adj. 依赖性的; 依靠的;
associated
adj. 有关联的; 相关的; 有联系的; (用于联合企业的名称) 联合的;
v. 联想; 联系; 交往; (尤指) 混在一起; 表明支持; 表示同意;
[词典] associate的过去分词和过去式;
spacious
adj. 宽敞的;
Lake Shore Drive
网络 湖滨大道; 湖滨快车道;
mechanical
adj. 机动的; 机械驱动的; 机械的; 机器的; 发动机的; 机械般的; 呆头呆脑的; 无思想的;
scenes
n. (尤指不愉快事件发生的) 地点,现场; 事件; 场面; 情景; 片段; 镜头;
[词典] scene的复数;
sacrificed
v. 牺牲; 献出; 以(人或动物)作祭献;
[词典] sacrifice的过去分词和过去式;
inevitable
adj. 不可避免的; 不能防止的; 总会发生的; 照例必有的; 惯常的; 必然发生的事; 不可避免的事;
irreversible
adj. 无法复原(或挽回)的; 不能倒转的;

Test 4
make it
chronic
adj. 长期的; 慢性的; 难以治愈(或根除)的; 长期患病的; 糟透的; 拙劣的;
acute
adj. 十分严重的; (疾病) 急性的; 灵敏的;
converge
v. 汇集; 聚集; 集中; (向某一点) 相交,会合; (思想、政策、目标等) 十分相似,相同;
discipline
n. 训练; 训导; 纪律; 风纪; 训练方法; 行为准则; 符合准则的行为; 自制力; 遵守纪律;
v. 惩罚; 处罚; 训练; 训导; 管教; 自我控制; 严格要求(自己);
stuck
adj. 动不了; 无法移动; 卡住; 陷住; 陷(入); 困(于); 被难住; 答不上来; 卡壳;
v. 将…刺入(或插入); 刺; 戳; 插入; 粘贴; 粘住; (尤指迅速或随手) 放置;
[词典] stick的过去分词和过去式;
stick
v. 将…刺入(或插入); 刺; 戳; 插入; 粘贴; 粘住; (尤指迅速或随手) 放置;
n. 枝条; 枯枝; 柴火棍儿; 球棍; 条状物; 棍状物;
harmonization
n. 协调化;一致化;和谐;融洽;悦耳; 射效矫正;校射;
harmonise
v. (使) 和谐,(使……与……)协调,(使)相称; 以和声唱歌或演奏;
sacntion
n. 制裁; (正式) 许可,批准; 约束; 处罚;
v. 许可; 准许; 准予; 惩罚; 实施制裁;
suspension
n. 暂令停职(或停学、停赛等); 暂缓; 推迟; 延期; (车辆减震用的) 悬架;
rigour
n. 谨慎; 缜密; 严谨; 严格; 严厉; 艰苦; 严酷;
intervening
adj. 发生于其间的; 介于中间的;
v. 出面; 介入; 插嘴; 打断(别人的话); 阻碍; 阻挠; 干扰;
[词典] intervene的现在分词;
intervene
v. 出面; 介入; 插嘴; 打断(别人的话); 阻碍; 阻挠; 干扰;
mrurmured
v. 低语; 喃喃细语; 连续发出低沉的声音; (私下) 发怨言,发牢骚;
[词典] murmur的过去式;
curbing
v. 控制,抑制,限定,约束(不好的事物);
[词典] curb的现在分词;
ambitious
adj. 有野心的; 有雄心的; 费力的; 耗资的; 耗时的;
blunt
adj. 不锋利的; 钝的; 嘴直的; 直言的;
v. 使减弱; 使降低效应; 使(尖端、刃)变钝;
regard
v. 将…认为; 把…视为; 看待; (尤指以某种方式) 注视,凝视;
n. 注意; 关注; 关心; 尊重; 尊敬; 敬佩; (用于信函结尾或转达问候) 致意,问候;
desperate
adj. (因绝望而) 不惜冒险的,不顾一切的,拼命的; 绝望的; 孤注一掷的; 铤而走险的; 非常需要; 极想; 渴望;
conceited
adj. 自负的; 骄傲自大的;
conceit
n. 自负; 骄傲自大; 别出心裁但不实用的效果; 巧妙但不实用的东西; 巧妙的言辞; 别出心裁的比喻;

Part B
cigarette
n. 香烟; 纸烟; 卷烟;
senior
adj. 级别(或地位)高的; 成人的; 高级水平的; (父子同名时,加在父亲的名字前) 老,大;
n. 较…年长的人; 级别(或地位)较高者; 上级; 上司; 资深成人运动员; 高水平运动员;
sponsorship
n. 资助; 赞助款; 主办; 倡议;
spiraling
v. 盘旋上升(或下降);
boesity
n. 肥胖症;
diabetes
n. 糖尿病; 多尿症;
halt
v. (使) 停止,停下;
n. 停止; 阻止; 暂停; 小火车站(只有站台);
inconceivable
adj. 难以想象的; 无法相信的;
conceivable
adj. 可想象的; 可信的;
conceive
v. 想出(主意、计划等); 想象; 构想; 设想; 怀孕; 怀(胎);
ban
v. 明令禁止; 取缔; 禁止(某人)做某事(或去某处等);
n. 禁令;
pub
n. 酒吧; 酒馆;
alarmed
adj. 担心; 害怕; 有警报装置的;
v. 使惊恐; 使害怕; 使担心; 给(门等)安装警报器;
[词典] alarm的过去分词和过去式;
campaigner
n. (尤指政治或社会变革的) 运动领导者,运动参加者;
centerpiece
n. 中心装饰品;放在餐桌中央的摆饰;
lectureing
v. (尤指在大学里) 开讲座,讲授,讲课; (尤指恼人地) 指责,训斥,告诫;
[词典] lecture的现在分词;
billboard
n. (大幅) 广告牌;
v. 宣传;
cinemas
n. 电影院; (去电影院) 看电影; 电影艺术; 电影制片业;
[词典] cinema的复数;
bold
adj. 大胆自信的; 敢于表白情感的; 敢于冒险的; 明显的; 轮廓突出的; 粗体的; 黑体的;
n. 黑体; 粗体;
association
n. 协会; 社团; 联盟; 联合; 合伙; 关联; 交往; 联想; 联系;
inducement
n. 引诱; 刺激; 诱因;
lure
v. 劝诱; 引诱; 诱惑;
n. 吸引力; 诱惑力; 魅力; 鱼饵; 诱饵;
council
n. (市、郡等的) 政务委员会,地方议会; 市政(或地方管理)服务机构; (顾问、立法、研究、基金等) 委员会;
outlet
n. (感情、思想、精力发泄的) 出路; 表现机会; 专营店; 经销店; 折扣品经销店;

2012

Section I

adventurism
n. (企业、政治等方面) 冒险主义;
adventure
n. 冒险; 冒险经历; 奇遇; 冒险的刺激; 大胆开拓;
v. <旧>探险; <旧>冒险; 大胆说出;
liberated
adj. (社会及性行为) 不受传统思想束缚的,解放的,开放的;
v. 解放; 使自由; 使摆脱约束(或限制);
[词典] liberate的过去分词和过去式;
torn
adj. 犹豫的; 举棋不定的;
v. 撕裂; 撕碎; 扯破; 戳破; 撕开,划成,刺出,扯开(裂口或洞); 拉掉; 撕掉; 拔掉; 扯掉;
[词典] tear的过去分词;
tear sb away from
使某人脱离
tear
v. 撕裂; 撕碎; 扯破; 戳破; 撕开,划成,刺出,扯开(裂口或洞); 拉掉; 撕掉; 拔掉; 扯掉;
n. 破洞; 裂口; 裂缝;
n. 眼泪; 泪珠; 泪水;
stick it out
[词典] (在逆境中) 坚持到底,忍耐到底;
murder
n. 谋杀; 凶杀; 困难的事; 讨厌的事;
v. 谋杀; 凶杀; 糟蹋; 毁坏; 弄坏; (尤指在团队运动中) 彻底打败,打垮;
brutal
adj. 残暴的; 兽性的; 直截了当的; 冷酷的;
abbreviation
n. 略语; 缩写词; 缩写形式; 缩略; 缩写;
actual
adj. 真实的; 实际的; (强调事情最重要的部分) 真正的,…本身;
abbreviate
v. 缩略; 把(词语、名称)缩写(成…);
facility
n. 设施; 设备; (机器等的) 特别装置; (服务等的) 特色; (供特定用途的) 场所; (学习、做事的) 天资,才能,天赋;
secretary
n. 秘书; (俱乐部、社团等的) 干事,文书; 部长; 大臣;
troop
n. 军队; 部队; 士兵; 连队; 坦克连; 骑兵连; 童子军中队;
v. 成群结队而行; 列队行进;
correspondent
n. 记者; 通讯员; 通信者;
secretary of state
n. (英国) 大臣; (美国) 国务卿;
famed
adj. 著名的;
exhaustion
n. 筋疲力尽; 疲惫不堪; 耗尽; 用尽; 枯竭;
civilization
n. 文明; (特定时期和地区的) 社会文明; 文明世界; 文明社会;
rebelled
v. 造反; 反抗; 背叛;
[词典] rebel的过去分词和过去式;
commute
v. (乘公共汽车、火车、汽车等)上下班往返,经常往返(于两地) ; 减刑; 代偿;
n. 上下班路程;
ethical
adj. (有关) 道德的; 伦理的; 合乎道德的;
article
n. (报刊上的) 文章,论文,报道; (协议、契约的) 条款,项; 物件,物品(尤指整套中的一件);
vi. 使受协议条款的约束; 以协议(或契约)约束; 订约将…收为学徒(或徒弟); 定约雇用进行控告; 提出罪状(或指责)(against); 签订协议;
hand out
[词典] 分发; 散发; 给予(忠告、许可等);
make it
[词典] (及时) 到达(尤指来得及做某事); 及时赶上参加; (经历艰难困苦后) 成功; 做到;
rebel
n. 反政府的人; 叛乱者; 造反者; 反抗权威者; 叛逆者; 不守规矩者;
v. 造反; 反抗; 背叛;
distinguished
adj. 卓越的; 杰出的; 著名的; 显得重要的; 高贵的; 有尊严的;
v. 区分; 辨别; 分清; 成为…的特征; 使具有…的特色; 使有别于; 看清; 认出; 听出;
[词典] distinguish的过去分词和过去式;
actual
adj. 真实的; 实际的; (强调事情最重要的部分) 真正的,…本身;
portray
v. 描绘; 描画; 描写; 将…描写成; 给人以某种印象; 表现; 扮演(某角色);
eased
v. (使) 宽慰; 减轻; 缓解; (使) 小心缓缓地移动; 使…容易些;
[词典] ease的过去分词和过去式;
ease
n. 容易; 轻易; 不费劲; 舒适; 安逸; 自在; 无忧无虑;
v. (使) 宽慰; 减轻; 缓解; (使) 小心缓缓地移动; 使…容易些;
civilization
n. 文明; (特定时期和地区的) 社会文明; 文明世界; 文明社会;
bore
v. (尤指因啰唆) 使厌烦; 钻,凿,挖(长而深的洞); 盯着看;
n. (常因话多) 令人厌烦的人; 烦人的状况(或事情); (管道、枪炮等的) 孔,内径,口径; 膛径;
[词典] bear的过去式;
bear
v. 承受; 忍受; 不适于某事(或做某事); 承担责任;
n. 熊; (在证券市场等) 卖空的人;
facility
n. 设施; 设备; (机器等的) 特别装置; (服务等的) 特色; (供特定用途的) 场所; (学习、做事的) 天资,才能,天赋;
property
n. 所有物; 财产; 财物; 不动产; 房地产; 房屋及院落; 庄园;
disguised
v. 假扮; 装扮; 伪装; 掩蔽; 掩饰;
[词典] disguise的过去分词和过去式;
disguise
v. 假扮; 装扮; 伪装; 掩蔽; 掩饰;
n. 伪装物; 化装用具; 假扮; 装扮; 伪装;
colony
n. 殖民地; 殖民地定居者群体; (来自同一地方,职业或兴趣相同的) 聚居人群;
patrolled
v. 巡逻; 巡查; (尤指威胁性地) 逛荡,闲逛;
[词典] patrol的过去分词和过去式;
patrol
v. 巡逻; 巡查; (尤指威胁性地) 逛荡,闲逛;
n. 巡逻; 巡查; 巡逻队; 巡逻车队; 童子军小队;
duplicated
v. 复制; 复印; 复写; (尤指不必要时) 重复,再做一次;
[词典] duplicate的过去分词和过去式;
duplicate
v. 复制; 复印; 复写; (尤指不必要时) 重复,再做一次;
adj. 完全一样的; 复制的; 副本的;
n. 完全一样的东西; 复制品; 副本;
contradicited
v. 反驳; 驳斥; 批驳; 相抵触; 相矛盾; 相反;
[词典] contradict的过去分词和过去式;
contradict
v. 反驳; 驳斥; 批驳; 相抵触; 相矛盾; 相反;
neglected
adj. 被忽略的; 被忽视的; 未被重视的;
v. 疏于照顾; 未予看管; 忽略; 忽视; 不予重视; 疏忽; 疏漏;
[词典] neglect的过去分词和过去式;
neglect
v. 疏于照顾; 未予看管; 忽略; 忽视; 不予重视; 疏忽; 疏漏;
n. 忽略; 忽视; 未被重视;
fragment
n. 碎片; 片段;
v. (使) 碎裂,破裂,分裂;
advance
n. (尤指武装部队的) 前进,行进; 进步; 进展; 预付款;
v. (为了进攻、威胁等) 前进,行进; (知识、技术等) 发展,进步; 促进; 推动;
adj. 预先的; 事先的; 先遣队; 先头部队;
advancement
n. 促进; 推动; 发展; 前进; (工作、社会等级等的) 提升,晋升;
from the outset
[词典] 在开始时/ 从一开始;
at that point
[词典] 就在那时;

Section II

Test 1
scorned
v. 轻蔑; 鄙视; 不屑于(接受或做); 轻蔑地拒绝;
[词典] scorn的过去分词和过去式;
district
n. 地区; 区域; 区; 管区; 行政区;
exception
n. 一般情况以外的人(或事物); 例外; 规则的例外; 例外的事物;
revising
v. 改变,修改(意见或计划); 修改,修订(书刊、估算等); 复习; 温习;
[词典] revise的现在分词;
with the exception of
[词典] 除……外;
count for
占(比例)
complicated
adj. 复杂的; 难懂的;
v. 使复杂化;
implication
n. 可能的影响(或作用、结果); 含意; 暗指; (被) 牵连,牵涉;
ritual
n. 程序; 仪规; 礼节; (尤指) 宗教仪式; 习惯; 老规矩;
adj. 仪式上的; 庆典的; 习惯的; 老套的; 例行公事的;
inflexible
adj. 缺乏弹性的; 僵化的; 固守己见的; 死板的; 顽固的; 不能弯曲的; 硬的;
mandate
n. (政府或组织等经选举而获得的) 授权; (政府的) 任期; 委托书; 授权令;
v. 强制执行; 委托办理; 授权;
preference
n. 偏爱; 爱好; 喜爱; 偏爱的事物; 最喜爱的东西;
tend to do
网络 倾向于做; 倾向于; 趋向;
compete
v. 竞争; 对抗; 参加比赛(或竞赛);
trend
n. 趋势; 趋向; 倾向; 动态; 动向;
vi. 倾向; 趋势;
address
对付;
exception
n. 一般情况以外的人(或事物); 例外; 规则的例外; 例外的事物;
compete
v. 竞争; 对抗; 参加比赛(或竞赛);
competitive
adj. 竞争的; (与…) 一样好的; (比…) 更好的; 有竞争力的; 努力竞争的; 一心求胜的;
complete
adj. (用以强调) 完全的,彻底的; 全部的; 完整的; 整个的; 包括,含有(额外部分或特征);
v. 完成; 结束; 填写(表格); 使完整; 使完美;
chaotic
adj. 混乱的; 杂乱的; 紊乱的;
contradictory
adj. 相互矛盾的; 对立的; 不一致的;
n. 对立物; 矛盾因素;
contradict
v. 反驳; 驳斥; 批驳; 相抵触; 相矛盾; 相反;
assigned
v. 分配(某物); 分派,布置(工作、任务等); 指定; 指派; 委派; 派遣;
[词典] assign的过去分词和过去式;
essentially
adv. 本质上; 根本上; 基本上;
thorny
adj. 棘手的; 麻烦的; 引起争议的; 有刺的; 多刺的;
preference
n. 偏爱; 爱好; 喜爱; 偏爱的事物; 最喜爱的东西;
prefer
v. 较喜欢; 喜欢…多于…;
interpretation
n. 理解; 解释; 说明; 演绎; 演奏方式; 表演方式;
interpret
v. 诠释; 说明; 把…理解为; 领会; 口译;
pending
prep. 在等待…时期; 直到…为止;
adj. 待定; 待决; 即将发生的;
v. 吊着; 悬而未决; 待决;
flat
adj. 水平的; 平坦的; 平滑的;
n. 一套房间; 公寓; 单元房; (某物的) 平面部分; (尤指水边的) 平地; 低洼地;
adv. (尤指贴着另一表面) 平直地,平躺地; 断然; 直截了当地; 低于标准音高;
across-the-board
adj. 全面的;包括一切的; 在固定时间内播送的;
indifference
n. 漠不关心; 冷淡; 不感兴趣; 无动于衷;
conversely
adv. 相反地; 反过来;
correct
adj. 准确无误的; 精确的; 正确的; 恰当的; 合适的; (举止言谈) 符合公认准则的,得体的;
v. 改正; 纠正; 修正; 批改; 改; 指出错误;
review
n. 评审,审查,检查,检讨(以进行必要的修改); (对书籍、戏剧、电影等的) 评介,评论; 报告; 汇报; 述评; 回顾;
v. 复查; 重新考虑; 回顾; 反思; 写(关于书籍、戏剧、电影等的)评论; 评介;
meaningful
adj. 严肃的; 重要的; 重大的; 意味深长的; 意在言外的; 意义明显的; 易于理解的;
put on hold
网络 暂停; 搁置; 暂时搁置;
conduct
v. 组织; 安排; 实施; 执行; 指挥(歌唱或音乐演奏); 带领; 引导; 为(某人)导游;
n. (人在某地或某种情况下的) 行为,举止; 经营方式; 管理方法; 实施办法;

Test 2
obsess
v. 使痴迷; 使迷恋; 使着迷; 唠叨; 挂牵; 念念不忘;
pervasive
adj. 遍布的; 充斥各处的; 弥漫的;
pervasiveness
网络 普遍性; 广泛性; 无处不在; 普及性; 牵扯性;
intrinsically
[词典] 本质地;固有地;内在地;从本质上(讲);
slice
n. (切下的食物) 薄片,片; 部分; 份额; 锅铲; (餐桌用) 小铲;
v. 把…切成(薄)片; 切; 割; 划; 削(球); 斜切打;
fuse
n. 保险丝; 熔断器; 导火线; 导火索; 引信; 信管; 雷管;
v. (使) 融合,熔接,结合; (使) 熔化; (使保险丝熔断而) 停止工作;
innocent
adj. 无辜的; 清白的; 无罪的; 无辜受害的; 成为牺牲品的; 无恶意的; 无冒犯之意的;
n. 无辜者,单纯的人(尤指天真无邪的孩子);
despaired
v. 绝望; 失去希望; 丧失信心;
[词典] despair的过去分词和过去式;
despair
n. 绝望;
v. 绝望; 失去希望; 丧失信心;
domestic
adj. 本国的; 国内的; 家用的; 家庭的; 家务的; 喜爱家庭生活的; 享受家庭乐趣的; 乐于操持家务的;
n. 家佣; 佣人; 家庭纠纷; 家庭矛盾;
neutral
adj. 中立的; 持平的; 无倾向性的; 中立国的; 中性的; 不含褒贬义的;
n. (汽车排挡) 空挡的; 中立者; 中立国; 素净色; 中和色;
masculine
adj. 男子汉的; 男人的; 像男人的; 阳性的;
n. (词语的) 阳性; 阳性词; 阳性词形;
pastel
n. 彩色粉笔; 蜡笔; 粉笔; 彩色粉笔画; 蜡笔画;
constancy
n. 稳定性; 持久不变; 始终如一; 忠诚; 忠实; 忠贞;
constant
生的; 不断的; 重复的; 不变的; 固定的; 恒定的;
n. 常数; 常量;
faithfuness
n. 忠实;
femininity
n. 女子气质; 女气; 阴柔;
inherently
adv. 天性地,固有地;
critical
adj. 批评的; 批判性的; 挑剔的; 极重要的; 关键的; 至关紧要的; 严重的; 不稳定的; 可能有危险的;
profoundly
adv. 极大地; 深刻地; 严重地; 完全地; 彻底地;
dictated
v. 口述; (尤指以令人不快的方式) 指使,强行规定; 支配; 摆布; 决定;
[词典] dictate的过去分词和过去式;
dictate
v. 口述; (尤指以令人不快的方式) 指使,强行规定; 支配; 摆布; 决定;
n. 命令; 规定;
counsel
n. (尤指年长者或专家的) 劝告,忠告,建议; 法律顾问; 律师;
v. 提供专业咨询; 建议,劝告(做某事);
category
n. (人或事物的) 类别,种类;
innocence
n. 清白; 无辜; 无罪; 天真; 纯真; 单纯;
innocent
adj. 无辜的; 清白的; 无罪的; 无辜受害的; 成为牺牲品的; 无恶意的; 无冒犯之意的;
n. 无辜者,单纯的人(尤指天真无邪的孩子);
colour
n. 颜色; 色彩; 彩色; (尤指脸色的) 红润,粉红; (尴尬时的) 脸红;
v. (用颜料、彩色笔等) 为…着色; (因尴尬而) 脸红; (尤指负面地) 影响;
prefer
v. 较喜欢; 喜欢…多于…;
perception
n. 知觉; 感知; 洞察力; 悟性; 看法; 见解;
perceptual
adj. 知觉的; 感知的;
consumption
n. (能量、食物或材料的) 消耗,消耗量; 消费; 肺病; 肺痨; 肺结核;

Test 3
shook
v. 摇动; 抖动; (使) 颤动; 摇(出); 抖(掉); 摇头;
[词典] shake的过去式;
shake
v. 摇动; 抖动; (使) 颤动; 摇(出); 抖(掉); 摇头;
n. 摇动; 抖动; 颤动; 颤抖; 战栗; 哆嗦;
executive
n. (公司或机构的) 经理,主管领导,管理人员; (统称公司或机构的) 行政领导,领导层; (政府的) 行政部门;
adj. 经营管理的; 经理的; 决策的; 有执行权的; 实施的; 行政的; 高级的; 供重要人物使用的;
agitated
adj. 焦虑不安的; 激动的;
v. (尤指为法律、社会状况的改变而) 激烈争论,鼓动,煽动; 激怒; 使不安; 使激动; 搅动; 摇动(液体等);
[词典] agitate的过去分词和过去式;
agitate
v. (尤指为法律、社会状况的改变而) 激烈争论,鼓动,煽动; 激怒; 使不安; 使激动; 搅动; 摇动(液体等);
preliminary
adj. 预备性的; 初步的; 开始的;
n. 初步行动(或活动); 预备性措施;
temporarily
adv. 暂时;
suppress
v. 镇压; (武力) 平定; 压制; 禁止(发表); 查禁; 封锁; 抑制; 控制; 忍住;
innovation
n. (新事物、思想或方法的) 创造; 创新; 改革; 新思想; 新方法;
monopoly
n. 垄断; 专营服务; 被垄断的商品(或服务); 独占; 专利; 专利品; “大富翁”(棋类游戏,游戏者以玩具钞票买卖房地产);
urged
v. 敦促; 催促; 力劝; 大力推荐; 竭力主张; 驱赶; 鞭策;
[词典] urge的过去分词和过去式;
urge
v. 敦促; 催促; 力劝; 大力推荐; 竭力主张; 驱赶; 鞭策;
n. 强烈的欲望; 冲动;
reform
v. 改革; 改进; 改良; (使)改正,改造(行为) ; (使) 悔改;
n. 改革; 变革; 改良; 改善;
cotton
n. 棉,棉花(植株); 棉织物; 棉布; 棉线; 棉纱;
v. 一致; 理解; 和谐; 亲近;
despite
prep. 即使; 尽管; 尽管(自己)不愿意;
sequencing
n. (对基因、DNA的) 排序;
v. 按顺序排列; 测定(整套基因或分子成分的)序列;
[词典] sequence的现在分词;
sequence
n. 一系列; 一连串; 顺序; 次序; (电影中表现同一主题或场面的) 一组镜头;
v. 按顺序排列; 测定(整套基因或分子成分的)序列;
genome
n. 基因组; 染色体组;
efficacy
n. (尤指药物或治疗方法的) 功效,效验,效力;
convention
n. 习俗; 常规; 惯例; (某职业、政党等成员的) 大会,集会; (国家或首脑间的) 公约,协定,协议;
session
n. 一场; 一节; 一段时间; (法庭的) 开庭,开庭期; (议会等的) 会议,会期; 学年;
patent
n. 专利权; 专利证书;
adj. 有专利的; 受专利保护的; 专利生产的; 专利经销的; 明显的; 赤裸裸的;
v. 获得专利权;
establish
v. 建立; 创立; 设立; 建立(尤指正式关系); 确立; 使立足; 使稳固;
authoritative
adj. 命令式的; 专断的; 权威式的; 权威性的;
be keen to
热衷于

Test 4
ultimately
adv. 最终; 最后; 终归; 最基本地; 根本上;
lime
n. 石灰; 酸橙; 酸橙汁; 酸橙树;
v. (尤指为控制酸度而给土壤) 掺加石灰,撒石灰;
prudent
adj. 谨慎的; 慎重的; 精明的;
reckless
adj. 鲁莽的; 不计后果的; 无所顾忌的;
stagnation
n. 停滞; 滞止; 萧条; 迟钝;
stagnate
v. 停滞; 不发展; 不进步; 因不流动而变得污浊;
spirited
adj. 精神饱满的; 坚定的; 勇猛的;
v. 偷偷带走; 让人不可思议地弄走;
[词典] spirit的过去式;
incllusive
adj. 包含全部费用; 包括所提到的费用在内; 包括提到的所有的天数(或月、数目等)在内; 包容广阔的; 范围广泛的;
reversed
v. 颠倒; 彻底转变; 使完全相反; 撤销,废除(决定、法律等); 使反转; 使次序颠倒;
[词典] reverse的过去分词和过去式;
sentiment
n. (基于情感的) 观点,看法; 情绪; (失之过度或不恰当的) 伤感,柔情,哀伤;
conflict
n. 冲突; 争执; 争论; (军事) 冲突; 战斗; 抵触; 矛盾; 不一致;
v. (两种思想、信仰、说法等) 冲突,抵触;
inequality
n. 不平等; 不平衡; 不平均;
beneath
prep. 在(或往)…下面; 在(或往)…下方; (对某人来说) 不够好;
adv. 在下面; 在底下;
resentment
n. 愤恨; 怨恨;
conflict
n. 冲突; 争执; 争论; (军事) 冲突; 战斗; 抵触; 矛盾; 不一致;
v. (两种思想、信仰、说法等) 冲突,抵触;
faric
n. 织物; 布料; (社会、机构等的) 结构; (建筑物的)结构(如墙、地面、屋顶) ;
prudence
n. 谨慎; 慎重; 精明;
prudent
adj. 谨慎的; 慎重的; 精明的;
due to
[词典] 由于,应付;
destructive
adj. 引起破坏(或毁灭)的; 破坏(或毁灭)性的;

Part B
accomplish
v. 完成;
sage
n. 鼠尾草(可用作调料); 哲人; 智者; 圣人;
adj. 睿智的,贤明的(尤指因经验丰富);
biterary
adj. 文学的; 文学上的; 适于文学作品的; 有典型文学作品特征的; 爱好文学的; 从事文学研究(或写作)的;
craze
n. (通常为一时的) 狂热,疯狂; 风行一时的东西;
empathy
n. 同感; 共鸣; 同情;
inspiration
n. 灵感; 启发灵感的人(或事物); 使人产生动机的人(或事物); 鼓舞人心的人(或事物);
excemplary
adj. 典范的; 可作榜样的; 可作楷模的; 严厉的; 儆戒性的; 惩戒性的;
rambling
adj. 向四处延伸的; 规划凌乱的; 冗长而含糊的; 不切题的; 蔓生的; 攀缘生长的;
n. 乡间漫步; 漫无目的的讲话; 长而离题的文章;
v. 漫游,漫步,闲逛(尤指在乡间); 漫谈; 闲聊; 瞎扯; 蔓生; 攀附生长;
ramble
v. 漫游,漫步,闲逛(尤指在乡间); 漫谈; 闲聊; 瞎扯; 蔓生; 攀附生长;
n. 漫步; 散步; 杂乱无章的长篇大论;
celebrated
adj. 著名的; 闻名的; 驰名的;
v. 庆祝; 庆贺; 主持宗教仪式(尤指圣餐); 赞美; 颂扬; 歌颂;
[词典] celebrate的过去分词和过去式;
celebrate
v. 庆祝; 庆贺; 主持宗教仪式(尤指圣餐); 赞美; 颂扬; 歌颂;
conquering
v. 占领; 攻克; 征服; (尤指比赛、赛跑等中) 击败,战胜; (成功地) 对付,克服,控制;
[词典] conquer的现在分词;
conquer
v. 占领; 攻克; 征服; (尤指比赛、赛跑等中) 击败,战胜; (成功地) 对付,克服,控制;
championed
v. 为…而斗争; 捍卫; 声援;
champion
n. 冠军; 第一名; 优胜者; 斗争者; 捍卫者; 声援者; 拥护者;
v. 为…而斗争; 捍卫; 声援;
cunning
adj. 狡猾的; 奸诈的; 诡诈的; 灵巧的; 精巧的; 巧妙的;
n. 狡猾; 诡诈; 狡黠;
ruthlessness
网络 无情; 冷酷无情; 冷酷; 无情的残酷; 残忍;
ruthless
adj. 残酷无情的; 残忍的;
boldness
n. 大胆;显著;
mercy
n. 仁慈; 宽恕; 幸运; 恩惠;
attribute
v. 把…归因于; 认为…是由于; 认为是…所为(或说、写、作);
n. 属性; 性质; 特征;
commemorate
v. (用…) 纪念; 作为…的纪念;
glory
n. 荣誉; 光荣; 桂冠; (对上帝的) 赞颂,赞美,崇拜; 壮丽; 辉煌; 灿烂;
v. 夸耀; 得意;
satalogue
n. 目录; 目录簿; 一连串(糟糕)事;
v. 列入目录; 编入目录; 记载,登记(某人、某事等的详情);
furnish
v. 布置家具; 向(某人 / 某事物)供应,提供;
steadfast
adj. 坚定的; 不动摇的;
integrity
n. 诚实正直; 完整; 完好;
noble
adj. 崇高的; 品质高尚的; 宏伟的; 壮丽的; 贵族的; 高贵的;
n. 出身高贵的人; 贵族成员;
exhibit
v. 展览; 展出; 表现,显示,显出(感情、品质或能力);
n. (一件) 展览品,陈列品; (在法庭上出示的) 物证,证据;
resolute
adj. 坚决的; 有决心的;
beacon
n. (指引车船等的) 灯标,灯塔; 立标; (导航) 无线电信标台; (昔日) 烽火;
bourgeois
adj. 中产阶级的; 追求名利且平庸的; 世俗的; 资产阶级的; 资本家的;
n. 有产者,资产阶级; 中产阶级的人; 业主,店主; [印] 〈古〉九点活字;
heroic
adj. 英勇的; 英雄的; 有必胜决心的; 不畏艰难的; (关于) 英雄的;
n. 英雄诗; 史诗; 英勇行为; 夸张的言行; 咬文嚼字; 文诌诌;
epochal
adj. 划时代的;开创新纪元的;
imitate
v. 模仿; 仿效; 模仿(某人的讲话、举止); 作滑稽模仿;
mortal
adj. 不能永生的; 终将死亡的; 导致死亡的; 致命的; 非常危急的; 至死方休的; 不共戴天的;
n. 人; 凡人; 普通人;
bombast
n. 华而不实的言辞; 大话;
hitherto
adv. 迄今; 直到某时;
immense
adj. 极大的; 巨大的;
waged
adj. 领工资的; 有定期付酬工作的; 支取工资的; 带薪的; 工薪阶层; (统称) 拿工资的人;
v. 开始,发动,进行,继续(战争、战斗等);
[词典] wage的过去分词和过去式;
wage
n. (通常指按周领的) 工资,工钱;
v. 开始,发动,进行,继续(战争、战斗等);
reality
n. 现实; 实际情况; 事实; 实际经历; 见到的事物;
context
n. (事情发生的) 背景,环境,来龙去脉; 上下文; 语境;
circumstance
n. 条件; 环境; 状况; 境况; 境遇; (尤指) 经济状况; 命运; 客观环境;
vt. 使处于某种特定的情况之下;
transmitted
v. 传送; 输送; 发射; 播送; 传播; 传染; 传(热、声等); 透(光等); 使通过;
appreciation
n. 欣赏; 理解; 体谅; 同情; 感激; 感谢;
murture
v. 养育; 养护; 培养; 扶持; 帮助; 支持; 滋长; 助长;
n. 养育; 培养;
realm
n. 领域; 场所; 王国;
multiplicity
n. 多样性; 多种多样;
depict
v. 描绘; 描画; 描写; 描述; 刻画;

2013

Section I

Section II

Test 1
stubbornly
adv. 顽固地; 顽强; 傲然地; 斩钉截铁地;
genius
n. 天才; 天资; 天赋; 天才人物; (某领域的) 天才; (特别的) 才能,本领;
shed
n. 简易房,棚(用于贮藏物品); (工业上用于生产或存放设备的) 厂房,工棚,库房; 剪羊毛棚; 挤奶棚;
v. 去除; 摆脱; 使落下; 使掉下; 掉落(货物);

Test 2
sojuurner
网络 索杰纳; 旅居者; 逗留者; 寄居者; 旅居者号;
folk
n. 人们; 各位; 大伙儿; 亲属; 家属; (尤指) 爹妈;
adj. 传统民间的; 民俗的; 流传民间的; 普通百姓的;

affectionate
adj. 表示关爱的;
affection
n. 喜爱; 钟爱; 爱情;
affect
v. 影响; 侵袭; 使感染; (感情上) 深深打动; 使悲伤(或怜悯等);
effect
n. 效应; 影响; 结果; (艺术家或作家所要创造的特定) 外观,声响,印象,效果; (个人) 财产,所有物,财物;
v. 使发生; 实现; 引起;
effective
adj. 产生预期结果的; 有效的; 实际的; 事实上的; 生效的; 起作用的;
n. [军] 现役兵额; 有生力量; 精兵;
rigid
adj. 死板的; 僵硬的; 固执的; 僵化的; 一成不变的; 坚硬的; 不弯曲的; 僵直的;
hail
v. 赞扬(或称颂)…为…(尤用于报章等); 招手(请出租车或公共汽车停下); 跟…打招呼; 向…喊;
n. 雹; 冰雹; 一阵像冰雹般袭来的事物; 雹子般的一阵;
alien
adj. 陌生的; 不熟悉; 外国的; 异域的; 不相容; 相抵触; 格格不入;
n. 外国人; 外侨; 外星人; 外星生物;
mightily
adv. 很; 非常; 全力以赴地; 极其努力地;
mighty
adj. 强而有力的; 巨大的; 非凡的;
adv. 非常; 很; 极其;

paralysis
n. 麻痹; 瘫痪; (活动、工作等) 能力的完全丧失;
parallel
adj. 平行的; 极相似的; 同时发生的; 相应的; 对应的; 并行的;
n. (尤指不同地点或时间的)极其相似的人(或情况、事件等) ; 相似特征; 相似特点; (地球或地图的) 纬线,纬圈;
v. 与…相似; 与…同时发生; 与…媲美; 比得上;
violinist
n. 小提琴手; 小提琴演奏者;
construction
n. 建筑; 建造; 施工; 建造(或构造)的方式; 建造物; 构筑物; 制成物;
straddle
v. 骑; 跨坐; 分腿站立; 跨过,横跨(河流、道路或一片土地); 横跨,同属(不同时期、活动或群体); 两栖于(不同活动);
jurisdiction
n. 司法权; 审判权; 管辖权; 管辖区域; 管辖范围;
accommodating
adj. 乐于助人的; 与人方便的;
v. 为(某人)提供住宿(或膳宿、座位等); 容纳; 为…提供空间; 考虑到; 顾及;
[词典] accommodate的现在分词;
accommodate
v. 为(某人)提供住宿(或膳宿、座位等); 容纳; 为…提供空间; 考虑到; 顾及;
accomplish
v. 完成;

Test 3
prone
adj. 易于遭受; 有做(坏事)的倾向; 有做…倾向的; 易于遭受…的; 俯卧的;
snap
v. (使喀嚓) 断裂,绷断; (使啪地) 打开,关上,移到某位置; 厉声说; 怒气冲冲地说; 不耐烦地说;
n. (尤指关上或断裂的声音) 啪嗒声,咔嚓声; (尤指抢拍的) 照片; “对儿”牌游戏(游戏者轮流下牌,出现相同的牌时要抢先喊“对儿”);
adj. 匆忙的; 仓促的;
overreaction
n. 小题大作;
defense
n. 防卫,防护;防御措施;防守;
v. 谋划抵御;
assess
v. 评估,评定(性质、质量); 估算,估定,核定(数量、价值);
neuroticism
n. 不稳定;
prime
adj. 主要的; 首要的; 基本的; 优质的; 上乘的; 优异的; 典型的; 有代表性的;
n. 盛年; 年富力强的时期; 鼎盛时期; [数] 质数;
v. 事先指点; 使(某人)做好准备; 把(事物)准备好; 在(金属、木材等上)打底漆;

impulse
n. 冲动; 心血来潮; 一时的念头; 脉冲; 冲击; 冲量; 推动力; 刺激;
reverse
v. 颠倒; 彻底转变; 使完全相反; 撤销,废除(决定、法律等); 使反转; 使次序颠倒;
n. 相反的情况(或事物); 后面; 背面; 反面; 倒挡;
adj. 相反的; 反面的; 反向的; 背面的; 后面的;
mute
adj. 沉默的; 不出声的; 无声的; 哑的;
n. 弱音器; 哑巴;
v. 消音; 减音; 减弱(尤指乐器)的声音; 减弱; 缓解;
contemplating
v. 考虑; 思量; 思忖; 考虑接受(发生某事的可能性); 深思熟虑; 沉思; 苦思冥想;
[词典] contemplate的现在分词;
contemplate
v. 考虑; 思量; 思忖; 考虑接受(发生某事的可能性); 深思熟虑; 沉思; 苦思冥想;
temptation
n. 引诱; 诱惑; 煽诱人的事物;
urgency
n. 紧迫; 急迫; 急事; 紧要;
associative
adj. 联想的; 结合的;
associate
v. 联想; 联系; 交往; (尤指) 混在一起; 表明支持; 表示同意;
adj. 非正式的; 准的; 副的; 联合的; 有关联的;
n. 同事; 伙伴; 合伙人; 准学士(获得两年制高校学位);
reverse
v. 颠倒; 彻底转变; 使完全相反; 撤销,废除(决定、法律等); 使反转; 使次序颠倒;
n. 相反的情况(或事物); 后面; 背面; 反面; 倒挡;
adj. 相反的; 反面的; 反向的; 背面的; 后面的;

Test 4
frustration
n. 懊丧; 懊恼; 沮丧; 令人懊丧(或懊恼、沮丧)的事物; 受阻; 受挫; 阻止; 挫败;
frustrate
v. 使懊丧; 使懊恼; 使沮丧; 阻止; 防止; 挫败;
provision
n. 提供; 供给; 给养; 供应品; (为将来做的) 准备; 饮食供应; (尤指旅途中的) 粮食;
v. 为…提供所需物品(尤指食物);
provide
v. 提供; 供应; 给予; 规定;
reluctance
n. 不情愿; 磁阻; 厌恶; 反抗 (to; at);
meritocracy
n. 精英领导体制; 英才管理制度; 精英管理班子;
run counter to
[词典] 与…相对; 与…冲突;
meritocratic
adj. 精英领导的; 贤能统治的;
appropriate
adj. 合适的; 恰当的;
v. 盗用; 挪用; 占用; 侵吞; 拨(专款等);
caregiver
n. 照料家居老弱病患者的人; 家庭护理员;
reluctant
adj. 不情愿的; 勉强的;

Part B
peasant
n. (尤指昔日或贫穷国家的) 农民,小农,佃农; 老粗; 土包子; 没教养的人;
chronicle
n. 编年史; 历史;
v. 把…载入编年史; 按事件发生顺序记载;
validation
n. 生效;批准;验证;确认;证实;核实;
council
n. (市、郡等的) 政务委员会,地方议会; 市政(或地方管理)服务机构; (顾问、立法、研究、基金等) 委员会;
impulsive
adj. 凭冲动行事的; 易冲动的;
ingredient
n. 成分; (尤指烹饪) 原料; (成功的) 因素,要素;
anonymity
n. 匿名; 不知姓名; 名字不公开; 无特色; 无个性特征;
embarrassment
n. 害羞; 窘迫; 愧疚; 难堪; 使人为难的处境; 困境; 令人为难(或难堪、尴尬)的人;
rasher
n. 火腿薄片;
adj. 轻率的; 鲁莽的;
[词典] rash的比较级;
rash
n. 皮疹; 疹; 大量; 许多; (涌现的) 令人不快的事物;
adj. 轻率的; 鲁莽的;
frugal
adj. (对金钱、食物等) 节约的,节俭的; 简单廉价的;

2014

English Vocabulary

发表于 2019-10-28

1994

Section 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
utmost
adj. 最大的; 极度的;
n. 最大量; 最大限度; 极限; 最大可能;
prevent
v. 阻止; 阻碍; 阻挠;
stir
v. 搅动; 搅和; 搅拌; (使) 微动; (使) 行动,活动;
n. (一些人感到的) 激动,愤怒,震动; 搅动; 搅和; 搅拌;
stir up
[词典] 扬起(灰尘); 卷起(泥浆); 挑起,引起(不愉快的情绪或事态);
interfere
v. 干涉; 干预; 介入;
comprehension
n. 理解力; 领悟能力; (语言学习中的)理解练习(或训练) ;
hence
adv. 因此; 由此;
transmission
n. 传送; 传递; 传达; 传播; 传染; (电子信号、信息或广播、电视节目的) 播送,发射,发送,传输; (电台或电视) 信息,广播;
reception
n. 接待处; 接待区; 接待仪式; 欢迎会; 招待会; 欢迎; 反应; 反响;
preliminarily
网络 初步; 预先; 初步地;
obscure
adj. 无名的; 鲜为人知的; 费解的; 难以理解的;
v. 使模糊; 使隐晦; 使费解;

##

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
couple with
[词典] 与…连接在一起;
mechanism
n. 机械装置; 机件; 方法; 机制; (生物体内的) 机制,构造;
respond
v. (口头或书面) 回答,回应; 作出反应; 响应; 反应灵敏; 作出正确反应;
bid
v. 出(价); (尤指拍卖中) 喊价; 投标; 努力争取; 企图获得;
n. 买方的出价; 投标; 努力争取;
v. 向(某人)问候、道别等; 告诉(某人做某事); 吩咐;
embrace
v. 抱; 拥抱; 欣然接受,乐意采纳(思想、建议等); 信奉(宗教、信仰等); 包括; 包含;
n. 拥抱,怀抱;
overstate
v. 夸大; 夸张; 言过其实;

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
withdraw
v. (使) 撤回,撤离; 停止提供; 不再给予; (使) 退出;
deposit
n. 订金; 订钱; 押金; 存款;
v. 放下; 放置; 使沉积; 使沉淀; 使淤积; 将(钱)存入银行; 存储;
ring up
[词典] 给…打电话; 把(钱款)记入(收款机); 赚取; 盈利;
staff
n. 全体职工(或雇员); (大、中、小学的) 管理人员,行政人员; (军队的) 全体参谋人员;
v. 在…工作; 任职于; 为…配备职员;
assignment
n. (分派的) 工作,任务; (工作等的) 分派,布置;
assign
v. 分配(某物); 分派,布置(工作、任务等); 指定; 指派; 委派; 派遣;
prefer
v. 较喜欢; 喜欢…多于…;
promotional
adj. 广告宣传的; 推销的;
promote
v. 促进; 推动; 促销; 推销; 提升; 晋升;
rely on
v. 依靠; 信赖;
utilitiy
n. 公用事业; 实用; 效用; 有用; 实用程序; 公用程序;
adj. 多用途的; 多效用的; 多功能的;
processor
n. 加工机(或工人); 处理器; 处理机;
approach
v. (在距离或时间上) 靠近,接近; 接洽; 建议; 要求; (在数额、水平或质量上) 接近;
n. (待人接物或思考问题的) 方式,方法,态度; (距离和时间上的) 靠近,接近; 接洽; 建议; 要求;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
exceptional
adj. 杰出的; 优秀的; 卓越的; 异常的; 特别的; 罕见的;
scenery
n. 风景; 景色; 风光; 舞台布景;
interpret
v. 诠释; 说明; 把…理解为; 领会; 口译;
confirm
v. (尤指提供证据来) 证实,证明; 使感觉更强烈; 使确信; 批准(职位、协议等); 确认; 认可;
appropriate
adj. 合适的; 恰当的;
v. 盗用; 挪用; 占用; 侵吞; 拨(专款等);
modify
v. 调整; 稍作修改; 使更适合; 缓和; 使温和; 修饰;
instruction
n. 用法说明; 操作指南; 指示; 命令; 吩咐; (计算机的) 指令;
adj. 说明用法的; 操作指南的;
substantially
adv. 非常; 大大地; 基本上; 大体上; 总的来说;
substantial
adj. 大量的; 价值巨大的; 重大的; 大而坚固的; 结实的; 牢固的;
n. 本质; 重要材料;
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
arise
v. 发生; 产生; 出现; (由…) 引起; (因…) 产生; 发展;
caiution
n. 谨慎; 小心; 慎重; (警察向犯轻罪的人发出的) 警告; (对危险或风险的) 警告,告诫;
v. 警告; 告诫; 提醒; 提醒(某人说的任何话都可能在法庭上被当作对其不利的证据); 警告(某人不得再做错事或非法的事);
survive
v. 生存; 存活; 继续存在; 幸存; 幸免于难; 艰难度过; 比…活(或存在)的时间长;
estimate
n. (对数量、成本等的) 估计; 估价; 估计的成本;
v. 估价; 估算;
discourage
v. 阻拦; 阻止; 劝阻; 使灰心; 使泄气; 使丧失信心;
discover
v. (第一个) 发现; (出乎意料地) 发现,找到,发觉; 了解到; 认识到; 查明;
oncogene
n. 癌基因;
remain
v. 仍然是; 保持不变; 剩余; 遗留; 继续存在; 仍需去做(或说、处理);
cancerous
adj. 癌的; 癌性的;
exact
adj. 精确的; 准确的; 严谨的; 严格的; 一丝不苟的; 精密的; 严密的;
v. 要求; 索取; 迫使; 强迫; 强求;
involved
adj. 参与; 作为一部分; 有关联; 耗费很多时间; 关注; 关系密切;
v. 包含; 需要; 使成为必然部分(或结果); 牵涉; 牵连; 影响; (使) 参加,加入;
[词典] involve的过去分词和过去式;
Involve
v. 包含; 需要; 使成为必然部分(或结果); 牵涉; 牵连; 影响; (使) 参加,加入;
prevent
v. 阻止; 阻碍; 阻挠;
oncologist
n. 肿瘤学家;
responsible
adj. 有责任; 负责; 承担义务; 应受责备; 作为原因; 成为起因;
counteract
v. 抵制; 抵消; 抵抗;
counter
n. (商店、银行等的) 柜台; (某些棋盘游戏的) 筹码; (电子) 计数器,计算器;
v. 反驳; 驳斥; 抵制; 抵消;
adv. 逆向地; 相反地; 反对地;
predict
v. 预言; 预告; 预报;
drastic
adj. 极端的; 急剧的; 严厉的; 猛烈的;
fairly
adv. 一定地; 相当地; 公平合理地; 公正地; (用以强调) 简直,竟然;
ever-present
adj. 总是存在的;始终存在的;
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
discovery
n. 发现; 发觉; 被发现的事物(或真相、人);
untaught
网络 未教过的;
blinding
adj. 雪亮的; 刺眼的; 使人视线模糊的; 绝妙的; 精彩的;
v. 使变瞎; 使失明; 使眼花; 使目眩; 使思维混沌; 使失去判断力;
[词典] blind的现在分词;
legend
n. 传说; 传奇故事; (尤指某领域中的) 传奇人物; (地图或书中图表的) 图例,说明,解释;
mold
n. 模型,压模; 霉,霉菌; 类型;
v. 用可塑材料塑成(有某种形状的物体); 浇铸,塑造; 发霉;
there and then
[词典] 立即; 立刻;
experiment
n. 实验; 试验; 尝试; 实践;
v. 做试验; 进行实验; 尝试; 试用;
invention
n. 发明; 创意; 创造; 虚构; 编造; 虚构的故事;
innovation
n. (新事物、思想或方法的) 创造; 创新; 改革; 新思想; 新方法;
laborious
adj. 耗时费力的; 辛苦的;
consciously
adv. 有意识地,自觉地;
conscious
adj. 意识到; 注意到; 神志清醒的; 有知觉的; 有意识的; 慎重的; 有意的; 刻意的;
fanciful
adj. 空想的; 想象的; 装饰独出心裁的; 式样奇特的; 花哨的;
abstraction
n. 抽象概念; 抽象; 出神; 心神专注; 提取; 抽取; 分离;
suitcase
n. (旅行用的) 手提箱;
proposition
n. 提议,建议(尤指业务上的); 欲做的事; 待处理的问题; 任务; (美国) 法律修正议案;
v. 求欢;
propose
v. 提议; 建议; 打算; 希冀; 计划; 求婚;
route
n. 路线; 路途; (公共汽车和列车等的) 常规路线,固定线路; 途径; 渠道;
v. 按某路线发送;
alternate
adj. 交替的; 轮流的; 间隔的; 每隔(…天等)的;
v. 使交替; 使轮流; 交替; 轮流;
n. 代替者; 代理人; 候补者;
ignorant
adj. (对某事物) 不了解的; 无知的; 愚昧的; 无学识的; 很无礼的; 十分不懂规矩的;
experimentation
n. 实验; 试验; 尝试;
expert
n. 专家; 行家; 能手;
adj. 熟练的; 内行的; 专家的; 经验(或知识)丰富的;
vi. 以专家身份研究(或检查); 像专家那样研究(或检查); 由专家审读(书籍等)做专家工作; 担任专家; 成为高手(或能手);
assertion
n. 明确肯定; 断言; 声称; 使用; 主张;
diligent
adj. 孜孜不倦的; 勤勉的; 刻苦的;
drummer
n. 鼓手;

Translation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
horizon
n. 地平线; (欲望、知识或兴趣的) 范围,眼界;
genius
复数:geniuses
n. 天才; 天资; 天赋; 天才人物; (某领域的) 天才; (特别的) 才能,本领;
expand
v. 扩大,增加,增强(尺码、数量或重要性); 扩展,发展(业务); 细谈; 详述; 详细阐明;
innovation
n. (新事物、思想或方法的) 创造; 创新; 改革; 新思想; 新方法;
hail
v. 赞扬(或称颂)…为…(尤用于报章等); 招手(请出租车或公共汽车停下); 跟…打招呼; 向…喊;
n. 雹; 冰雹; 一阵像冰雹般袭来的事物; 雹子般的一阵;
innumerable
adj. 多得数不清的; 很多的;
innovation
n. (新事物、思想或方法的) 创造; 创新; 改革; 新思想; 新方法;
glory
n. 荣誉; 光荣; 桂冠; (对上帝的) 赞颂,赞美,崇拜; 壮丽; 辉煌; 灿烂;
v. 夸耀; 得意;
dispute
n. 争论; 辩论; 争端; 纠纷;
v. 对…提出质询; 对…表示异议(或怀疑); 争论; 辩论; 争执; 争夺; 竞争;

2000

Section 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
other than
[词典] (用于否定陈述后) 除了…以外;
instead of
prep. 代替; 作为…的替换;
only if
conj. 只有当;
much as
[词典] 虽然; 尽管;
ever since
[词典] 自从; 打…以后一直;
surplus
n. 过剩; 剩余; 过剩量; 剩余额; 盈余; 顺差;
adj. 过剩的; 剩余的; 多余的;
unpredictable
adj. 无法预言的; 不可预测的; 难以预料的; (人) 善变的,难以捉摸的;
commodity
n. 商品; 有用的东西; 有使用价值的事物;
fertilizer
n. 肥料;
dispose
v. 排列; 布置; 安排; 使倾向于; 使有意于; 使易于;
construct
v. 建筑; 修建; 建造; 组成; 创建; (按照数学规则) 编制,绘制;
n. (根据不总是真实的各种证据得出的) 构想,观念,概念; (短语的) 结构成分,结构体; 建造物; 构筑物; 制成物;
genuinely
adv. 由衷地; 真诚地; 真正地; 诚实地;
presumably
adv. 很可能; 大概; 想必是;

Section II

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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
handicap
n. 生理缺陷; 弱智; 残疾; 障碍; 阻碍; 让步赛(使参赛者中的优势方跑得较远、增加负重等); (让步赛中给优势方施加的) 障碍,不利条件;
v. 妨碍; 阻碍;
unparalleled
adj. 无比的; 无双的; 空前的; 绝无仅有的;
paralleled
adj. 并行的,平行的;
inevitable
adj. 不可避免的; 不能防止的; 总会发生的; 照例必有的; 惯常的; 必然发生的事; 不可避免的事;
primacy
n. 首要; 至高无上; 总主教职;
narrow
adj. 狭窄的; 窄小的; 勉强的; 刚刚好的; 狭隘的; 目光短浅的;
v. 使窄小; 变窄; 缩小;
n. 海峡; 狭路; 隘路; 狭窄的水道;
predominance
n. (数量上的) 优势; 主导地位; 支配地位; 霸业;
dominance
n. 支配; 控制;
vanish
v. (莫名其妙地) 突然消失; 不复存在; 消亡; 绝迹;
rope
n. 粗绳; 线缆; 绳索; (拳击或摔跤场四周的) 围绳,圈绳; 串在一起的相似的东西;
v. 用绳子捆(或绑、系); 用绳子系牢; 捆紧; 用套索抓捕(动物); 套;

casualty
n. (战争或事故的) 伤员,亡者,遇难者; 受害者; 毁坏物; 损坏物; 急诊室;
crisis
n. 危机; 危急关头; 危难时刻; 病危期;
prosperity
n. 兴旺; 繁荣; 成功; 昌盛;
granted
adv. (表示肯定属实,然后再作另一番表述) 不错,的确;
conj. 因为;
v. (尤指正式地或法律上) 同意,准予,允许; (勉强) 承认,同意;
grant
v. (尤指正式地或法律上) 同意,准予,允许; (勉强) 承认,同意;
n. (政府、机构的) 拨款;
fail
v. 失败; 未能(做到); 未做; 未履行(某事); 不及格; 评定不及格;
n. (考试) 不及格;
sensational
adj. 轰动的; 引起哗然的; 哗众取宠的; 耸人听闻的; 极好的; 绝妙的;
struggle
v. 奋斗; 努力; 争取; 艰难地行进; 吃力地进行; 斗争; 抗争;
n. 斗争; 奋斗; 努力; 搏斗; 扭打; (尤指) 抢夺,挣扎脱身; 难事;
attribute
v. 把…归因于; 认为…是由于; 认为是…所为(或说、写、作);
n. 属性; 性质; 特征;
solely
adv. 仅; 只; 唯; 单独地;
yield
v. 出产(作物); 产生(收益、效益等); 提供; **屈服; 让步; 放弃; 缴出;**
n. 产量; 产出; 利润;
dean
n. 座堂主任牧师; (乡间主管若干教堂牧师的) 主任牧师; (大学的) 学院院长,系主任;
painstaking
adj. 需细心的; 辛苦的; 需专注的;
impetus
n. 动力; 推动; 促进; 刺激; 动量; 惯性;
manifest
v. 表明,清楚显示(尤指情感、态度或品质); 显现; 使人注意到;
adj. 明显的; 显而易见的;
n. (船或飞机的) 货单,旅客名单;
withdraw
v. (使) 撤回,撤离; 停止提供; 不再给予; (使) 退出;
suicidal
adj. 想自杀的; 有自杀倾向的; 自杀性的; 有致命危险的; 毁灭性的; 灾难性的;
auto industry
[词典] 汽车工业;汽车业;汽车行业;
on the ropes
[词典] 处境艰难; 即将放弃; 濒临失败; 走投无路;
intense
adj. 很大的; 十分强烈的; 严肃紧张的; 激烈的; 有强烈感情(或意见、想法)的; 尖锐的; 热切的;
revival
n. (状况或力量的) 进步,振兴,复苏; 复兴; 再流行; (戏剧的) 重演;
pave
v. (用砖石)铺(地) ;
pave the way for
[词典] 鸣锣开道;

male
adj. 男性的; 雄性的; 男的; 阳的; **凸形的;**
n. 男性; 雄性; 雄株;
female
adj. 女的; 女性的; 雌的; 母的; 妇女的; 女性特有的;
n. 雌性动物; 雌性植物; 雌株; 女子;
maturity
n. (思想行为、作品等) 成熟; 成熟; 成年; 完全长成; 到期(应付款);
universal
adj. 普遍的; 全体的; 全世界的; 共同的; 普遍存在的; 广泛适用的;
n. [逻辑学] 全称命题; [哲学] 一般概念; 一般性;
mortality
n. 生命的有限; 死亡数量; 死亡率; 死亡;
excess
n. 超过; 过度; 过分; 过多的量; 超过的量; 免赔额; 自负额;
adj. 超额的; 额外的; 附加的; 过度的;
crucial
adj. 至关重要的; 关键性的;
removed
adj. 相异的; 不同的;
v. 移开; 拿开; 去掉; 从…机构开除; 脱去(衣服等); 摘下; 去除,排除(污渍、不愉快的事物等); 使消失;
[词典] remove的过去分词和过去式;
particularly
adv. 特别; 尤其;
variation
n. (数量、水平等的) 变化,变更,变异; 变异的东西; 变种; 变体; 变奏; 变奏曲;
agent
n. (企业、政治等的) 代理人,经纪人; (演员、音乐家、运动员、作家等的) 代理人; 原动力,动因(指对事态起重要作用的人、事物);
commit
v. 做出(错或非法的事); 犯(罪或错等); 自杀; 承诺,保证(做某事、遵守协议或遵从安排等);
fertile
adj. 肥沃的; 富饶的; 能生育的; 可繁殖的; 能结果的; 能产生好结果的; 促进的;
average
adj. 平均的; 典型的; 正常的; 普通的; 平常的; 一般的;
n. 平均数; 平均水平; 一般水准;
v. 平均为; 计算出…的平均数;
roughly
adv. 大约; 大致; 差不多; 粗暴地; 粗鲁地; 粗糙地; 凹凸不平地;
offspring
n. 孩子; 子女; 后代; 崽兽; 幼崽; 幼苗;
diminish
v. 减少; (使) 减弱,缩减; 降低; 贬低; 贬损; 轻视;
poverty
n. 贫穷; 贫困; 贫乏; 短缺; 劣质;
tribal
adj. 部落的; 部族的;
n. (尤指南亚的) 部落成员;
remaining
adj. 仍需做的; 还需处理的;
v. 仍然是; 保持不变; 剩余; 遗留; 继续存在; 仍需去做(或说、处理);
[词典] remain的现在分词;
grand
adj. 壮丽的; 堂皇的; 重大的; (用于大建筑物等的名称) 大; 宏大的; 宏伟的; 有气派的;
n. 1 000元; 1 000英镑;
mediocrity
n. 平庸; 普通; 平常; 平庸之人; 碌碌无为者;
tribe
n. 部落; (尤指同一职业的)一伙(人),一帮(人),一类(人) ; (动物或植物的) 群,族;
Utopia
n. 乌托邦; 空想的完美境界;
phrase
n. 短语; 词组; 成语; 习语; 惯用法; 警句; 乐句; 乐节;
v. (以某种方式) 表达,措辞,推敲; 划分乐句,分乐节(尤指为奏乐或歌唱);
igorant
adj. (对某事物) 不了解的; 无知的; 愚昧的; 无学识的; 很无礼的; 十分不懂规矩的;
savage
adj. 凶恶的; 凶残的; 损害严重的; 猛烈抨击的; 蒙昧的; 未开化的; 野蛮的;
n. 野蛮人; 未开化的人; 凶狠残暴的人;
v. 凶狠地攻击(或伤害); 残害; 猛烈批评; 激烈抨击;
ship
n. (大) 船; 舰;
v. 船运; 运输; 运送; 上市; 把…推向市场; 舷侧进水;
comprehension
n. 理解力; 领悟能力; (语言学习中的)理解练习(或训练) ;
ugliness
n. 丑恶,丑陋的事; 尴尬局面;
descendant
n. 后裔; 后代; 子孙; (由过去类似物发展来的) 派生物;
fierce
adj. 凶猛的; 凶狠的; 凶残的; 狂热的; 强烈的; 猛烈的; 狂暴的; 恶劣的;
defective
adj. 有缺点的; 有缺陷的; 有毛病的;
n. 身心有缺陷的人; 变化不全的词;
used to be
[词典] 过去是;
hardly
adv. 几乎不; 几乎没有; 尤用于can或could之后,主要动词之前,强调做某事很难; 刚刚; 才;

movement
n. (身体部位的) 运动,转动; 移动; 迁移; 转移; 活动; (具有共同思想或目标的) 运动;
advocate
v. 拥护; 支持; 提倡;
n. 拥护者; 支持者; 提倡者; 辩护律师; 出庭辩护人;
farfetched
adj. 牵强(附会)的;
unresonable
adj. 不合理的; 不公正的; 期望过高的;
regard
v. 将…认为; 把…视为; 看待; (尤指以某种方式) 注视,凝视;
n. 注意; 关注; 关心; 尊重; 尊敬; 敬佩; (用于信函结尾或转达问候) 致意,问候;
futurist
n. 未来主义者; 未来派艺术家; 未来派作家; 预测未来者; 未来学家;
literature
n. 文学; 文学作品; (某学科的) 文献,著作,资料;
conditionally
adv. 有条件地;
consequently
adv. 因此; 所以;
corresponding
adj. 符合的; 相应的; 相关的;
v. 相一致; 符合; 类似于; 相当于; 通信;
[词典] correspond的现在分词;
interpret
v. 诠释; 说明; 把…理解为; 领会; 口译;
stream
n. 小河; 溪; 流; (液) 流; (气) 流; (人) 流; (车) 流;
v. 流; 流动; 流出; 鱼贯而行; 一个接一个地移动; 飘动; 飘扬;
unhampered
adj. 无拘束的; 无阻碍的; 随心所欲的;
qualify
v. 取得资格(或学历); 合格; 使合格; 使具备资格; 有权,使有权(做某事);
adjective
n. 形容词;
finite
adj. 有限的; 有限制的; 限定的;
imitate
v. 模仿; 仿效; 模仿(某人的讲话、举止); 作滑稽模仿;
at will
[词典] 任意; 随意;
battle
n. 战役; 战斗; 搏斗; 较量; 争论; 斗争; 奋斗;
v. 搏斗; 奋斗; 斗争;
confused
adj. 糊涂的; 迷惑的; 不清楚的; 混乱的; 难懂的;
v. 使糊涂; 使迷惑; (将…) 混淆,混同; 使更难于理解;
explanatory
adj. 解释的; 说明的; 阐述的;
fulfill
v. 履行,执行,贯彻:; 完成,实现;兑现:; 达到;起到;做到:;
proposition
n. 提议,建议(尤指业务上的); 欲做的事; 待处理的问题; 任务; (美国) 法律修正议案;
v. 求欢;
survey
n. 民意调查; 民意测验; 测量; 勘测; 测绘; (尤指为欲购房者所做的) 房屋鉴定;
v. 查看; 审视; 审察; **总体研究; 全面评述; 概述;** 测量; 勘测; 测绘;
merit
n. 优点; 美德; 价值; 值得赞扬(或奖励、钦佩)的特点; 功绩; 长处; (学校或大学考试或作业的) 良好;
v. 应得; 值得;
production
n. 生产; 制造; 制作; 产量; (自然的) 产生,分泌;
relieve
v. 解除,减轻,缓和(不快或痛苦); 减轻(问题的严重性); 缓和; 缓解; 调剂; 使有趣;
indicative
adj. 表明; 标示; 显示; 暗示; 陈述的; 指示的;
n. 陈述语气的动词形式;
transient
adj. 短暂的; 转瞬即逝的; 倏忽; 暂住的; 过往的; 临时的;
n. 暂住某地的人; 过往旅客; 临时工;

aimlessness
网络 漫无目的; 无目的; 盲目性; 无目的性;
harmony
n. 融洽; 和睦; 和声; 和谐; 协调;
envy
n. 羡慕; 忌妒;
v. 羡慕; 忌妒; 庆幸不必做别人非做不可的事;
moral
adj. 道德的; 道义上的; 道德上的; 品行端正的; 有道德的;
n. 品行,道德(尤指性关系方面); 寓意; 教益;
fulfill
v. 履行,执行,贯彻:; 完成,实现;兑现:; 达到;起到;做到:;
entry
n. 进入(指行动); 进入(指权利等); 参与,加入(指权利、机会);
sacrifice
n. 牺牲; 舍弃; 祭献; 祭祀; 祭献的牲畜; 祭品;
v. 牺牲; 献出; 以(人或动物)作祭献;
rigid
adj. 死板的; 僵硬的; 固执的; 僵化的; 一成不变的; 坚硬的; 不弯曲的; 僵直的;
in addition
[词典] 另外; 加之; 除…之外;
counterpart
n. 职位(或作用)相当的人; 对应的事物;
praise
n. 赞扬; 称赞; 赞美; (对上帝的) 颂扬,赞颂;
v. 表扬; 赞扬; 称赞; 颂扬,赞颂(上帝);
liberal
adj. 宽宏大度的; 心胸宽阔的; 开明的; (政治经济上) 自由的; 支持(社会、政治或宗教)变革的; (旧时) 英国自由党的; (英国以外国家) 自由党的;
n. 理解且尊重他人意见的人; 宽容的人; 开明的人; 支持(社会、政治或宗教)变革的人; (旧时) 英国自由党成员; (英国以外国家的) 自由党成员;
democratic
adj. 民主的; 民主政体的; 民主制度的; 民主管理的; 有民主精神的; 平等的;
frustration
n. 懊丧; 懊恼; 沮丧; 令人懊丧(或懊恼、沮丧)的事物; 受阻; 受挫; 阻止; 挫败;
assault
n. 侵犯他人身体(罪); 侵犯人身罪; 攻击; 突击; 袭击; (向困难或危险事物发起的) 冲击;
v. 猛烈攻击,袭击,侵犯人身(尤指构成罪行); 使(感官)难受;
outcry
n. 呐喊; 怒吼; 强烈的抗议;
conservative
adj. 保守的; 守旧的; (英国) 保守党的; 低于实际数量的;
n. (英国) 保守党党员,保守党支持者; 保守者; 因循守旧者;
prewar
adj. 战前的; (尤指) 第二次世界大战以前的;
eyebrow
n. 眉; 眉毛;
authority
n. 权力; 威权; 当权(地位); 权; 职权; 批准; 授权;
centralization
n. 中央集权,集权,集中,集结于棋盘中心,集中制,集于中心,聚集,集中化,集中管理方式,集权式;
abandon
v. (不顾责任、义务等) 离弃,遗弃,抛弃; (不得已而) 舍弃,丢弃,离开; 停止(支持或帮助); 放弃(信念);
n. 放任; 放纵;
favor
n. 喜爱,宠爱,好感,赞同; 偏袒,偏爱; 善行,恩惠;
v. 赞同; 喜爱,偏爱; 有利于,便于;
isolated
adj. 偏远的; 孤零零的; 孤独的; 孤立的; 单独的; 只出现一次的;
v. (使) 隔离,孤立,脱离; 将…剔出(以便看清和单独处理); 使(某物质、细胞等)分离; 使离析;
commute
v. (乘公共汽车、火车、汽车等)上下班往返,经常往返(于两地) ; 减刑; 代偿;
n. 上下班路程;
crowd
n. 人群; 观众; 一伙人; 一帮人; 群众; 民众; 老百姓; 凡夫俗子;
v. 挤满; 塞满; 使…拥挤; 涌上(心头); 涌入(脑海); 挤,靠近,挤在一旁(以致使人不舒服或紧张);
rival
n. 竞争对手;
v. 与…相匹敌; 比得上;
adj. 竞争的;
be placed on
cultivation
n. 耕种; 种植; 栽培; (关系的) 培植; (品质或技巧的) 培养;
discomfort
n. 轻微的病痛; 不舒服; 不适; 不安; 不自在; 尴尬; 使人不舒服的事物; 苦事; 痛苦;
v. 使不舒服; 使不安; 使尴尬;
appreciate
v. 欣赏; 赏识; 重视; 感激; 感谢; 欢迎; 理解; 意识到; 领会;

distinction
n. 差别; 区别; 对比; 优秀; 杰出; 卓越; 特质; 特点; 不同凡响;
destiny
n. 命运; 天命; 天数; 主宰事物的力量; 命运之神;
sacrifice
n. 牺牲; 舍弃; 祭献; 祭祀; 祭献的牲畜; 祭品;
v. 牺牲; 献出; 以(人或动物)作祭献;
vitality
n. 生命力; 活力; 热情;
hypocrisy
n. 伪善; 虚伪;
barn
n. 谷仓; 畜棚; 简陋的大建筑物; (公共汽车、卡车等的) 车库;
formerly
adv. 以前; 从前;
confess
v. 供认,坦白,承认(错误或罪行); 承认(自己感到羞愧或尴尬的事); 忏悔(罪过); 悔过; 告罪; 告解;
lest
conj. 免得; 以免; (引出产生某种情感的原因) 唯恐,担心;
acquisitive
adj. 渴求获取财物的; 贪婪的;
vulgar
adj. 庸俗的; 粗俗的; 粗野的; 不雅的; 粗鲁的; 下流的;
hypocritical
adj. 虚伪的; 伪善的;
spectacle
n. 精彩的表演; 壮观的场面; 壮观的景象; 奇特的现象; 出人意外的情况;
ample
adj. 足够的; 丰裕的; 丰满的; 硕大的;
materialism
n. 实利主义; 物质主义; 唯物主义; 唯物论;
radical
adj. 根本的; 彻底的; 完全的; 全新的; 不同凡响的; 激进的; 极端的;
n. 激进分子; 游离基; 自由基;
enroll
v. 吸收(成员),加入,入册把…归入某一类档案,写下,录下,登记,注册,编入,服役,清单,入会,报告;
formulation
n. (药品、化妆品等的) 配方,剂型; 配方产品; (政策、计划等的) 制定,构想; (想法的) 阐述方式,表达方法;
angle
n. 角; 斜角; 角度;
v. 斜移; 斜置; 从(某角度)报道; 以(某观点)提供信息; 垂钓; 钓鱼;
defender
n. 防守队员; 后卫; 守卫者; 保护人; 防御者;
unimpressive
adj. 普通的; 平庸的; 毫无特色的;
impulse
n. 冲动; 心血来潮; 一时的念头; 脉冲; 冲击; 冲量; 推动力; 刺激;
quality
n. 质量; 品质; 上乘; 优质; 高标准; (尤指好的) 人品,素质,品德;
adj. 优质的; 高质量的; 盖帽儿了; 棒极了;
prompting
n. 劝说; 催促; 督促;
v. 促使; 导致; 激起; 鼓励,提示,提醒(某人说话); 给(演员)提词;
[词典] prompt的现在分词;
profess
v. 妄称; 伪称; 声称; 宣称; 公开表明; 信奉,信仰(某一宗教);
sly
adj. 诡诈的; 狡诈的; 诡秘的(表示自己知道别人不知道的秘密);
majority
n. 大部分; 大多数; (获胜的) 票数; 多数票; 超出其余各方票数总和的票数;
get on
[词典] (同…) 和睦相处; 继续做; 开始做; 取得进展; 有进步; 发迹; 取得成功; 出人头地; 上年纪;
compensate
v. 补偿; 弥补; 给(某人)赔偿(或赔款);
spiritual
adj. 精神的; 心灵的; 宗教的;
n. 灵歌(宗教歌曲,最初为美国黑人奴隶所唱);
material
n. 布料; 材料; 原料; (某一活动所需的) 材料;
adj. 实际的(非精神需求的); 物质的; 客观存在的; 重要的; 必要的;
customary
adj. 习俗的; 习惯的; (某人) 特有的,独特的,典型的;
n. 习惯法; 风俗志;
impractical
adj. 不明智的; 不现实的; 手不灵巧的; 不善于规划(或组织)的;
inmoral
adj. 不道德的; 邪恶的; 放荡的; 淫荡的;
comtemptible
adj. 可轻蔑的; 可鄙的; 卑劣的;
momentarily
adv. 短促地; 片刻地; 立即; 马上;
verbally
adv. 口头上(而非书面或行动上);
spiritually
adv. 在精神上地;

Translation

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
centralize
v. 集权控制; 实行集中;
efficiency
n. 效率; 效能; 功效; 提高功效的方法; 功率;
in turn
[词典] 继而; 转而; 反过来; 逐一; 依次; 轮流地;
rest upon
网络 停在; 依靠; 取决于;
mass
n. 团; 块; 堆; 大量; 许多; (常指混乱的) 一群,一堆;
adj. 大批的; 数量极多的; 广泛的;
v. 集结; 聚集;
innovation
n. (新事物、思想或方法的) 创造; 创新; 改革; 新思想; 新方法;
owing to
prep. 因为; 由于;
far-reaching
adj. 影响深远的; 广泛的;
undergo
v. 经历,经受(变化、不快的事等);
spread over
[词典] 分散,传开;
whereas
conj. (用以比较或对比两个事实) 然而,但是,尽管; (用于正式文件中句子的开头) 鉴于;
n. “鉴于…”:正式文件的介绍性陈述; 开场白; 条件性陈述;
arise from
[词典] 产生于,起因于(说明);
transport
n. 交通运输系统; 交通车辆; 运输工具; 旅行方式; 运输; 运送; 输送; 搬运;
v. (用交通工具) 运输,运送,输送; (以自然方式) 运输,传播; 使产生身临其境的感觉;

2002

Section I

diffusion
n. 扩散,传播;漫射;
pamphlet
n. 小册子; 手册;
periodical
n. (学术) 期刊;
generally
adv. 普遍地; 广泛地; 一般地; 通常; 大体上; 笼统地; 概括地; 大概;
circuit
n. 环行; 环行路线; 电路; 线路; 巡回赛;
vt. 巡回; 周游;
radically
adv. 根本地; 彻底地;
sharper
adv. (用于表时间的词语后,表示准时) …整; 向左 / 向右急转; 偏高音地;
adj. 锋利的; 锐利的; 尖的; 急剧的,骤然的(变化); 清楚明确的; 清晰的; 鲜明的;
storage
n. 贮存,贮藏(空间); 存储(方式); 付费托管;
leisure
n. 闲暇; 空闲; 休闲;
political
adj. 政治的; 政府的; 政权的; 政党的; 党派的; 关心政治的; 政治上活跃的;
motion
n. 运动; 移动; 动; (为传递信息用手或头做的) 动作; 动议; 提议;
v. (以头或手) 做动作,示意;
dimension
n. 维(构成空间的因素); 尺寸; 规模; 程度; 范围; 方面; 侧面;
perspective
n. 态度; 观点; 思考方法; 客观判断力; 权衡轻重的能力; 透视法;
in perspective
[词典] 正确地看待(或判断);
plausible
adj. 似是而非的; 有道理的; 可信的; 巧言令色的; 花言巧语的;
instrumental
adj. 起重要作用; 用乐器演奏的; 为乐器谱写的;
n. 器乐曲; 工具格; 工具词;
institutional
adj. 惯例的; 机构的; 慈善机构的;
capacity
n. 容量; 容积; 容纳能力; 领悟(或理解、办事)能力; 职位; 职责;
capability
n. 能力; 才能; (国家的) 军事力量,军事武器;
faculty
n. 官能; 天赋; 才能; 能力; (高等院校的) 系,院;
contest
n. 比赛; 竞赛; (控制权或权力的) 争夺,竞争;
v. 争取赢得(比赛、选举等); 争辩; 就…提出异议;
context
n. (事情发生的) 背景,环境,来龙去脉; 上下文; 语境;
scope
n. (做或实现某事的) 机会,能力; (题目、组织、活动等的) 范围; …镜(观察仪器);
v. 仔细看; 彻底检查;
territory
n. 领土; 版图; 领地; (个人、群体、动物等占据的) 领域,管区,地盘; (某人负责的) 地区;
effect
n. 效应; 影响; 结果; (艺术家或作家所要创造的特定) 外观,声响,印象,效果; (个人) 财产,所有物,财物;
v. 使发生; 实现; 引起;
distract
v. 转移(注意力); 分散(思想); 使分心;
controversial
adj. 引起争论的; 有争议的;
irrational
adj. 不合逻辑的; 没有道理的;
n. 无理数; 无理性的生物;
weight sth against sth
sth is weighed against sth
权衡; 斟酌;

Section II

relevant
adj. 紧密相关的; 切题的; 有价值的; 有意义的;
secretary
n. 秘书; (俱乐部、社团等的) 干事,文书; 部长; 大臣;
alternatively
adv. (引出第二种选择或可能的建议) 要不,或者;
alternative
n. 可供选择的事物;
adj. 可供替代的; 非传统的; 另类的;
comment
n. 议论; 评论; 解释; 批评; 指责;
v. 表达意见;
stomp
v. 迈着重重的步子走(或跳舞、移动);
appropriate
adj. 合适的; 恰当的;
v. 盗用; 挪用; 占用; 侵吞; 拨(专款等);
inedible
adj. 不能吃的; 不宜食用的;
canteen
n. 食堂; 餐厅; (士兵、旅游者等用的) 水壶; (装有一套刀、叉和勺的) 餐具盒;
notorious
adj. 声名狼藉的; 臭名昭著的;
resent
v. 愤恨; 感到气愤; 愤愤不平;
disparaging
adj. 贬低的; 诋毁的; 轻蔑的;
v. 贬低; 轻视;
[词典] disparage的现在分词;
disparage
v. 贬低; 轻视;
scapegoat
n. 替罪羊; 代人受过者;
v. 使…成为替罪羊;
casual
adj. 不经意的; 无忧无虑的; 漫不经心的; 不在乎的; 马虎的; 疏忽的; 非正式; 随便的;
n. 便装; 便鞋; 临时工;
manner
n. 方式; 方法; 举止; 态度; 礼貌; 礼仪;
twist
v. 使弯曲,使扭曲(成一定形状); (使) 弯曲变形,扭曲变形; 扭转,转动(身体部位);
n. 转动; 旋转; 搓; 捻; 拧; 扭动; (故事或情况的) 转折,转变,突然变化; 急转弯处; 曲折处;
impolite
adj. 不礼貌的; 粗鲁的;
refer to
v. 查阅; 提到;
audience
n. (戏剧、音乐会或演讲等的) 观众,听众; (同一事物的) 观众,读者; (与要人的) 会见; 觐见; 进见;
grab
v. 抓住; 攫取; (试图) 抓住,夺得; 利用,抓住(机会);
n. 猛然的抓取; 突然的抢夺; 抓取(或截取、采集)的图像; 抓具; 抓斗;
resent
v. 愤恨; 感到气愤; 愤愤不平;
stick to
[词典] 紧随; 紧跟; 呆在…近旁; 坚持不变; 遵守,坚持(诺言、协议、决定、原则等); 遵循(规则);
apparently
adv. 据…所知; 看来; 显然;
quote
v. 引用; 引述; 举例说明; 开价; 出价; 报价;
n. 引用;
exaggeration
n. 夸张; 夸大; 言过其实;
impolite
adj. 不礼貌的; 粗鲁的;
conscious
adj. 意识到; 注意到; 神志清醒的; 有知觉的; 有意识的; 慎重的; 有意的; 刻意的;
off-the-cuff
[词典] 未经准备(或思考)的; 即兴的;

dawn
n. 黎明; 拂晓; 破晓; 开端; 曙光; 萌芽;
v. 开始; 变得明朗; 开始清楚;
ingenuity
n. 独创力; 聪明才智; 心灵手巧;
devise
v. 发明; 设计; 想出;
n. 遗赠; 遗赠的财产; 遗赠的条款;
cunning
adj. 狡猾的; 奸诈的; 诡诈的; 灵巧的; 精巧的; 巧妙的;
n. 狡猾; 诡诈; 狡黠;
plain
adj. 清楚的; 明显的; 浅白的; 坦诚的; 直率的; 直接的; 不尚修饰的; 朴素的; 简单的;
n. 平原;
adv. (用于强调) 简直,绝对地;
burdensome
adj. 负担沉重的; 难以承担的; 繁重的;
confer
v. 商讨; 协商; 交换意见; 授予(奖项、学位、荣誉或权利);
compulsion
n. 强迫; 强制; (尤指做不道德、愚蠢或危险事的) 强烈欲望,冲动;
fiction
n. 小说; 虚构的事; 假想之物;
barely
adv. 仅仅; 刚刚; 勉强可能; 几乎不; 几乎没有; 刚好; 不超过(某个数量、年龄、时间等);
gizmos
n. 小玩意儿; 小装置;
hum
v. 哼(曲子); 发嗡嗡声; 活跃; 繁忙;
n. 嗡嗡声; 嘈杂声;
presence
n. 在场; 出席; 存在; 出现; (派遣的) 一个队; (尤指执行任务的) 部队;
rhythm
n. 节奏; 韵律; 律动; 规则变化; 规律; 节律;
assembly
n. 立法机构; 会议; 议会; 集会; (统称) 集会者; (全校师生的) 晨会,朝会;
automated
adj. 自动化的;
v. 使自动化;
[词典] automate的过去分词和过去式;
politeness
n. 殷勤;
miniaturization
n. 小型化;使微型化;
surgery
n. 外科手术; 外科学; 应诊时间; 诊室; 门诊处;
submillimeter
网络 亚毫米; 亚微米; 次毫米波; 次毫米; 亚毫米波;
accuracy
n. 准确(性); 精确(程度);
utility
n. 公用事业; 实用; 效用; 有用; 实用程序; 公用程序;
adj. 多用途的; 多效用的; 多功能的;
dynamic
n. (人或事物) 相互作用的方式,动态; 力学; 动力学; 动力;
adj. 充满活力的; 精力充沛的; 个性强的; 动态的; 发展变化的; 力的; 动力的;
despite
prep. 即使; 尽管; 尽管(自己)不愿意;
spell
v. 用字母拼; 拼写; 拼出,会拼(单词); 拼作; 拼成;
n. (持续的) 一段时间; (干某事或在某处工作的) 一段时间; 咒语; 符咒; 魔法;
microprocessor
n. 微处理器; 微处理机;
talent
n. 天才; 天资; 天赋; 有才能的人; 人才; (统称) 性感的人;
perception
n. 知觉; 感知; 洞察力; 悟性; 看法; 见解;
panel
n. (门、墙等上面的) 嵌板,镶板,方格板块; (车身的) 金属板,板金; (衣服上的) 镶条,嵌条,饰片;
v. 镶板(用木或玻璃板等镶嵌或装饰);
fraction
n. 小部分; 少量; 一点儿; 分数; 小数;
instantaneously
adv. 即刻;突如其来地;
suspicious
adj. 感觉可疑的; 怀疑的; 令人怀疑的; 可疑的; 不信任的; 持怀疑态度的;
neuroscientist
[词典] 神经科学家; 神经系统科学家; 神经学家;
delicate
adj. 易损的; 易碎的; 脆弱的; 虚弱的; 纤弱的; 纤细的; 微小的; 精美的; 小巧玲珑的;
intervention
n. 干涉; 干预;
intervent
n. 干涉物;
scene
n. (尤指不愉快事件发生的) 地点,现场; 事件; 场面; 情景; 片段; 镜头;
disregard
v. 不理会; 不顾; 漠视;
n. 漠视; 忽视;
tackle
v. 应付,处理,解决(难题或局面); 与某人交涉; 向某人提起(问题或困难情况); 抢球; 抢断; 抢截; 铲断;
n. (足球等) 抢断球,阻截铲球; (橄榄球或美式足球) 擒抱摔倒,阻截; 阻截队员; 用具; 体育器械; (尤指) 渔具;
perceive
v. 注意到; 意识到; 察觉到; 将…理解为; 将…视为; 认为;
conscious
adj. 意识到; 注意到; 神志清醒的; 有知觉的; 有意识的; 慎重的; 有意的; 刻意的;

crude
adj. 粗略的; 简略的; 大概的; 粗糙的; 粗制的; 冒犯的,粗俗的,粗鲁的(尤其有关性的);
n. 原油; 石油;
barrel
n. 桶; 一桶(的量); 桶(石油计量单位,相当于120到159升); 枪管;
v. (无法控制地) 高速行进,飞驰;
tripling
v. 成为三倍; 使增至三倍;
[词典] triple的现在分词;
triple
adj. 三部分的; 三人的; 三组的; 三倍的; 三重的;
v. 成为三倍; 使增至三倍;
scary
adj. 恐怖的; 吓人的;
quadrupled
v. (使) 变为四倍;
[词典] quadruple的过去分词和过去式;
quadruple
v. (使) 变为四倍;
adj. 由四部分(或人、群体)构成的; 四方面的; 四倍的;
inflation
n. 通货膨胀; 通胀率; 充气;
gloom
n. 忧郁; 愁闷; 无望; 幽暗; 黑暗; 昏暗;
vt. 变黑; 变暗; 忧郁; 沮丧使变黑; 变暗; 使忧伤; 沮丧;
doom
n. 死亡; 毁灭; 厄运; 劫数;
v. 使…注定失败(或遭殃、死亡等);
suspend
v. 悬; 挂; 吊; 暂停; 中止; 使暂停发挥作用(或使用等); 延缓; 暂缓; 推迟;
grip
n. 紧握; 紧抓; (对…的) 控制,影响力; 理解; 了解;
v. 紧握; 紧抓; 使感兴趣; 使激动; 吸引住(某人)的注意; 对…产生强有力的影响;
muted
adj. 静静的; 减轻的; 含糊不清的; 表达不明确的; 暗淡的; 不明亮的;
v. 消音; 减音; 减弱(尤指乐器)的声音; 减弱; 缓解;
[词典] mute的过去分词和过去式;
mute
adj. 沉默的; 不出声的; 无声的; 哑的;
n. 弱音器; 哑巴;
v. 消音; 减音; 减弱(尤指乐器)的声音; 减弱; 缓解;
pump
n. 抽水机; 泵; 打气筒; 轻软舞鞋; 轻便帆布鞋;
v. 用泵(或泵样器官等)输送; 涌出; 涌流; 奔流; 上下(或内外)快速摇动; 急速摇晃;
estimate
n. (对数量、成本等的) 估计; 估价; 估计的成本;
v. 估价; 估算;
squeezed
v. 挤压; 捏; (从某物中) 榨出,挤出,拧出; (使) 挤入; 挤过; 塞入;
irrelevant
adj. 无关紧要的; 不相关的;
conservation
n. (对自然环境的) 保护; (官方对历史或艺术建筑的) 保护; 文物保护; 防止流失(或浪费、损害、毁坏); 保持; 保护;
scared
adj. 害怕; 恐惧; 畏惧; 担心;
v. 惊吓; 使害怕; 使恐惧; 受惊吓; 害怕; 恐惧;
[词典] scare的过去分词和过去式;
shock
n. 震惊; 惊愕; 令人震惊的事; 休克; (由爆炸、地震等引起的) 剧烈震动,剧烈震荡;
v. 使震惊; 使惊愕; 使气愤; 使厌恶;
sensitive
adj. 体贴的; 体恤的; 善解人意的; 感觉敏锐的; 艺术感觉好的; 有悟性的; 易生气的; 易被惹恼的; 神经过敏的;
n. 敏感的人; 有灵异能力的人;
swing
v. (使) 摆动,摇摆,摇荡; 纵身跃向; 荡向; 悬吊到; (使) 弧线运动,转弯,转动;
n. 摆动; 挥动; 转动; 强劲节奏; 改变; 改变的程度; 秋千;
consumption
n. (能量、食物或材料的) 消耗,消耗量; 消费; 肺病; 肺痨; 肺结核;
constant
adj. 连续发生的; 不断的; 重复的; 不变的; 固定的; 恒定的;
n. 常数; 常量;
sizable
adj. 相当大的; 颇大的;

supreme
adj. (级别或地位) 最高的,至高无上的; (程度) 很大的,最大的;
physician
n. 医师; (尤指) 内科医生;
assisted
v. 帮助; 协助; 援助; 促进;
[词典] assist的过去分词和过去式;
suicide
n. 自杀; 自杀性行为; 自毁; 自取灭亡的行为; 自杀者;
implication
n. 可能的影响(或作用、结果); 含意; 暗指; (被) 牵连,牵涉;
actor
n. 演员;
relieve
v. 解除,减轻,缓和(不快或痛苦); 减轻(问题的严重性); 缓和; 缓解; 调剂; 使有趣;
constitutional
adj. 宪法的; 章程的; 宪法准许的; 受宪法限制的; 受章程限制的; 身体素质的; 体质的; 体格的;
n. 保健散步;
constitution
n. 宪法; 章程; 身体素质; 体质; 体格; 构成; 构造;
medication
n. 药; 药物;
sufficient
adj. 足够的; 充足的;
as long as
conj. 只要;
foreseen
v. 预料; 预见; 预知;
[词典] foresee的过去分词;
permissible
adj. 容许的; 许可的;
dosage
n. (通常指药的) 剂量;
sufficient
adj. 足够的; 充足的;
medication
n. 药; 药物;
prescribe
v. 给…开(药); 让…采用(疗法); 开(处方); 规定; 命令; 指示;
legitimate
adj. 正当合理的; 合情合理的; 合法的; 法律认可的; 法定的; 合法婚姻所生的;
vt. 使合法; 给予合法的地位; 通过法律手段给(私生子)以合法地位; 正式批准; 授权;
illegal
adj. 不合法的; 非法的; 违法的;
n. 非法移民; 非法劳工;
surgery
n. 外科手术; 外科学; 应诊时间; 诊室; 门诊处;
homicide
n. (蓄意) 杀人罪;
despair
n. 绝望;
v. 绝望; 失去希望; 丧失信心;
agony
n. (精神或肉体的) 极度痛苦;
volume
n. 体积; 容积; 容量; 量; 额; 音量; 响度;
aggressive
adj. 好斗的; 挑衅的; 侵略的; 富于攻击性的; 气势汹汹的; 声势浩大的; 志在必得的;
hospice
n. 临终安养院;
undertreatment
网络 治疗不足; 治疗上处理不足; 处理不足;
approach
v. (在距离或时间上) 靠近,接近; 接洽; 建议; 要求; (在数额、水平或质量上) 接近;
n. (待人接物或思考问题的) 方式,方法,态度; (距离和时间上的) 靠近,接近; 接洽; 建议; 要求;
predictably
adv. 可推断;
predict
v. 预言; 预告; 预报;
abuse
n. 滥用; 妄用; 虐待; 辱骂; 恶语;
v. 滥用(以致危害健康); 滥用,妄用(权力、所知所闻); 虐待; 性虐待; 伤害;
presumptively
网络 推定; 假定地;
presumptive
adj. 很可能的; 假设的; 推断的;
suspension
n. 暂令停职(或停学、停赛等); 暂缓; 推迟; 延期; (车辆减震用的) 悬架;
constitutional
adj. 宪法的; 章程的; 宪法准许的; 受宪法限制的; 受章程限制的; 身体素质的; 体质的; 体格的;
n. 保健散步;
insufficient
adj. 不充分的; 不足的; 不够重要的;
aggressive
adj. 好斗的; 挑衅的; 侵略的; 富于攻击性的; 气势汹汹的; 声势浩大的; 志在必得的;
desperate
adj. (因绝望而) 不惜冒险的,不顾一切的,拼命的; 绝望的; 孤注一掷的; 铤而走险的; 非常需要; 极想; 渴望;
bold
adj. 大胆自信的; 敢于表白情感的; 敢于冒险的; 明显的; 轮廓突出的; 粗体的; 黑体的;
n. 黑体; 粗体;
incompetently
adv. 无能力地;不胜任地;
translate
v. 翻译; 译; 被翻译; 被译成; (使) 转变,变为;
extent
n. 程度; 限度; 大小; 面积; 范围;
abuse
n. 滥用; 妄用; 虐待; 辱骂; 恶语;
v. 滥用(以致危害健康); 滥用,妄用(权力、所知所闻); 虐待; 性虐待; 伤害;
presumptively
网络 推定; 假定地;
incompetently
adv. 无能力地;不胜任地;
suspension
n. 暂令停职(或停学、停赛等); 暂缓; 推迟; 延期; (车辆减震用的) 悬架;
assist
v. 帮助; 协助; 援助; 促进;
n. (曲棍球等) 助攻; (棒球等) 助杀;
inadequate
adj. 不充分的; 不足的; 不够的; 不胜任的; 缺乏信心的;

Algorithms4

发表于 2019-10-19

2.Sorting

2.1 Elementary Sorts

1
2
3
4
5
6
7
8
9
10
11
private static boolean less(Comparable v, Comparable w) {
return (v.compareTo(w) < 0);
}
// v是否小于w

private static void exch(Comparable[] a, int i, int j) {
Comparable swap = a[i];
a[i] = a[j];
a[j] = swap;
}
// swap

Selection sort

1
2
3
4
5
6
7
8
9
10
public static void sort(Comparable[] a) {
int n = a.length;
for (int i = 0; i < n; i++) {
int min = i;
for (int j = i+1; j < n; j++) {
if (less(a[j], a[min])) min = j;
}
exch(a, i, min);
}
}

Insertion sort

1
2
3
4
5
6
7
8
public static void sort(Comparable[] a) {
int n = a.length;
for (int i = 1; i < n; i++) {
for (int j = i; j > 0 && less(a[j], a[j-1]); j--) {
exch(a, j, j-1);
}
}
}

Shellsort

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void sort(Comparable[] a) {
int n = a.length;

// 3x+1 increment sequence: 1, 4, 13, 40, 121, 364, 1093, ...
int h = 1;
while (h < n/3) h = 3*h + 1;

while (h >= 1) {
// h-sort the array
for (int i = h; i < n; i++) {
for (int j = i; j >= h && less(a[j], a[j-h]); j -= h) {
exch(a, j, j-h);
}
}
h /= 3;
}
}

Algorithms

发表于 2019-10-19

PAT学习

发表于 2019-08-18

:scream:是😱
:kissing_heart:是😘
:yum:是😋

sscanf()和sprintf()

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
using namespace std;

int main() {
int n;
char str[100] = "123";
sscanf(str, "%d", &n);
printf("%d\n", n);
return 0;
}

123
1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
using namespace std;

int main() {
int n = 456;
char str[100];
sprintf(str, "%d", n);
printf("%s\n", str);
return 0;
}

456
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main() {
int n;
double db;
char str1[100] = "2048:3.14,hello", str2[100];
sscanf(str, "%d:%lf,%s", &n, &db, &str2);
printf("n = %d, db = %.2f, str2 = %s\n", n, db, str2);

return 0;
}

n = 2048, db = 3.14, str2 = hello
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main() {
int n = 12;
double db = 3.1415;
char str1[100], str2[100] = "good";
sprintf(str1, "%d:%.3f,%s", n, db, str2);
printf("str1 = %s\n", str1);

return 0;
}

str1 = 12:3.142,good

DFS

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
#include <iostream>
using namespace std;

const int maxn = 30;
int n, V, maxValue = 0;
int w[maxn], c[maxn];

void DFS(int index, int sumW, int sumC) {
if (index == n) {
if (sumW <= V && sumC > maxValue) {
maxValue = sumC;
}
return;
}
DFS(index + 1, sumW, sumC);
DFS(index + 1, sumW + w[index], sumC + c[index]);
}

int main() {
scanf("%d%d", &n, &V);
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
DFS(0, 0, 0);
printf("%d\n", maxValue);

return 0;
}

5 8
3 5 1 2 2
4 5 2 1 3

10
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
#include <iostream>
using namespace std;

const int maxn = 30;
int n, V, maxValue = 0;
int w[maxn], c[maxn];

void DFS(int index, int sumW, int sumC) {
if (index == n) {
return;
}
DFS(index + 1, sumW, sumC);
if (sumW + w[index] <= V) {
if (sumC + c[index] > maxValue) {
maxValue = sumC + c[index];
}
DFS(index + 1, sumW + w[index], sumC + c[index]);
}
}

int main() {
scanf("%d%d", &n, &V);
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
DFS(0, 0, 0);
printf("%d\n", maxValue);

return 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
#include <iostream>
using namespace std;

const int maxn = 30;
int n, V, maxValue = 0;
int w[maxn], c[maxn];

void DFS(int index, int sumW, int sumC) {
if (index == n) {
return;
}
if (sumW < V) { // 试着再优化,当容量还有空间,才考虑选与不选
DFS(index + 1, sumW, sumC);
}
if (sumW + w[index] <= V) {
if (sumC + c[index] > maxValue) {
maxValue = sumC + c[index];
}
DFS(index + 1, sumW + w[index], sumC + c[index]);
}
}

int main() {
scanf("%d%d", &n, &V);
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
DFS(0, 0, 0);
printf("%d\n", maxValue);

return 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
#include <iostream>
using namespace std;

const int maxn = 11;
int n, P[maxn], hashTable[maxn] = {0};

void generateP(int index) {
if (index == n + 1) {
for (int i = 1; i <= n; i++) {
printf("%d", P[i]);
}
printf("\n");
return;
}
for (int x = 1; x <= n; x++) {
if (hashTable[x] == 0) {
P[index] = x;
hashTable[x] = 1;
generateP(index + 1);
hashTable[x] = 0;
}
}
}

int main() {
n = 3;
generateP(1);

return 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
#include <iostream>
using namespace std;

const int maxn = 11;
int n, P[maxn], hashTable[maxn] = {0};

int cnt = 0;

void generateP(int index) {
if (index == n + 1) {
bool flag = true;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (abs(i - j) == abs(P[i] - P[j])) {
flag = false;
}
}
}
if (flag) cnt++;
return;
}
for (int x = 1; x <= n; x++) {
if (hashTable[x] == 0) {
P[index] = x;
hashTable[x] = 1;
generateP(index + 1);
hashTable[x] = 0;
}
}
}

int main() {


return 0;
}

最大公约数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
using namespace std;

int gcd(int m, int n) {
return !n ? m : gcd(n, m % n);
}

int main() {
int m, n;
while (scanf("%d%d", &m, &n) != EOF) {
printf("%d\n", gcd(m, n));
}

return 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
#include <iostream>
using namespace std;

int gcd(int m, int n) {
return !n ? m : gcd(n, m % n);
}

struct Fraction {
int up, down;
};

Fraction reduction(Fraction res) {
if (res.down < 0) {
res.up = -res.up;
res.down = -res.down;
}
if (res.up == 0) {
res.down = 1;
} else {
int d = gcd(abs(res.up), abs(res.down));
res.up /= d;
res.down /= d;
}
return res;
}

Fraction add(Fraction f1, Fraction f2) {
Fraction res;
res.up = f1.up * f2.down + f2.up * f1.down;
res.down = f1.down * f2.down;
return reduction(res);
}

Fraction minus(Fraction f1, Fraction f2) {
Fraction res;
res.up = f1.up * f2.down - f2.up * f1.down;
res.down = f1.down * f2.down;
return reduction(res);
}

Fraction multiplication(Fraction f1, Fraction f2) {
Fraction res;
res.up = f1.up * f2.up;
res.down = f1.down * f2.down;
return reduction(res);
}

Fraction divide(Fraction f1, Fraction f2) {
Fraction res;
while (f2.up != 0) {
res.up = f1.up * f2.down;
res.down = f1.down * f2.up;
return reduction(res);
}
}

void showRes(Fraction r) {
if (r.down == 1) printf("%d", r.up);
else if (abs(r.up) > abs(r.down)) {
printf("%d %d/%d", r.up / r.down, abs(r.up) % abs(r.down), r.down);
} else {
printf("%d/%d", r.up, r.down);
}
}

int main() {
Fraction f1;
f1.up = -14, f1.down = 6;
showRes(f1);
printf("\n");
f1 = reduction(f1);
showRes(f1);


return 0;
}

-2 2/6
-2 1/3

素数

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
#include <iostream>
#include <math.h>
using namespace std;

bool isPrime_1(int n) {
if (n <= 1) return false;
int sqr = (int)sqrt(1.0 * n);
for (int i = 2; i <= sqr; i++) {
if (n % i == 0) return false;
}
return true;
}

bool isPrime_2(int n) {
if (n <= 1) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}

int main() {
printf("%d\n", isPrime_1(13));
printf("%d\n", isPrime_2(53));

return 0;
}

1
1

Dijkstra

邻接矩阵

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
const int MAXV = 1000;
const int INF = 0x3fffffff;
int n, G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV] = {false};

void Dijkstra(int s) {
fill(d, d + MAXV, INF);
d[s] = 0;
for (int i = 0; i < n; i++) {
int u = -1, MIN = INF;
for (int j = 0; j < n; j++) {
if (vis[j] == false && d[j] < MIN) {
u = j;
MIN = d[j];
}
}
if (u == -1) {
return;
}
vis[u] = true;
for (int v = 0; v < n; v++) {
if (vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]) {
d[v] = d[u] + G[u][v];
}
}
}
}

邻接表

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
const int MAXV = 1000;
const int INF = 0x3fffffff;

struct Node {
int v, dis;
};

vector<Node> Adj[MAXV];
int n;
int d[MAXV];
bool vis[MAXV] = {false};

void Dijkstra(int s) {
fill(d, d + MAXV, INF);
d[s] = 0;
for (int i = 0; i < n; i++) {
int u = -1, MIN = INF;
for (int j = 0; j < n; j++) {
if (vis[j] == false && d[j] < MIN) {
u = j;
MIN = d[j];
}
}
if (u == -1) {
return;
}
vis[u] = true;
for (int j = 0; j < Adj[u].size(); j++) {
int v = Adj[u][j].v;
if (vis[v] == false && d[u] + Adj[u][j].dis < d[v]) {
d[v] = d[u] + Adj[u][j].dis;
}
}
}
}

一个实例

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
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int MAXV = 1000;
const int INF = 0x3fffffff;
int n, G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV] = {false};
int m, s;

void Dijkstra(int s) {
fill(d, d + MAXV, INF);
d[s] = 0;
for (int i = 0; i < n; i++) {
int u = -1, MIN = INF;
for (int j = 0; j < n; j++) {
if (vis[j] == false && d[j] < MIN) {
u = j;
MIN = d[j];
}
}
if (u == -1) {
return;
}
vis[u] = true;
for (int v = 0; v < n; v++) {
if (vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]) {
d[v] = d[u] + G[u][v];
}
}
}
}

int main() {
int u, v, w;
scanf("%d%d%d", &n, &m, &s);
fill(G[0], G[0] + MAXV * MAXV, INF);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &u, &v, &w);
G[u][v] = w;
}
Dijkstra(s);
for (int i = 0; i < n; i++) {
printf("%d ", d[i]);
}

return 0;
}

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

0 1 5 3 4 6

动态葵花

动态规划的递推写法

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
const int maxn = 10000;

int F1(int n) {
if (n == 0 || n == 1) return 1;
else return F1(n - 1) + F1(n - 2);
}

int dp[maxn];

int F2(int n) {
if (n == 0 || n == 1) return 1;
if (dp[n] != -1) return dp[n];
else {
dp[n] = F2(n - 1) + F2(n - 2);
return dp[n];
}
}

int main() {
memset(dp, -1, maxn);
cout << F2(5) << endl;

return 0;
}

8

PAT (Basic Level) Practice

发表于 2019-08-12

1036 跟奥巴马一起编程

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
#include <iostream>
using namespace std;

int main() {
int row, col;
char c;
scanf("%d %c", &col, &c);
if (col % 2 == 1) row = col / 2 + 1;
else row = col / 2;

for (int i = 0; i < col; i++) {
printf("%c", c);
}
printf("\n");
for (int i = 2; i < row; i++) {
printf("%c", c);
for (int j = 0; j < col - 2; j++) {
printf(" ");
}
printf("%c\n", c);
}
for (int i = 0; i < col; i++) {
printf("%c", c);
}

return 0;
}

10 a

aaaaaaaaaa
a a
a a
a a
aaaaaaaaaa

codeup 1928

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;

int month[13][2] = {{0 ,0}, {31, 31}, {28, 29}, {31, 31}, {30, 30}, {31, 31}, {30, 30},
{31, 31}, {31, 31}, {30, 30}, {31, 31}, {30, 30}, {31, 31}};

bool isLeapYear(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}


int main() {


return 0;
}

PAT

发表于 2019-08-10

UEFU/
// PAT

1001 A+B Format (20分)


题目要求:
计算A+B的和,以每三位一个”,”的格式输出。

用s数组记录每3位的数字,然后按照格式输出。
先输出最高位的数值也就是s[–e],然后是,s[e–]即可。
因为之前的循环e多1要先减1再用,之后都是先判断再减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
#include <iostream>
using namespace std;

int main() {
int a, b, sum;
while (scanf("%d%d", &a, &b) == 2) {
sum = a + b;
if (sum == 0) printf("0\n");
else {
if (sum < 0) {
printf("-");
sum = -sum;
}
int s[10], e = 0;
while (sum) {
s[e++] = sum % 1000;
sum = sum / 1000;
}
printf("%d", s[--e]);
while (e--) {
printf(",%03d", s[e]);
}
printf("\n");
}
}

return 0;
}

-1000000 9
-999,991

还有个留着参考:
#include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
string s = to_string(a + b);
int len = s.length();
for (int i = 0; i < len; i++) {
cout << s[i];
if (s[i] == '-') continue;
if ((i + 1) % 3 == len % 3 && i != len - 1) cout << ",";
}
return 0;
}

1002 A+B for Polynomials


相同次数的系数合并,统计系数不为0的项,输出。
a[exp] += num; 比如a[2]也就是x的平方的系数。exp = 0也就是常数项。
因为没有说同一行输入不会出现相同次数的项,因此要+=,当然+=也能很好地处理系数不同的问题。

求8x²-7x+5与3x²-4x+1的差。
解: (8x²-7x+5)-(3x²-4x+1)
=8x²-7x+5-3x²+4x-1
=5x²-3x+4

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 <iostream>
using namespace std;

int main() {
int k1, k2, exp;
float num;
float a[1001] = {0};
scanf("%d", &k1);
for (int i = 0; i < k1; i++) {
scanf("%d%f", &exp, &num);
a[exp] += num;
}
scanf("%d", &k2);
for (int i = 0; i < k2; i++) {
scanf("%d%f", &exp, &num);
a[exp] += num;
}
int cnt = 0;
for (int i = 0; i < 1001; i++) {
if (a[i] != 0) cnt++;
}
printf("%d", cnt);
for (int i = 1000; i >= 0; i--) {
if (a[i] != 0) {
printf(" %d %.1f", i, a[i]);
}
}

return 0;
}

2 1 2.4 0 3.2
2 2 1.5 1 0.5
3 2 1.5 1 2.9 0 3.2

1003 Emergency (25 分)


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
#include <iostream>
#include <string.h>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXV = 510;
const int INF = 0x3fffffff;

int n, m, st, ed, G[MAXV][MAXV], weight[MAXV];
int d[MAXV], w[MAXV], num[MAXV];
bool vis[MAXV] = {false};

void Dijkstra(int s) {
fill(d, d + MAXV, INF);
memset(num, 0, sizeof(num));
memset(w, 0, sizeof(w));
d[s] = 0;
w[s] = weight[s];
num[s] = 1;
for (int i = 0; i < n; i++) {
int u = -1, MIN = INF;
for (int j = 0; j < n; j++) {
if (vis[j] == false && d[j] < MIN) {
u = j;
MIN = d[j];
}
}
if (u == -1) {
return;
}
vis[u] = true;
for (int v = 0; v < n; v++) {
if (vis[v] == false && G[u][v] != INF) {
if (d[u] + G[u][v] < d[v]) {
d[v] = d[u] + G[u][v];
w[v] = w[u] + weight[v];
num[v] = num[u];
} else if (d[u] + G[u][v] == d[v]) {
if (w[u] + weight[v] > w[v]) {
w[v] = w[u] + weight[v];
}
num[v] += num[u];
}
}
}
}
}

int main() {
scanf("%d%d%d%d", &n, &m, &st, &ed);
for (int i = 0; i < n; i++) {
scanf("%d", &weight[i]);
}
int u, v;
fill(G[0], G[0] + MAXV * MAXV, INF);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
scanf("%d", &G[u][v]);
G[v][u] = G[u][v];
}
Dijkstra(st);
printf("%d %d", num[ed], w[ed]);

return 0;
}


5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1

2 4

1004 Counting Leaves

1
2


1006 Sign In and Sign Out (25 分)

1
2


1005 Spell It Right


题目大意:
输入一个数字,把数字的每一位相加,用英文输出最后总和的每一位数字。
因为输入的数字可能很大,所以用字符串的形式输入。即使每一位是9,和也不过是900罢了。
之后转换为字符串,输出每一位的数字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;

int main() {
string str;
cin >> str;
int sum = 0;
for (int i = 0; i < str.length(); i++) {
sum += (str[i] - '0');
}
string s = to_string(sum);
string digits[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
cout << digits[s[0] - '0'];
for (int i = 1; i < s.length(); i++) {
cout << " " << digits[s[i] - '0'];
}

return 0;
}

12345
one five

1006 Sign In and Sign Out


题目大意:
告诉你M个工作人员的出入记录,最早进门的人负责开门,最晚出门的负责关门。
请问,谁开的门和谁关的门。

总体思想是把所有人的进出时间统一到一个可以比较的刻度上,比如,进出时间是当天的第几秒。
之后用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
#include <iostream>
using namespace std;


int main() {
int n, minn = INT32_MAX, maxn = INT32_MIN;
scanf("%d", &n);
string unlocked, locked;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
int h1, h2, m1, m2, s1, s2;
scanf("%d:%d:%d %d:%d:%d", &h1, &m1, &s1, &h2, &m2, &s2);
int tempIn = h1 * 3600 + m1 * 60 + s1;
int tempOut = h2 * 3600 + m2 * 60 + s2;
if (tempIn < minn) {
minn = tempIn;
unlocked = t;
}
if (tempOut > maxn) {
maxn = tempOut;
locked = t;
}
}
cout << unlocked << " " << locked;

return 0;
}


3
CS301111 15:30:28 17:00:10
SC3021234 08:00:00 11:25:25
CS301133 21:45:00 21:58:40

SC3021234 CS301133

1007 Maximum Subsequence Sum


题目大意:
输出最大子序列和,以及首尾元素。

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
#include <iostream>
using namespace std;

int main() {
int n;
scanf("%d", &n);
int num[n + 1];
int left = 0, right = n - 1, sum = -1, temp = 0, tempindex = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
temp = temp + num[i];
if (temp < 0) {
temp = 0;
tempindex = i + 1;
} else if (temp > sum) {
sum = temp;
left = tempindex;
right = i;
}
}
if (sum < 0) sum = 0;
printf("%d %d %d", sum, num[left], num[right]);

return 0;
}

10
-10 1 2 3 4 -5 -23 3 7 -21

10 1 4

1009 Product of Polynomials (25 分)


题目大意:
求2个多项式A*B后的结果。

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
#include <iostream>
using namespace std;

int main() {
int n1, n2, a, cnt = 0;
double b, arr[1001] = {0.0}, ans[2001] = {0.0};
scanf("%d", &n1);
for (int i = 0; i < n1; i++) {
scanf("%d %lf", &a, &b);
arr[a] = b;
}
scanf("%d", &n2);
for (int i = 0; i < n2; i++) {
scanf("%d %lf", &a, &b);
for (int j = 0; j < 1001; j++) {
ans[j + a] += arr[j] * b;
}
}
for (int i = 2000; i >= 0; i--) {
if (ans[i] != 0.0) cnt++;
}
printf("%d", cnt);
for (int i = 2000; i >= 0; i--) {
if (ans[i] != 0.0) {
printf(" %d %.1f", i, ans[i]);
}
}

return 0;
}

2 1 2.4 0 3.2
2 2 1.5 1 0.5

3 3 3.6 2 6.0 1 1.6

❌ 1010 Radix (25 分)


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
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cctype>
using namespace std;

long long convert(string n, long long radix) {
long long sum = 0;
int index = 0, temp = 0;
for (auto it = n.rbegin(); it != n.rend(); it++) {
temp = isdigit(*it) ? *it - '0' : *it - 'a' + 10;
sum += temp * pow(radix, index++);
}
return sum;
}

long long find_radix(string n, long long num) {
char it = *max_element(n.begin(), n.end());
long long low = (isdigit(it) ? it - '0' : it - 'a' + 10) + 1;
long long high = max(num, low);
while (low <= high) {
long long mid = (low + high) / 2;
long long temp = convert(n, mid);
if (temp < 0 || temp > num) high = mid - 1;
else if (temp == num) return mid;
else low = mid + 1;
}
return -1;
}

int main() {
string n1, n2;
long long tag = 0, radix = 0, result_radix;
cin >> n1 >> n2 >> tag >> radix;
result_radix = tag == 1 ? find_radix(n2, convert(n1, radix)) : find_radix(n1, convert(n2, radix));
if (result_radix != -1) {
printf("%lld", result_radix);
} else {
printf("Impossible");
}

return 0;
}



6 110 1 10

2

1011 World Cup Betting (20)

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
#include <iostream>
using namespace std;

int main() {
char c[4] = {"WTL"};
double res = 1.0;
for (int i = 0; i < 3; i++) {
double maxval = 0.0;
int maxchar = 0;
for (int j = 0; j < 3; j++) {
double t;
scanf("%lf", &t);
if (t >= maxval) {
maxval = t;
maxchar = j;
}
}
res *= maxval;
printf("%c ", c[maxchar]);
}
printf("%.2f", (res * 0.65 - 1) * 2);

return 0;
}

1.1 2.5 1.7
1.2 3.1 1.6
4.1 1.2 1.1

T T W 39.31

❌ 1012 The Best Rank (25 分)

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 <iostream>
#include <algorithm>
using namespace std;

struct student {
int id, best;
int score[4], rank[4];
}stu[2005];

int exist[1000000], flag = -1;

bool cmp(student x, student y) {
return x.score[flag] > y.score[flag];
}

int main() {
int n, m, id;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d %d %d %d", &stu[i].id, &stu[i].score[1], &stu[i].score[2], &stu[i].score[3]);
stu[i].score[0] = (stu[i].score[1] + stu[i].score[2] + stu[i].score[3]) / 3.0 + 0.5;
}
for (flag = 0; flag <= 3; flag++) {
sort(stu, stu + n, cmp);
stu[0].rank[flag] = 1;
for (int i = 1; i < n; i++) {
stu[i].rank[flag] = i + 1;
if (stu[i].score[flag] == stu[i - 1].score[flag]) {
stu[i].rank[flag] = stu[i - 1].rank[flag];
}
}
}
for (int i = 0; i < n; i++) {
exist[stu[i].id] = i + 1;
stu[i].best = 0;
int minnum = stu[i].rank[0];
for (int j = 1; j <= 3; j++) {
if (stu[i].rank[j] < minnum) {
minnum = stu[i].rank[j];
stu[i].best = j;
}
}
}
char c[5] = {'A', 'C', 'M', 'E'};
for (int i = 0; i < m; i++) {
scanf("%d", &id);
int t = exist[id];
if (t) {
int best = stu[t - 1].best;
printf("%d %c\n", stu[t- 1].rank[best], c[best]);
} else {
printf("N/A\n");
}
}

return 0;
}

5 6
310101 98 85 88
310102 70 95 88
310103 82 87 94
310104 91 91 91
310105 85 90 90
310101
310102
310103
310104
310105
999999

1 C
1 M
1 E
1 A
3 A
N/A

1013 Battle Over Cities (25 分)

1
2


1015 Reversible Primes (20 分)

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 <cmath>
using namespace std;

bool isPrime(int n) {
if (n <= 1) return false;
int sqr = (int)sqrt(1.0 * n);
for (int i = 2; i <= sqr; i++) {
if (n % i == 0) return false;
}
return true;
}

int main() {
int n, d;
while (scanf("%d", &n) != EOF && n > 0) {
// if (n < 0) break;
scanf("%d", &d);
if (!isPrime(n)) {
printf("No\n");
continue;
}
int len = 0, arr[100];
while (n) {
arr[len++] = n % d;
n /= d;
}
for (int i = 0; i < len; i++) {
n = n * d + arr[i];
}
printf("%s", isPrime(n) ? "Yes\n" : "No\n");
}

return 0;
}

73 10
23 2
23 10
-2

Yes
Yes
No

1016 Phone Bills (25 分) UN

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
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
struct node {
string name;
int status, month, time, day, hour, minute;
};
bool cmp(node a, node b) {
return a.name != b.name ? a.name < b.name : a.time < b.time;
}
double billFromZero(node call, int *rate) {
double total = rate[call.hour] * call.minute + rate[24] * 60 * call.day;
for (int i = 0; i < call.hour; i++)
total += rate[i] * 60;
return total / 100.0;
}
int main() {
int rate[25] = {0}, n;
for (int i = 0; i < 24; i++) {
scanf("%d", &rate[i]);
rate[24] += rate[i];
}
scanf("%d", &n);
vector<node> data(n);
for (int i = 0; i < n; i++) {
cin >> data[i].name;
scanf("%d:%d:%d:%d", &data[i].month, &data[i].day, &data[i].hour, &data[i].minute);
string temp;
cin >> temp;
data[i].status = (temp == "on-line") ? 1 : 0;
data[i].time = data[i].day * 24 * 60 + data[i].hour * 60 + data[i].minute;
}
sort(data.begin(), data.end(), cmp);
map<string, vector<node> > custom;
for (int i = 1; i < n; i++) {
if (data[i].name == data[i - 1].name && data[i - 1].status == 1 && data[i].status == 0) {
custom[data[i - 1].name].push_back(data[i - 1]);
custom[data[i].name].push_back(data[i]);
}
}
for (auto it : custom) {
vector<node> temp = it.second;
cout << it.first;
printf(" %02d\n", temp[0].month);
double total = 0.0;
for (int i = 1; i < temp.size(); i += 2) {
double t = billFromZero(temp[i], rate) - billFromZero(temp[i - 1], rate);
printf("%02d:%02d:%02d %02d:%02d:%02d %d $%.2f\n", temp[i - 1].day, temp[i - 1].hour, temp[i - 1].minute, temp[i].day, temp[i].hour, temp[i].minute, temp[i].time - temp[i - 1].time, t);
total += t;
}
printf("Total amount: $%.2f\n", total);
}
return 0;
}

10 10 10 10 10 10 20 20 20 15 15 15 15 15 15 15 20 30 20 15 15 10 10 10
10
CYLL 01:01:06:01 on-line
CYLL 01:28:16:05 off-line
CYJJ 01:01:07:00 off-line
CYLL 01:01:08:03 off-line
CYJJ 01:01:05:59 on-line
aaa 01:01:01:03 on-line
aaa 01:02:00:01 on-line
CYLL 01:28:15:41 on-line
aaa 01:05:02:24 on-line
aaa 01:04:23:59 off-line

CYJJ 01
01:05:59 01:07:00 61 $12.10
Total amount: $12.10
CYLL 01
01:06:01 01:08:03 122 $24.40
28:15:41 28:16:05 24 $3.85
Total amount: $28.25
aaa 01
02:00:01 04:23:59 4318 $638.80
Total amount: $638.80

❌ 1017 Queueing at Bank (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct node {
int come, time;
} tempcustomer;
bool cmp1(node a, node b) {
return a.come < b.come;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<node> custom;
for(int i = 0; i < n; i++) {
int hh, mm, ss, time;
scanf("%d:%d:%d %d", &hh, &mm, &ss, &time);
int cometime = hh * 3600 + mm * 60 + ss;
if(cometime > 61200) continue;
tempcustomer = {cometime, time * 60};
custom.push_back(tempcustomer);
}
sort(custom.begin(), custom.end(), cmp1);
vector<int> window(k, 28800);
double result = 0.0;
for(int i = 0; i < custom.size(); i++) {
int tempindex = 0, minfinish = window[0];
for(int j = 1; j < k; j++) {
if(minfinish > window[j]) {
minfinish = window[j];
tempindex = j;
}
}
if(window[tempindex] <= custom[i].come) {
window[tempindex] = custom[i].come + custom[i].time;
} else {
result += (window[tempindex] - custom[i].come);
window[tempindex] += custom[i].time;
}
}
if(custom.size() == 0)
printf("0.0");
else
printf("%.1f", result / 60.0 / custom.size());
return 0;
}

1019 General Palindromic Number (20 分)

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
#include <iostream>
using namespace std;

int main() {
int n, b;
scanf("%d %d", &n, &b);
int arr[100] = {0}, len = 0;
while (n) {
arr[len++] = n % b;
n /= b;
}
int flag = 1;
for (int i = 0; i < len / 2; i++) {
if (arr[i] != arr[len - 1 - i]) {
printf("No\n");
flag = 0;
break;
}
}
if (flag) printf("Yes\n");
for (int i = len - 1; i >= 0; i--) {
printf("%d", arr[i]);
if (i != 0) printf(" ");
}

return 0;
}

27 2
Yes
1 1 0 1 1

1020 Tree Traversals (25 分)

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
#include <iostream>
#include <queue>
using namespace std;

const int maxn = 50;

struct node {
int data;
node* lchild;
node* rchild;
};

int pre[maxn], in[maxn], post[maxn];
int n;

node* create(int postL, int postR, int inL, int inR) {
if (postL > postR) {
return NULL;
}
node* root = new node;
root->data = post[postR];
int k;
for (k = inL; k <= inR; k++) {
if (in[k] == post[postR]) {
break;
}
}
int numLeft = k - inL;
root->lchild = create(postL, postL + numLeft - 1, inL, k - 1);
root->rchild = create(postL + numLeft, postR - 1, k + 1, inR);
return root;
}

int num = 0;
void BFS(node* root) {
queue<node*> q;
q.push(root);
while (!q.empty()) {
node* now = q.front();
q.pop();
printf("%d", now->data);
num++;
if (num < n) printf(" ");
if (now->lchild != NULL) q.push(now->lchild);
if (now->rchild != NULL) q.push(now->rchild);
}
}

int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &post[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &in[i]);
}
node* root = create(0, n - 1, 0, n - 1);
BFS(root);

return 0;
}

7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

4 1 6 3 5 7 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
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct node {
int index, value;
};
bool cmp(node a, node b) {
return a.index < b.index;
}
vector<int> post, in;
vector<node> ans;
void pre(int root, int start, int end, int index) {
if (start > end) return;
int i = start;
while (i < end && in[i] != post[root]) i++;
ans.push_back({index, post[root]});
pre(root - 1 - end + i, start, i - 1, 2 * index + 1);
pre(root - 1, i + 1, end, 2 * index + 2);
}
int main() {
int n;
scanf("%d", &n);
post.resize(n);
in.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &post[i]);
for (int i = 0; i < n; i++) scanf("%d", &in[i]);
pre(n - 1, 0, n - 1, 0);
sort(ans.begin(), ans.end(), cmp);
for (int i = 0; i < ans.size(); i++) {
if (i != 0) cout << " ";
cout << ans[i].value;
}
return 0;
}

❌ 1021 Deepest Root (25 分)

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>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int n, maxheight = 0;
vector<vector<int>> v;
bool visit[10010];
set<int> s;
vector<int> temp;
void dfs(int node, int height) {
if(height > maxheight) {
temp.clear();
temp.push_back(node);
maxheight = height;
} else if(height == maxheight){
temp.push_back(node);
}
visit[node] = true;
for(int i = 0; i < v[node].size(); i++) {
if(visit[v[node][i]] == false)
dfs(v[node][i], height + 1);
}
}
int main() {
scanf("%d", &n);
v.resize(n + 1);
int a, b, cnt = 0, s1 = 0;
for(int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for(int i = 1; i <= n; i++) {
if(visit[i] == false) {
dfs(i, 1);
if(i == 1) {
if (temp.size() != 0) s1 = temp[0];
for(int j = 0; j < temp.size(); j++)
s.insert(temp[j]);
}
cnt++;
}
}
if(cnt >= 2) {
printf("Error: %d components", cnt);
} else {
temp.clear();
maxheight = 0;
fill(visit, visit + 10010, false);
dfs(s1, 1);
for(int i = 0; i < temp.size(); i++)
s.insert(temp[i]);
for(auto it = s.begin(); it != s.end(); it++)
printf("%d\n", *it);
}
return 0;
}

1023 Have Fun with Numbers (20 分)

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
#include <iostream>
#include <string.h>
using namespace std;

int book[10] = {0};
int main() {
char num[32];
scanf("%s", num);
int flag1 = 0, flag2 = 1, len = strlen(num); // 不进一位 是源数字的重新排列
for (int i = len - 1; i >= 0; i--) {
int t = num[i] - '0';
book[t]++;
t = t * 2 + flag1;
flag1 = 0;
if (t >= 10) {
t = t - 10;
flag1 = 1;
}
num[i] = t + '0';
book[t]--;
}
for (int i = 0; i < 10; i++) {
if (book[i] != 0) {
flag2 = 0;
break;
}
}
printf("%s", (flag1 == 1 || flag2 == 0) ? "No\n" : "Yes\n");
if (flag1) printf("1");
printf("%s", num);

return 0;
}

123456789
Yes
246913578

1025 PAT Ranking (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct student {
long long no;
int score, finrank, local, localrank;
};

bool cmp(student a, student b) {
return a.score != b.score ? a.score > b.score : a.no < b.no;
}

int main() {
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif

int n, m;
scanf("%d", &n);
vector<student> fin;
for (int i = 1; i <= n; i++) {
scanf("%d", &m);
vector<student> v(m);
for (int j = 0; j < m; j++) {
scanf("%lld %d", &v[j].no, &v[j].score);
v[j].local = i;
}
sort(v.begin(), v.end(), cmp);
v[0].localrank = 1;
fin.push_back(v[0]);
for (int j = 1; j < m; j++) {
v[j].localrank = (v[j].score == v[j - 1].score) ? (v[j - 1].localrank) : (j + 1);
fin.push_back(v[j]);
}
}
sort(fin.begin(), fin.end(), cmp);
fin[0].finrank = 1;
for (int j = 1; j < fin.size(); j++) {
fin[j].finrank = (fin[j].score == fin[j - 1].score) ? (fin[j - 1].finrank) : (j + 1);
}
printf("%d\n", fin.size());
for (int i = 0; i < fin.size(); i++) {
printf("%013lld %d %d %d\n", fin[i].no, fin[i].finrank, fin[i].local, fin[i].localrank);
}

return 0;
}

2
5
1234567890001 95
1234567890005 100
1234567890003 95
1234567890002 77
1234567890004 85
4
1234567890013 65
1234567890011 25
1234567890014 100
1234567890012 85

9
1234567890005 1 1 1
1234567890014 1 2 1
1234567890001 3 1 2
1234567890003 3 1 2
1234567890004 5 1 4
1234567890012 5 2 2
1234567890002 7 1 5
1234567890013 8 2 3
1234567890011 9 2 4

题目要求:The locations are numbered from 1 to N. The output must be sorted in nondecreasing order of the final ranks. The testees with the same score must have the same rank, and the output must be sorted in nondecreasing order of their registration numbers.

也就是说,学生的排名和学号都是非递减。那么排名优先是按照分数高在前,低在后。
因此用return a.score != b.score ? a.score > b.score : a.no < b.no;也就说,分数不同时,分数高优先,分数相同时,学号小优先。

1027 Colors in Mars (20 分)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;

int main() {
char c[14] = {"0123456789ABC"};
printf("#");
for (int i = 0; i < 3; i++) {
int num;
scanf("%d", &num);
printf("%c%c", c[num / 13], c[num % 13]);
}

return 0;
}

15 43 71
#123456

// 2位的13进制最多可以表示169个数(13*13)从0到168(CC)

1028 List Sorting (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

const int maxn = 100001;

struct student {
int no, score;
char name[10];
};

student s[maxn];

int c;
bool cmp(student a, student b) {
if (c == 1) {
return a.no < b.no;
} else if (c == 2) {
if (strcmp(a.name, b.name) == 0) return a.no < b.no;
return strcmp(a.name, b.name) <= 0;
} else {
if (a.score == b.score) return a.no < b.no;
return a.score <= b.score;
}
}

int main() {
int n;
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) {
scanf("%d %s %d", &s[i].no, &s[i].name, &s[i].score);
}
sort(s, s + n, cmp);
for (int i = 0; i < n; i++) {
printf("%06d %s %d\n", s[i].no, s[i].name, s[i].score);
}

return 0;
}

4 3
000007 James 85
000010 Amy 90
000001 Zoe 60
000002 James 90

1029 Median (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

const int maxn = 200001;
int num[maxn];

int main() {
int n, m, t, cnt = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
num[n + 1] = INT32_MAX;
cin >> m;
int midpos = (n + m + 1) / 2, i = 1;
for (int j = 1; j <= m; j++) {
scanf("%d", &t);
while (num[i] < t) {
cnt++;
if (cnt == midpos) cout << num[i];
i++;
}
cnt++;
if (cnt == midpos) cout << t;
}
while (i <= n) {
cnt++;
if (cnt == midpos) cout << num[i];
i++;
}

return 0;
}

4 11 12 13 14
5 9 10 15 16 17

13

1031 Hello World for U (20 分)

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
#include <iostream>
#include <string.h>
using namespace std;

char c[81], u[29][29];

int main() {
memset(u, ' ', sizeof(u));
scanf("%s", c);
int len = strlen(c) + 2;
int n1 = len / 3, n2 = len / 3 + len % 3, index = 0;
for (int i = 0; i < n1; i++) u[i][0] = c[index++];
for (int i = 1; i <= n2 - 1; i++) u[n1 - 1][i] = c[index++];
for (int i = n1 - 2; i >= 0; i--) u[i][n2 - 1] = c[index++];
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n2; j++) {
printf("%c", u[i][j]);
}
printf("\n");
}

return 0;
}

helloworld!
h !
e d
l l
lowor

1032 Sharing (25 分)

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
#include <cstdio>
using namespace std;
struct NODE {
char key;
int next;
bool flag;
}node[100000];
int main() {
int s1, s2, n, a, b;
scanf("%d%d%d", &s1, &s2, &n);
char data;
for(int i = 0; i < n; i++) {
scanf("%d %c %d", &a, &data, &b);
node[a] = {data, b, false};
}
for(int i = s1; i != -1; i = node[i].next)
node[i].flag = true;
for(int i = s2; i != -1; i = node[i].next) {
if(node[i].flag == true) {
printf("%05d", i);
return 0;
}
}
printf("-1");
return 0;
}

❌ 1033 To Fill or Not to Fill (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

const int INF = 99999999;

struct station {
double price, distance;
};

bool cmp(station a, station b) {
return a.distance < b.distance;
}

int main() {
double cmax, d, davg;
int n;
scanf("%lf %lf %lf %d", &cmax, &d, &davg, &n);
vector<station> sta(n + 1);
sta[0].price = 0.0, sta[0].distance = d;
// sta[0] = {0.0, d};
for (int i = 1; i <= n; i++) {
scanf("%lf %lf", &sta[i].price, &sta[i].distance);
}
sort(sta.begin(), sta.end(), cmp);
double nowdis = 0.0, maxdis = 0.0, nowprice = 0.0, totalPrice = 0.0, leftdis = 0.0;
if (sta[0].distance != 0.0) {
printf("The maximum travel distance = 0.00");
return 0;
} else {
nowprice = sta[0].price;
}
while (nowdis < d) {
maxdis = nowdis + cmax * davg;
double minPriceDis = 0, minPrice = INF;
int flag = 0;
for (int i = 1; i <= n && sta[i].distance <= maxdis; i++) {
if (sta[i].distance <= nowdis) continue;
if (sta[i].price < nowprice) {
totalPrice += (sta[i].distance - nowdis - leftdis) * nowprice / davg;
leftdis = 0.0;
nowprice = sta[i].price;
nowdis = sta[i].distance;
flag = 1;
break;
}
if (sta[i].price < minPrice) {
minPrice = sta[i].price;
minPriceDis = sta[i].distance;
}
}
if (flag == 0 && minPrice != INF) {
totalPrice += (nowprice * (cmax - leftdis / davg));
leftdis = cmax * davg - (minPriceDis - nowdis);
nowprice = minPrice;
nowdis = minPriceDis;
}
if (flag == 0 && minPrice == INF) {
nowdis += cmax * davg;
printf("The maximum travel distance = %.2f", nowdis);
return 0;
}
}
printf("%.2f", totalPrice);

return 0;
}

50 1300 12 8
6.00 1250
7.00 600
7.00 150
7.10 0
7.20 200
7.50 400
7.30 1000
6.85 300

749.17

​​

1035 Password (20 分)

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>
#include <vector>
using namespace std;

int main() {
int n;
scanf("%d", &n);
vector<string> res;
for (int i = 0; i < n; i++) {
string name, s;
cin >> name >> s;
int len = s.length(), flag = 0;
for (int j = 0; j < len; j++) {
if (s[j] == '1') {
s[j] = '@';
flag = 1;
} else if (s[j] == '0') {
s[j] = '%';
flag = 1;
} else if (s[j] == 'l') {
s[j] = 'L';
flag = 1;
} else if (s[j] == 'O') {
s[j] = 'o';
flag = 1;
} else {
continue;
}
}
if (flag) {
string t = name + " " + s;
res.push_back(t);
}
}
int cnt = res.size();
if (cnt) {
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) {
cout << res[i] << endl;
}
} else if (n == 1) {
printf("There is 1 account and no account is modified");
} else {
printf("There are %d accounts and no account is modified", n);
}

return 0;
}

3
Team000002 Rlsp0dfa
Team000003 perfectpwd
Team000001 R1spOdfa

2
Team000002 RLsp%dfa
Team000001 R@spodfa

# 1036 Boys vs Girls (25 分)

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
#include <iostream>
using namespace std;

int main() {
int n;
scanf("%d", &n);
string female, male;
int femalescore = -1, malescore = 101;
for (int i = 1; i <= n; i++) {
string name, sex, num;
int score;
cin >> name >> sex >> num;
scanf("%d", &score);
if (sex == "F") {
if (femalescore < score) {
femalescore = score;
female = name + " " + num;
}
} else if (malescore > score) {
malescore = score;
male = name + " " + num;
}
}
if (femalescore != -1) {
cout << female << endl;
} else {
printf("Absent\n");
}
if (malescore != 101) {
cout << male << endl;
} else {
printf("Absent\n");
}
if (femalescore != -1 && malescore != 101) {
printf("%d", femalescore - malescore);
} else {
printf("NA");
}

return 0;
}

3
Joe M Math990112 89
Mike M CS991301 100
Mary F EE990830 95

Mary EE990830
Joe Math990112
6

1037 Magic Coupon (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
int len1, len2, ans = 0, p = 0, q = 0;
scanf("%d", &len1);
vector<int> v1(len1);
for (int i = 0; i < len1; i++) {
scanf("%d", &v1[i]);
}
scanf("%d", &len2);
vector<int> v2(len2);
for (int i = 0; i < len2; i++) {
scanf("%d", &v2[i]);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
while (p < len1 && q < len2 && v1[p] < 0 && v2[q] < 0) {
ans += v1[p] * v2[q];
p++; q++;
}
p = len1 - 1, q = len2 - 1;
while (p >= 0 && q >= 0 && v1[p] > 0 && v2[q] > 0) {
ans += v1[p] * v2[q];
p--; q--;
}
printf("%d", ans);

return 0;
}

4
1 2 4 -1
4
7 6 -2 -3

43

1039 Course List for Student (25 分)

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
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int getid(char *name) {
int id = 0;
for(int i = 0; i < 3; i++)
id = 26 * id + (name[i] - 'A');
id = id * 10 + (name[3] - '0');
return id;
}
const int maxn = 26 * 26 * 26 * 10 + 10;
vector<int> v[maxn];

int main() {
int n, k, no, num, id = 0;
char name[5];
scanf("%d %d", &n, &k);
for(int i = 0; i < k; i++) {
scanf("%d %d", &no, &num);
for(int j = 0; j < num; j++) {
scanf("%s", name);
id = getid(name);
v[id].push_back(no);
}
}
for(int i = 0; i < n; i++) {
scanf("%s", name);
id = getid(name);
sort(v[id].begin(), v[id].end());
printf("%s %lu", name, v[id].size());
for(int j = 0; j < v[id].size(); j++)
printf(" %d", v[id][j]);
printf("\n");
}
return 0;
}

❌⭕ 1040 Longest Symmetric String (25 分) 对递推方程还是有疑虑

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 <iostream>
#include <algorithm>
using namespace std;

int dp[1010][1010];

int main() {
string s;
getline(cin, s);
int len = s.length(), ans = 1;
for (int i = 0; i < len; i++) {
dp[i][i] = 1;
if (i < len - 1 && s[i] == s[i + 1]) {
dp[i][i + 1] = 1;
ans = 2;
}
}
for (int l = 3; l <= len; l++) {
for (int i = 0; i + l - 1 < len; i++) {
int j = i + l - 1;
if (s[i] == s[j] && dp[i + 1][j - 1] == 1) {
dp[i][j] = 1;
ans = l;
}
}
}
printf("%d", ans);

return 0;
}

Is PAT&TAP symmetric?

11

1041 Be Unique (20 分)

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
#include <iostream>
using namespace std;

int num[100001], cnt[100001];

int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
cnt[num[i]]++;
}
for (int i = 0; i < n; i++) {
if (cnt[num[i]] == 1) {
printf("%d", num[i]);
return 0;
}
}
printf("None");

return 0;
}

7 5 31 5 88 67 88 17
31

1042 Shuffling Machine (20 分)

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
#include <iostream>
using namespace std;

int main() {
int cnt;
scanf("%d", &cnt);
int start[55], end[55], order[55];
for (int i = 1; i < 55; i++) {
scanf("%d", &order[i]);
end[i] = i;
}
for (int i = 0; i < cnt; i++) {
for (int j = 1; j < 55; j++) {
start[j] = end[j];
}
for (int j = 1; j < 55; j++) {
end[order[j]] = start[j];
}
}
char c[6] = {"SHCDJ"};
for (int i = 1; i < 55; i++) {
end[i] = end[i] - 1;
printf("%c%d", c[end[i] / 13], end[i] % 13 +1);
if (i != 54) printf(" ");
}

return 0;
}

❌ 1043 Is It a Binary Search Tree (25 分)

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
#include <cstdio>
#include <vector>
using namespace std;
bool isMirror;
vector<int> pre, post;
void getpost(int root, int tail) {
if(root > tail) return ;
int i = root + 1, j = tail;
if(!isMirror) {
while(i <= tail && pre[root] > pre[i]) i++;
while(j > root && pre[root] <= pre[j]) j--;
} else {
while(i <= tail && pre[root] <= pre[i]) i++;
while(j > root && pre[root] > pre[j]) j--;
}
if(i - j != 1) return ;
getpost(root + 1, j);
getpost(i, tail);
post.push_back(pre[root]);
}
int main() {
int n;
scanf("%d", &n);
pre.resize(n);
for(int i = 0; i < n; i++)
scanf("%d", &pre[i]);
getpost(0, n - 1);
if(post.size() != n) {
isMirror = true;
post.clear();
getpost(0, n - 1);
}
if(post.size() == n) {
printf("YES\n%d", post[0]);
for(int i = 1; i < n; i++)
printf(" %d", post[i]);
} else {
printf("NO");
}
return 0;
}

1044 Shopping in Mars (25 分)

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
#include <iostream>
#include <vector>
using namespace std;
vector<int> sum, resultArr;
int n, m;
void Func(int i, int &j, int &tempsum) {
int left = i, right = n;
while(left < right) {
int mid = (left + right) / 2;
if(sum[mid] - sum[i-1] >= m)
right = mid;
else
left = mid + 1;
}
j = right;
tempsum = sum[j] - sum[i-1];
}
int main() {
scanf("%d%d", &n, &m);
sum.resize(n+1);
for(int i = 1; i <= n; i++) {
scanf("%d", &sum[i]);
sum[i] += sum[i-1];
}
int minans = sum[n];
for(int i = 1; i <= n; i++) {
int j, tempsum;
Func(i, j, tempsum);
if(tempsum > minans) continue;
if(tempsum >= m) {
if(tempsum < minans) {
resultArr.clear();
minans = tempsum;
}
resultArr.push_back(i);
resultArr.push_back(j);
}
}
for(int i = 0; i < resultArr.size(); i += 2)
printf("%d-%d\n", resultArr[i], resultArr[i+1]);
return 0;
}

1046 Shortest Distance (20 分)

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
#include <iostream>
using namespace std;

int main() {
int n;
scanf("%d", &n);
int dis[n + 2] = {0};
int sum = 0, left, right, cnt;
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
sum += t;
dis[i + 1] = sum;
} // dis[i]表示i点的绝对距离,dis[1] = 0,dis[n+1]意思是走一圈的距离
scanf("%d", &cnt);
for (int i = 0; i < cnt; i++) {
scanf("%d %d", &left, &right);
if (left > right) { swap(left, right); }
int t = dis[right] - dis[left];
printf("%d\n", min(t, dis[n + 1] - t));
}

return 0;
}

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

3
10
7

// 也可以用
for(int i = 1; i <= n; i++) {
int temp;
scanf("%d", &temp);
sum += temp;
dis[i] = sum;
}
// 表示的是从第一个点到i下一个点的距离
// 所以dis[n]是从第一点到n点再毁1点的距离(即总长)
// 两点距离得用int temp = dis[right - 1] - dis[left - 1];来表示。
// 比如2 6,temp = dis[2-1]-dis[6-1],
// 因为dis[1]表示从1点到2点的距离,dis[5]表示从1点到6点的距离

1048 Find Coins (25 分)

1
2


1050 String Subtraction (20 分)

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
#include <iostream>
#include <string.h>
using namespace std;

char s1[10001], s2[10001];
int main() {
cin.getline(s1, 10001);
cin.getline(s2, 10001);
int len1 = strlen(s1);
int len2 = strlen(s2);
bool ASCII[300] = {false};
for (int i = 0; i< len2; i++) {
ASCII[s2[i]] = true;
}
for (int i = 0; i < len1; i++) {
if (ASCII[s1[i]] == false) {
printf("%c", s1[i]);
}
}

return 0;
}

// 因为输入会有空格,所以用cin.getline()来读取一行,用scanf遇到空格会停止

They are students.
aeiou

Thy r stdnts.

1051 Pop Sequence (25 分)

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 <iostream>
#include <vector>
#include <algorithm>
#include <stack>
using namespace std;

int main() {
int m, n, k;
scanf("%d %d %d", &m, &n, &k);
for (int i = 0; i < k; i++) {
bool flag = false;
stack<int> s;
vector<int> v(n + 1);
for (int j = 1; j <= n; j++) {
scanf("%d", &v[j]);
}
int cur = 1;
for (int j = 1; j <= n; j++) {
s.push(j);
if (s.size() > m) break;
while (!s.empty() && s.top() == v[cur]) {
s.pop();
cur++;
}
}
if (cur == n + 1) flag = true;
if (flag) printf("YES\n");
else printf("NO\n");
}

return 0;
}

5 7 5
1 2 3 4 5 6 7
3 2 1 7 5 6 4
7 6 5 4 3 2 1
5 6 4 3 7 2 1
1 7 6 5 4 3 2

YES
NO
NO
YES
NO

1054 The Dominant Color (20 分)

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
#include <iostream>
#include <map>
using namespace std;

int main() {
int m, n;
scanf("%d %d", &m, &n);
map<int, int> pixel;
int half = n * m / 2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int t;
scanf("%d", &t);
pixel[t]++;
if (pixel[t] > half) {
printf("%d", t);
return 0;
}
}
}

return 0;
}

5 3
0 0 255 16777215 24
24 24 0 0 24
24 0 24 24 24

24

1055 The World’s Richest (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

struct rich {
char name[10];
int age, money;
};

int cmp(rich a, rich b) {
if (a.money != b.money) {
return a.money > b.money;
} else if (a.age != b.age) {
return a.age < b.age;
} else {
return (strcmp(a.name, b.name) < 0);
}
}

int main() {
int n, k, num, amin, amax;
scanf("%d %d", &n, &k);
vector<rich> vt(n), v;
vector<int> book(205, 0);
for (int i = 0; i < n; i++) {
scanf("%s %d %d", vt[i].name, &vt[i].age, &vt[i].money);
}
sort(vt.begin(), vt.end(), cmp);
for (int i = 0; i < n; i++) {
if (book[vt[i].age] < 100) {
v.push_back(vt[i]);
book[vt[i].age]++;
}
}
for (int i = 0; i < k; i++) {
scanf("%d %d %d", &num, &amin, &amax);
vector<rich> t;
for (int j = 0; j < v.size(); j++) {
if (v[j].age >= amin && v[j].age <= amax) {
t.push_back(v[j]);
}
}
if (i != 0) printf("\n");
printf("Case #%d:", i + 1);
int flag = 0;
for (int j = 0; j < num && j <t.size(); j++) {
printf("\n%s %d %d", t[j].name, t[j].age, t[j].money);
flag = 1;
}
if (flag == 0) printf("\nNone");
}

return 0;

}

12 4
Zoe_Bill 35 2333
Bob_Volk 24 5888
Anny_Cin 95 999999
Williams 30 -22
Cindy 76 76000
Alice 18 88888
Joe_Mike 32 3222
Michael 5 300000
Rosemary 40 5888
Dobby 24 5888
Billy 24 5888
Nobody 5 0
4 15 45
4 30 35
4 5 95
1 45 50

Case #1:
Alice 18 88888
Billy 24 5888
Bob_Volk 24 5888
Dobby 24 5888
Case #2:
Joe_Mike 32 3222
Zoe_Bill 35 2333
Williams 30 -22
Case #3:
Anny_Cin 95 999999
Michael 5 300000
Alice 18 88888
Cindy 76 76000
Case #4:
None

1056 Mice and Rice (25 分)

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
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
struct node {
int weight, index, rank, index0;
};
bool cmp1(node a, node b) {
return a.index0 < b.index0;
}
int main() {
int n, g, num;
scanf("%d%d", &n, &g);
vector<int> v(n);
vector<node> w(n);
for(int i = 0; i < n; i++)
scanf("%d", &v[i]);
for(int i = 0; i < n; i++) {
scanf("%d", &num);
w[i].weight = v[num];
w[i].index = i;
w[i].index0 = num;
}
queue<node> q;
for(int i = 0; i < n; i++)
q.push(w[i]);
while(!q.empty()) {
int size = q.size();
if(size == 1) {
node temp = q.front();
w[temp.index].rank = 1;
break;
}
int group = size / g;
if(size % g != 0)
group += 1;
node maxnode;
int maxn = -1, cnt = 0;
for(int i = 0; i < size; i++) {
node temp = q.front();
w[temp.index].rank = group + 1;
q.pop();
cnt++;
if(temp.weight > maxn) {
maxn = temp.weight;
maxnode = temp;
}
if(cnt == g || i == size - 1) {
cnt = 0;
maxn = -1;
q.push(maxnode);
}
}
}
sort(w.begin(), w.end(), cmp1);
for(int i = 0; i < n; i++) {
if(i != 0) printf(" ");
printf("%d", w[i].rank);
}
return 0;
}

1058 A+B in Hogwarts (20 分)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;

int main() {
long long a, b, c, d, e, f;
scanf("%lld.%lld.%lld %lld.%lld.%lld", &a, &b, &c, &d, &e, &f);
long long sum = c + b * 29 + a * 17 * 29 + f + e * 29 + d * 17 * 29;
long long g = sum / (17 * 29);
sum = sum % (17 * 29);
printf("%lld.%lld.%lld", g, sum / 29, sum % 29);

return 0;
}

3.2.1 10.16.27
14.1.28

1059 Prime Factors (25 分)

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
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> prime(50000, 1);

int main() {
for (int i = 2; i * i < 50000; i++) {
for (int j = 2; j * i < 50000; j++) {
prime[i * j] = 0;
}
}
long int num;
scanf("%ld", &num);
printf("%ld=", num);
if (num == 1) printf("1");
bool state = false;
for (int i = 2; i < 50000 && num >= 2; i++) {
int cnt = 0, flag = 0;
while (prime[i] == 1 && num % i == 0) {
cnt++;
num /= i;
flag = 1;
}
if (flag) {
if (state) printf("*");
printf("%d", i);
state = true;
}
if (cnt >= 2) printf("^%d", cnt);
}
if (num > 1) printf("%s%ld", state ? "*" : "", num);

return 0;
}


97532468

97532468=2^2*11*17*101*1291

输出十万内的素数。

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <stack>
using namespace std;

vector<int> prime(100000, 1);

int main() {
#ifdef ONLINE_JUDGE
#else
// freopen("1.txt", "r", stdin);
freopen("out.txt","w",stdout);
#endif

for (int i = 2; i * i < 100000; i++) {
for (int j = 2; j * i < 100000; j++) {
prime[i * j] = 0;
}
}
printf("2");
for (int i = 3; i < 100000; i++) {
if (prime[i]) printf(" %d", i);
}

return 0;
}

5万以后的素质:

49939 49943 49957 49991 49993 49999 50021 50023 50033 50047 50051 50053 50069 50077 50087 50093 50101 50111 50119 50123 50129 50131 50147 50153 50159 50177 50207 50221 50227 50231 50261 50263 50273 50287 50291 50311 50321 50329 50333 50341 50359 50363 50377 50383 50387 50411 50417 50423 50441 50459 50461 50497 50503 50513 50527 50539 50543 50549 50551 50581 50587 50591 50593 50599 50627 50647 50651 50671 50683 50707 50723 50741 50753 50767 50773 50777 50789 50821 50833 50839 50849 50857 50867 50873 50891 50893 50909 50923 50929 50951 50957 50969 50971 50989 50993 51001 51031 51043 51047 51059 51061 51071 51109 51131 51133 51137 51151 51157 51169 51193 51197 51199 51203 51217 51229 51239 51241 51257 51263 51283 51287 51307 51329 51341 51343 51347 51349 51361 51383 51407 51413 51419 51421 51427 51431 51437 51439 51449 51461 51473 51479 51481 51487 51503 51511 51517 51521 51539 51551 51563 51577 51581 51593

sqrt(1.0 * INT32_MAX)的值。

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <cmath>
using namespace std;

int main() {
int res = sqrt(1.0 * INT32_MAX);
printf("%d", res);

return 0;
}

46340

会出现重复情况吗?会的。

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <stack>
#include <cmath>
using namespace std;

vector<int> prime(100000, 1);

int main() {
#ifdef ONLINE_JUDGE
#else
// freopen("1.txt", "r", stdin);
freopen("out.txt","w",stdout);
#endif

int cnt = 0;
for (int i = 2; i * i < 100; i++) {
for (int j = 2; j * i < 100; j++) {
prime[i * j] = 0;
printf("%2d %2d %3d ", i, j, i * j);
cnt++;
if (cnt % 5 == 0) printf("\n");
}
}
printf("\n");
printf("cnt = %d\n\n", cnt);
printf("2");
for (int i = 3; i < 100; i++) {
if (prime[i]) printf(" %d", i);
}

return 0;
}

2 2 4 2 3 6 2 4 8 2 5 10 2 6 12
2 7 14 2 8 16 2 9 18 2 10 20 2 11 22
2 12 24 2 13 26 2 14 28 2 15 30 2 16 32
2 17 34 2 18 36 2 19 38 2 20 40 2 21 42
2 22 44 2 23 46 2 24 48 2 25 50 2 26 52
2 27 54 2 28 56 2 29 58 2 30 60 2 31 62
2 32 64 2 33 66 2 34 68 2 35 70 2 36 72
2 37 74 2 38 76 2 39 78 2 40 80 2 41 82
2 42 84 2 43 86 2 44 88 2 45 90 2 46 92
2 47 94 2 48 96 2 49 98 3 2 6 3 3 9
3 4 12 3 5 15 3 6 18 3 7 21 3 8 24
3 9 27 3 10 30 3 11 33 3 12 36 3 13 39
3 14 42 3 15 45 3 16 48 3 17 51 3 18 54
3 19 57 3 20 60 3 21 63 3 22 66 3 23 69
3 24 72 3 25 75 3 26 78 3 27 81 3 28 84
3 29 87 3 30 90 3 31 93 3 32 96 3 33 99
4 2 8 4 3 12 4 4 16 4 5 20 4 6 24
4 7 28 4 8 32 4 9 36 4 10 40 4 11 44
4 12 48 4 13 52 4 14 56 4 15 60 4 16 64
4 17 68 4 18 72 4 19 76 4 20 80 4 21 84
4 22 88 4 23 92 4 24 96 5 2 10 5 3 15
5 4 20 5 5 25 5 6 30 5 7 35 5 8 40
5 9 45 5 10 50 5 11 55 5 12 60 5 13 65
5 14 70 5 15 75 5 16 80 5 17 85 5 18 90
5 19 95 6 2 12 6 3 18 6 4 24 6 5 30
6 6 36 6 7 42 6 8 48 6 9 54 6 10 60
6 11 66 6 12 72 6 13 78 6 14 84 6 15 90
6 16 96 7 2 14 7 3 21 7 4 28 7 5 35
7 6 42 7 7 49 7 8 56 7 9 63 7 10 70
7 11 77 7 12 84 7 13 91 7 14 98 8 2 16
8 3 24 8 4 32 8 5 40 8 6 48 8 7 56
8 8 64 8 9 72 8 10 80 8 11 88 8 12 96
9 2 18 9 3 27 9 4 36 9 5 45 9 6 54
9 7 63 9 8 72 9 9 81 9 10 90 9 11 99

cnt = 170

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

PS:

打印素数的几种方法及其优化

https://blog.csdn.net/aixiaodeshushu/article/details/81429285

1060 Are They Equal (25 分)

1
2


1061 Dating (20 分)

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
#include <iostream>
using namespace std;

int main() {
string a, b, c, d;
cin >> a >> b >> c >> d;
char t[2];
int pos, i = 0, j = 0;
while (i < a.length() && i < b.length()) {
if (a[i] == b[i] && (a[i] >= 'A' && a[i] <= 'G')) {
t[0] = a[i];
break;
}
i++;
}
i = i + 1;
while (i < a.length() && i < b.length()) {
if (a[i] == b[i] && ((a[i] >= 'A' && a[i] <= 'N') || isdigit(a[i]))) {
t[1] = a[i];
break;
}
i++;
}
while (j < c.length() && j < d.length()) {
if (c[j] == d[j] && isalpha(c[j])) {
pos = j;
break;
}
j++;
}
string week[7] = {"MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"};
int m = isdigit(t[1]) ? t[1] - '0' : t[1] - 'A' + 10;
cout << week[t[0] - 'A'] << " ";
printf("%02d:%02d", m, pos);
return 0;
}

3485djDkxh4hhGE
2984akDfkkkkggEdsb
s&hgsfdk
d&Hyscvnm

THU 14:04

1065 A+B and C (64bit) (20 分)

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
#include <iostream>
using namespace std;

int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long a, b, c;
scanf("%lld %lld %lld", &a, &b, &c);
long long sum = a + b;
if (a > 0 && b > 0 && sum < 0) {
printf("Case #%d: true\n", i + 1);
} else if (a < 0 && b < 0 && sum >= 0) {
printf("Case #%d: false\n", i + 1);
} else if (sum > c) {
printf("Case #%d: true\n", i + 1);
} else {
printf("Case #%d: false\n", i + 1);
}
}

return 0;
}

3
1 2 3
2 3 4
9223372036854775807 -9223372036854775808 0

Case #1: false
Case #2: true
Case #3: false

1069 The Black Hole of Numbers

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
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

bool cmp(int a, int b) {
return a > b;
}

void to_array(int n, int num[]) {
for (int i = 0; i < 4; i++) {
num[i] = n % 10;
n /= 10;
}
}

int to_num(int num[]) {
int sum = 0;
for (int i = 0; i < 4; i++) {
sum = sum * 10 + num[i];
}
return sum;
}

int main() {
int n, MIN, MAX;
scanf("%d", &n);
int num[5];
for (; ;) { // 也可以用while (1)
to_array(n, num);
sort(num, num + 4);
MIN = to_num(num);
sort(num, num + 4, cmp);
MAX = to_num(num);
n = MAX - MIN;
printf("%04d - %04d = %04d\n", MAX, MIN, n);
if (n == 0 || n == 6174) break;
}

return 0;
}

6767

7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174

1073 Scientific Notation (20 分)

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
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int i = 0;
while (s[i] != 'E') i++;
string t = s.substr(1, i-1);
int n = stoi(s.substr(i+1));
if (s[0] == '-') cout << "-";
if (n < 0) {
cout << "0.";
for (int j = 0; j < abs(n) - 1; j++) cout << '0';
for (int j = 0; j < t.length(); j++)
if (t[j] != '.') cout << t[j];
} else {
cout << t[0];
int cnt, j;
for (j = 2, cnt = 0; j < t.length() && cnt < n; j++, cnt++) cout << t[j];
if (j == t.length()) {
for (int k = 0; k < n - cnt; k++) cout << '0';
} else {
cout << '.';
for (int k = j; k < t.length(); k++) cout << t[k];
}
}
return 0;
}

1077 Kuchiguse (20 分)

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
#include <iostream>
#include <algorithm>
using namespace std;

int main() {
int n;
scanf("%d\n", &n);
string ans;
for(int i = 0; i < n; i++) {
string s;
getline(cin ,s);
int lens = s.length();
reverse(s.begin(), s.end());
if (i == 0) {
ans = s;
continue;
} else {
int lenans = ans.length();
if (lenans > lens) swap(ans, s);
int minlen = min(lens, lenans);
for (int j = 0; j < minlen; j++) {
if (ans[j] != s[j]) {
ans = ans.substr(0, j);
break;
}
}
}
}
reverse(ans.begin(), ans.end());
if (ans.length() == 0) printf("nai");
cout << ans;

return 0;
}

// scanf“%d”少了个\n出错

3
Itai nyan~
Ninjin wa iyadanyan~
uhhh nyan~

nyan~

1078 Hashing (25 分)

1
2


1081 Rational Sum (20 分)

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
#include <iostream>
using namespace std;

long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}

int main() {
long long n, a, b, suma = 0, sumb = 1, gcdval;
scanf("%lld\n", &n);
for (int i = 0; i < n; i++) {
scanf("%lld/%lld", &a, &b);
gcdval = gcd(a, b);
a = a / gcdval;
b = b / gcdval;
suma = suma * b + sumb * a;
sumb = sumb * b;
gcdval = gcd(suma, sumb);
suma = suma / gcdval;
sumb = sumb / gcdval;
}
long long integer = suma / sumb;
suma = suma - (sumb * integer);
if (integer != 0) {
printf("%lld", integer);
if (suma != 0) printf(" ");
}
if (suma != 0) {
printf("%lld/%lld", suma, sumb);
}
if (integer == 0 && suma == 0) {
printf("0");
}

return 0;
}


3
1/3 -1/6 1/8

1084 Broken Keyboard (20 分)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;

int main() {
string s1, s2, res;
cin >> s1 >> s2;
for (int i = 0; i< s1.length(); i++) {
if (s2.find(s1[i]) == string::npos && res.find(toupper(s1[i])) == string::npos) {
res += toupper(s1[i]);
}
}
cout << res;

return 0;
}

7_This_is_a_test
_hs_s_a_es

7TI

1088 Rational Arithmetic (20 分) !!!

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
#include <iostream>
#include <cmath>
using namespace std;

long long a, b, c, d;

long long gcd(long long a, long long b) {
return !b ? abs(a) : gcd(b, a % b);
}

void f(long long m, long long n) {
if (m == 0 | n == 0) {
printf("%s", n == 0 ? "Inf" : "0");
return;
}
bool flag = (m < 0 && n > 0) || (m > 0 && n < 0);
m = abs(m), n = abs(n);
long long x = m / n;
printf("%s", flag ? "(-" : "");
if (x != 0) printf("%lld", x);
if (m % n == 0) {
if (flag) printf(")");
return;
}
if (x != 0) printf(" ");
m = m - x * n;
long long gcdval = gcd(m, n);
m = m / gcdval, n = n / gcdval;
printf("%lld/%lld%s", m, n, flag ? ")" : "");
}

int main() {
scanf("%lld/%lld %lld/%lld", &a, &b, &c, &d);
f(a, b);
printf(" + ");
f(c, d);
printf(" = ");
f(a * d + b * c, b * d);
printf("\n");

f(a, b);
printf(" - ");
f(c, d);
printf(" = ");
f(a * d - b * c, b * d);
printf("\n");

f(a, b);
printf(" * ");
f(c, d);
printf(" = ");
f(a * c, b * d);
printf("\n");

f(a, b);
printf(" / ");
f(c, d);
printf(" = ");
f(a * d, b * c);
printf("\n");

return 0;
}

2/3 -4/2

2/3 + (-2) = (-1 1/3)
2/3 - (-2) = 2 2/3
2/3 * (-2) = (-1 1/3)
2/3 / (-2) = (-1/3)

1092 To Buy or Not to Buy (20 分)

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 <iostream>
using namespace std;

int book[300];

int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < a.length(); i++) {
book[a[i]]++;
}
int res = 0;
for (int i = 0; i < b.length(); i++) {
if (book[b[i]] > 0) {
book[b[i]]--;
}
else {
res++;
}
}
if (res == 0) {
printf("Yes %d", a.length() - b.length());
}
else {
printf("No %d", res);
}

return 0;
}

ppRYYGrrYB225
YrR8RrY

No 2

1096 Consecutive Factors (20 分)

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
#include <iostream>
#include <cmath>
using namespace std;

int num, temp;

int main() {
cin >> num;
int begin = 0, len = 0, maxn = sqrt(num) + 1;
for (int i = 2; i <= maxn; i++) {
int j;
temp = 1;
for (j = i; j <= maxn; j++) {
temp *= j;
if (num % temp != 0) break;
}
if (j - i > len) {
len = j - i;
begin = i;
}
}
if (begin == 0) {
cout << 1 << endl << num;
} else {
cout << len << endl;
for (int i = 0; i < len; i++) {
cout << begin + i;
if (i != len - 1) cout << '*';
}
}

return 0;
}

630

3
5*6*7

1100 Mars Numbers (20 分)

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
#include <iostream>
#include <string>
using namespace std;

string a[13] = {"tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov", "dec"};
string b[13] = {"####", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer", "jou"};
string s;
int len;

void toMars(int n) {
if (n / 13) cout << b[n / 13];
if ((n / 13) && (n % 13)) cout << " ";
if (n % 13 || n == 0) cout << a[n % 13];
}

void toEarth() {
int t1 = 0, t2 = 0;
string s1 = s.substr(0, 3), s2;
if (len > 4) s2 = s.substr(4, 3);
for (int i = 0; i <= 12; i++) {
if (s1 == a[i] || s2 == a[i]) t2 = i;
if (s1 == b[i]) t1 = i;
}
cout << t1 * 13 + t2;
}

int main() {
int n;
cin >> n;
getchar(); // 用来接收回车的。
for (int i = 0; i < n; i++) {
getline(cin, s);
len = s.length();
if (s[0] >= '0' && s[0] <= '9') {
toMars(stoi(s));
} else {
toEarth();
}
cout << endl;
}

return 0;
}

4
29
5
elo nov
tam

hel mar
may
115
13

1104 Sum of Number Segments (20 分)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;

int main() {
int n;
cin >> n;
double sum = 0.0, t;
for (int i = 1; i <= n; i++) {
cin >> t;
sum = sum + (t * i * (n - (i - 1)));
}
printf("%.2f", sum);

return 0;
}


4
0.1 0.2 0.3 0.4

5.00

1108 Finding Average (20 分)

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
#include <iostream>
#include <string.h>
using namespace std;

int main() {
int n, cnt = 0;
char a[60], b[60];
double sum = 0.0, t;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%s", a);
sscanf(a, "%lf", &t);
sprintf(b, "%.2f", t);
int flag = 0;
for (int j = 0; j < strlen(a); j++) {
if (a[j] != b[j]) flag = 1;
}
if (flag || t < -1000 || t > 1000) {
printf("ERROR: %s is not a legal number\n", a);
continue;
} else {
sum += t;
cnt++;
// printf("a = %s, b = %s.\n", a, b);
// a也可能比b短,比如输入5,a = 5, b = 5.00
// 所以用j < strlen(a)
}
}
if (cnt == 1) {
printf("The average of 1 number is %.2f", sum);
} else if (cnt > 1) {
printf("The average of %d numbers is %.2f", cnt, sum / cnt);
} else {
printf("The average of 0 numbers is Undefined");
}

return 0;
}

《算法竞赛入门经典》 第4章-函数与程序结构

发表于 2019-07-20 | 分类于 《算法竞赛入门经典》

基础知识

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
// 计算两点之间的欧几里德的距离
double dist(double x1, double x2, double y1, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

double dist_1(double x1, double y1, double x2, double y2) {
double dx = x1 - x2;
double dy = y1 - y2;
return hypot(dx, dy);
}

struct Point {
double x, y;
};

double dist_2(struct Point a, struct Point b) {
return hypot(a.x - b.x, a.y - b.y);
}

typedef struct {
double x, y;
}Point_;

double dist_3(Point_ a, Point_ b) {
return hypot(a.x - b.x, a.y - b.y);
}
1
2
3
4
5
6
7
8
9
10
11
12
// 4.1 组合数(有BUG,中间变量可能会溢出)
long long factorial(int n) {
long long m = 1;
for (int i = 1; i <= n; i++) {
m *= i;
}
return m;
}

long long C(int n, int m) {
return factorial(n) / (factorial(m) * factorial(n - m));
}
1
2
3
4
5
6
7
8
// 4.1 组合数
long long C(int n, int m) {
if (m < n - m) m = n - m;
long long ans = 1;
for (int i = m + 1; i <= n; i++) ans *= i;
for (int i = 1; i <= n - m; i++) ans /= i;
return ans;
}
1
2
3
4
5
6
7
// 4.2 素数判定 (有问题)
int is_prime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}

1会被误判为素数,当n太大的时候,当n为接近int最大值的素数时候,i*i有可能会发生溢出。

1
2
3
4
5
6
7
8
9
// 4.2 素数判定
int is_prime_1(int n) {
if (n <= 1) return 0;
int m = floor(sqrt(n) + 0.5);
for (int i = 2; i <= m, i++) {
if (n % i == 0) return 0;
}
return 1;
}

避免了重复计算sqrt(n),同时+0.5避免了xxx.99999出现后取整的误差。

1
2
3
4
5
6
7
8
9
// 4.3 用函数交换变量(错误)
void swap(int a, int b) {
int t = a; a = b; b = t;
}

int a, b;
a = 3; b = 4;
swap(3, 4);
printf("a: %d b: %d\n", a, b);

同理,试了下,java也是不行的。

1
2
3
4
5
6
7
8
9
10
11
public static void swap(int a, int b) {
int t = a;
a = b;
b = t;
}

public static void main(String[] args) {
int a = 3, b = 4;
swap(a, b);
System.out.printf("a = %d, b = %d.", a, b);
}

1
2
3
4
5
6
7
8
9
10
// 4.3 用函数交换变量
void swap(int* a, int* b) {
int t = *a; *a = *b; *b = t;
}

int a =3, b = 4;
swap(&a, &b);
printf("a = %d, b = %d\n", a, b);

a = 4, b = 3

Q:递归和迭代到底是什么关系?

1
2
3
4
5
6
7
8
9
10
11
12
13
// 计算数组的元素和(错误,PS:C++中是可行的,亲测)
int sum(int a[]) {
int ans = 0;
for (int i = 0; i < sizeof(a); i++) {
ans += a[i];
}
return ans;
}

int a[] = {1,2,3};
printf("%d\n", sum(a));

6(C++测得)

新建了个c项目测试了下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>

int sum(int a[]) {
int ans = 0;
for (int i = 0; i < sizeof(a); i++) {
ans += a[i];
}
return ans;
}

int main() {
int a[] = {1,2,3};
printf("%d\n", sum(a));
return 0;
}

D:\Markdown\Coding\C\Exercises\main.c: In function 'sum':
D:\Markdown\Coding\C\Exercises\main.c:5:31: warning: 'sizeof' on array function parameter 'a' will return size of 'int *' [-Wsizeof-array-argument]
for (int i = 0; i < sizeof(a); i++) {
^
D:\Markdown\Coding\C\Exercises\main.c:3:13: note: declared here
int sum(int a[]) {

修改后:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>

int sum(int* a, int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
return ans;
}

int main() {
int a[] = {1,2,3};
printf("%d\n", sum(a + 1, 2));
return 0;
}

5

回到c++的环境中来:c可以的c++一定可以嘛。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 计算数组的元素和(正确)
int sum(int* a, int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
return ans;
}

int a[] = {1,2,3};
printf("%d\n", sum(a + 1, 2));
return 0;

5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 计算左闭右开区间的元素和(两种写法)
// 方法一
int sum(int* begin, int* end) {
int n = end - begin;
int ans = 0;
for (int i = 0; i < n; i++) {
ans += begin[i];
}
return ans;
}

// 方法二
int sum(int* begin, int* end) {
int *p = begin;
int ans = 0;
for (int *p = begin; p != end; p++) {
ans += *p;
}
return ans;
}

暂时掠过:函数做参数。道理明白,题先放着。

1
2
3
4
// 用递归计算阶乘
int f(int n){
return n == 0 ? 1 : f(n - 1) * n;
};

记住,调用自己和调用其他函数没有什么本质不同。

4-1 UVa1339 Ancient Cipher

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int main() {
char s1[200], s2[200];
while(scanf("%s%s", s1, s2) == 2) {
int n = strlen(s1);
int cnt1[26] = {0}, cnt2[26] = {0};
for(int i = 0; i < n; i++) cnt1[s1[i] - 'A']++;
for(int i = 0; i < n; i++) cnt2[s2[i] - 'A']++;
sort(cnt1, cnt1 + 26);
sort(cnt2, cnt2 + 26);
int ok = 1;
for(int i = 0; i < 26; i++)
if(cnt1[i] != cnt2[i]) ok = 0;
if(ok) printf("YES\n"); else printf("NO\n");
}
return 0;
}


JWPUDJSTVP
VICTORIOUS

YES

4-2 UVa489 Hangman Judge

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
#include <bits/stdc++.h>
using namespace std;

#define maxn 105
int Left, Chance; // 还要猜left个位置,错chance次后就会输
char s[maxn], s1[maxn];
int win, lose;

void guess(char ch) {
int bad = 1;
for (int i = 0; i < strlen(s); i++) {
if (s[i] == ch) { Left--; s[i] = ' '; bad = 0; }
}
if (bad) Chance--;
if (!Chance) lose = 1;
if (!Left) win = 1;
}

int main() {
int rnd;
while (scanf("%d%s%s", &rnd, s, s1) == 3 && rnd != -1) {
printf("Round %d\n", rnd);
win = lose = 0;
Left = strlen(s);
Chance = 7;
for (int i = 0; i < strlen(s1); i++) {
guess(s1[i]);
if (win || lose) break;
}
if (win) printf("You win.\n");
else if (lose) printf("You lose.\n");
else printf("You chickened out.\n");
}

return 0;
}

4-3 UVa133 The Dole Queue

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
#include <bits/stdc++.h>
using namespace std;

#define maxn 25
int n, m, k, cell[maxn];

int go(int p, int d, int t) {
while (t--) {
do {
p = (p + d + n - 1) % n + 1;
} while (cell[p] == 0);
}
return p;
}

int main() {
while (scanf("%d%d%d", &n, &k, &m) == 3 && n) {
for (int i = 1; i <= n; i++) cell[i] = i;
int left = n;
int p1 = n, p2 = 1;
while (left) {
p1 = go(p1, 1, k);
p2 = go(p2, -1, m);
printf("%3d", p1); left--;
if (p2 != p1) { printf("%3d", p2); left--; }
cell[p1] = cell[p2] = 0;
if (left) printf(",");
}
printf("\n");
}

return 0;
}

4-4 UVa213 Message Decoding

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
#include <bits/stdc++.h>
using namespace std;

int readchar() { // 实现跨行读字符
for (; ;) {
int ch = getchar();
if (ch != '\n' && ch != '\r') return ch;
}
}

int readint(int c) { // 读取c位的二进制符,并转换为十进制
int v = 0;
while (c--) v = v * 2 + readchar() - '0';
return v;
}

int code[8][1<<8]; // 把1左移8位,相当于1×2^8,等于256

int readcode() { // 读取编码
memset(code, 0, sizeof(code));
code[1][0] = readchar();
for (int len = 2; len < 8; len++) {
for (int i = 0; i < (1<<len) - 1; i++) {
int ch = getchar();
if (ch == EOF) return 0;
if (ch == '\n' || ch == '\r') return 1;
code[len][i] = ch;
}
}
return 1;
}

int main() {
while (readcode()) {
for (; ;) {
int len = readint(3);
if (len == 0) break;
for (; ;) {
int v = readint(len);
if (v == (1 << len) - 1) break;
putchar(code[len][v]);
}
}
printf("\n");
}

return 0;
}

TNM AEIOU
0010101100011
1010001001110110011
11000

TAN ME

4-5 UVa512 Spreadsheet Tracking (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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// UVa512 Spreadsheet Tracking (算法1)
// Rujia Liu
#include<stdio.h>
#include<string.h>
#define maxd 100
#define BIG 10000
int r, c, n, d[maxd][maxd], d2[maxd][maxd], ans[maxd][maxd], cols[maxd];

void copy(char type, int p, int q) {
if(type == 'R') {
for(int i = 1; i <= c; i++)
d[p][i] = d2[q][i];
} else {
for(int i = 1; i <= r; i++)
d[i][p] = d2[i][q];
}
}

void del(char type) {
memcpy(d2, d, sizeof(d));
int cnt = type == 'R' ? r : c, cnt2 = 0;
for(int i = 1; i <= cnt; i++) {
if(!cols[i]) copy(type, ++cnt2, i);
}
if(type == 'R') r = cnt2; else c = cnt2;
}

void ins(char type) {
memcpy(d2, d, sizeof(d));
int cnt = type == 'R' ? r : c, cnt2 = 0;
for(int i = 1; i <= cnt; i++) {
if(cols[i]) copy(type, ++cnt2, 0);
copy(type, ++cnt2, i);
}
if(type == 'R') r = cnt2; else c = cnt2;
}

int main() {
int r1, c1, r2, c2, q, kase = 0;
char cmd[10];
memset(d, 0, sizeof(d));
while(scanf("%d%d%d", &r, &c, &n) == 3 && r) {
int r0 = r, c0 = c;
for(int i = 1; i <= r; i++)
for(int j = 1; j <= c; j++)
d[i][j] = i*BIG + j;
while(n--) {
scanf("%s", cmd);
if(cmd[0] == 'E') {
scanf("%d%d%d%d", &r1, &c1, &r2, &c2);
int t = d[r1][c1]; d[r1][c1] = d[r2][c2]; d[r2][c2] = t;
} else {
int a, x;
scanf("%d", &a);
memset(cols, 0, sizeof(cols));
for(int i = 0; i < a; i++) { scanf("%d", &x); cols[x] = 1; }
if(cmd[0] == 'D') del(cmd[1]); else ins(cmd[1]);
}
}
memset(ans, 0, sizeof(ans));
for(int i = 1; i <= r; i++)
for(int j = 1; j <= c; j++) {
ans[d[i][j]/BIG][d[i][j]%BIG] = i*BIG+j;
}
if(kase > 0) printf("\n");
printf("Spreadsheet #%d\n", ++kase);

scanf("%d", &q);
while(q--) {
scanf("%d%d", &r1, &c1);
printf("Cell data in (%d,%d) ", r1, c1);
if(ans[r1][c1] == 0) printf("GONE\n");
else printf("moved to (%d,%d)\n", ans[r1][c1]/BIG, ans[r1][c1]%BIG);
}
}
return 0;
}

7 9
5
DR 2 1 5
DC 4 3 6 7 9
IC 1 3
IR 2 2 4
EX 1 2 6 5
4
4 8
5 5
7 8
6 5
0 0

Spreadsheet #1
Cell data in (4,8) moved to (4,6)
Cell data in (5,5) GONE
Cell data in (7,8) moved to (7,6)
Cell data in (6,5) moved to (1,2)

# 4-5 UVa512 Spreadsheet Tracking (B)

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
// UVa512 Spreadsheet Tracking (算法2)
// Rujia Liu
#include<stdio.h>
#include<string.h>
#define maxd 10000

struct Command {
char c[5];
int r1, c1, r2, c2;
int a, x[20];
} cmd[maxd];
int r, c, n;

int simulate(int* r0, int* c0) {
for(int i = 0; i < n; i++) {
if(cmd[i].c[0] == 'E') {
if(cmd[i].r1 == *r0 && cmd[i].c1 == *c0) { *r0 = cmd[i].r2; *c0 = cmd[i].c2; }
else if(cmd[i].r2 == *r0 && cmd[i].c2 == *c0) { *r0 = cmd[i].r1; *c0 = cmd[i].c1; }
} else {
int dr = 0, dc = 0;
for(int j = 0; j < cmd[i].a; j++) {
int x = cmd[i].x[j];
if(cmd[i].c[0] == 'I') {
if(cmd[i].c[1] == 'R' && x <= *r0) dr++;
if(cmd[i].c[1] == 'C' && x <= *c0) dc++;
}
else {
if(cmd[i].c[1] == 'R' && x == *r0) return 0;
if(cmd[i].c[1] == 'C' && x == *c0) return 0;
if(cmd[i].c[1] == 'R' && x < *r0) dr--;
if(cmd[i].c[1] == 'C' && x < *c0) dc--;
}
}
*r0 += dr; *c0 += dc;
}
}
return 1;
}

int main() {
int r0, c0, q, kase = 0;
while(scanf("%d%d%d", &r, &c, &n) == 3 && r) {
for(int i = 0; i < n; i++) {
scanf("%s", cmd[i].c);
if(cmd[i].c[0] == 'E') {
scanf("%d%d%d%d", &cmd[i].r1, &cmd[i].c1, &cmd[i].r2, &cmd[i].c2);
} else {
scanf("%d", &cmd[i].a);
for(int j = 0; j < cmd[i].a; j++) scanf("%d", &cmd[i].x[j]);
}
}
if(kase > 0) printf("\n");
printf("Spreadsheet #%d\n", ++kase);

scanf("%d", &q);
while(q--) {
scanf("%d%d", &r0, &c0);
printf("Cell data in (%d,%d) ", r0, c0);
if(!simulate(&r0, &c0)) printf("GONE\n");
else printf("moved to (%d,%d)\n", r0, c0);
}
}
return 0;
}

4-6 UVa12412 A Typical Homework

1
2


1
2
3
4
5
6
7
int main() {
freopen("D:\\Markdown\\Coding\\C++\\temporary\\in.txt", "r", stdin);
freopen("D:\\Markdown\\Coding\\C++\\temporary\\out.txt", "w", stdout);

fclose(stdin);
fclose(stdout);
}

《算法竞赛入门经典》 第5章 C++与STL入门

发表于 2019-07-19 | 分类于 《算法竞赛入门经典》

5-2 UVa101 The Blocks Problem

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
#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
using namespace std;

const int MAXN = 30;
int n;
vector<int> pile[MAXN];

// 找木块a所在的pile和height,以引用的形式返回调用者
void find_block(int a, int& p, int& h) {
for (p = 0; p < n; p++) {
for (h = 0; h < pile[p].size(); h++) {
if (pile[p][h] == a) {
return;
}
}
}
}

// 把第p堆高度为h的木块上方的所有木块移回原位
void clear_above(int p, int h) {
for (int i = h + 1; i < pile[p].size(); i++) {
int b = pile[p][i];
pile[b].push_back(b);
}
pile[p].resize(h + 1);
}

// 把第p堆高度h及其上方的木块整体移动到p2堆的顶部
void pile_onto(int p, int h, int p2) {
for (int i = h; i < pile[p].size(); i++) {
pile[p2].push_back(pile[p][i]);
}
pile[p].resize(h);
}

void print() {
for (int i = 0; i < n; i++) {
printf("%d:", i);
for (int j = 0; j < pile[i].size(); j++) {
printf(" %d", pile[i][j]);
}
printf("\n");
}
}

int main() {
int a, b;
cin >> n;
string s1, s2;
for (int i = 0; i < n; i++) {
pile[i].push_back(i);
}
while (cin >> s1 >> a >> s2 >> b) {
int pa, pb, ha, hb;
find_block(a, pa, ha);
find_block(b, pb, hb);
if (pa == pb) {
continue;
}
if (s2 == "onto") {
clear_above(pb, hb);
}
if (s1 == "move") {
clear_above(pa, ha);
}
pile_onto(pa, ha, pb);
}
print();

return 0;
}

5-3 UVa10815 Andy’s First Dictionary

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
#include<iostream>
#include<string>
#include<set>
#include<sstream>
using namespace std;

set<string> dict;
string s, buf;

int main() {
while (cin >> s) {
for (int i = 0; i < s.length(); i++) {
if (isalpha(s[i])) {
s[i] = tolower(s[i]);
} else {
s[i] = ' ';
}
}
stringstream ss(s);
while (ss >> buf) {
dict.insert(buf);
}
}
for (set<string>::iterator it = dict.begin(); it != dict.end(); it++) {
cout << *it << "\n";
}

return 0;
}

5-4 UVa156 Ananagrams

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
#include<iostream>
#include<string>
#include<cctype>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;

map<string, int> cnt;
vector<string> words;

string repr(string s) {
string res = s;
for (int i = 0; i < res.length(); i++) {
res[i] = tolower(res[i]);
}
sort(res.begin(), res.end());
return res;
}

int main() {
int n = 0;
string s;
while (cin >> s) {
if (s[0] == '#') {
break;
}
words.push_back(s);
string res = repr(s);
if (!cnt.count(res)) {
cnt[res] = 0;
}
cnt[res]++;
}
vector<string> res;
for (int i = 0; i < words.size(); i++) {
if (cnt[repr(words[i])] == 1) {
res.push_back(words[i]);
}
}
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) {
cout << res[i] << "\n";
}

return 0;
}

5-5 UVa12096 The SetStack Computer

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<iostream>
#include<string>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
using namespace std;

#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())

typedef set<int> Set;
map<Set,int> IDcache; // 把集合映射成ID
vector<Set> Setcache; // 根据ID取集合

// 查找给定集合x的ID。如果找不到,分配一个新ID
int ID (Set x) {
if (IDcache.count(x)) return IDcache[x];
Setcache.push_back(x); // 添加新集合
return IDcache[x] = Setcache.size() - 1;
}

int main () {
int T;
cin >> T;
while(T--) {
stack<int> s; // 题目中的栈
int n;
cin >> n;
for(int i = 0; i < n; i++) {
string op;
cin >> op;
if (op[0] == 'P') s.push(ID(Set()));
else if (op[0] == 'D') s.push(s.top());
else {
Set x1 = Setcache[s.top()]; s.pop();
Set x2 = Setcache[s.top()]; s.pop();
Set x;
if (op[0] == 'U') set_union (ALL(x1), ALL(x2), INS(x));
if (op[0] == 'I') set_intersection (ALL(x1), ALL(x2), INS(x));
if (op[0] == 'A') { x = x2; x.insert(ID(x1)); }
s.push(ID(x));
}
cout << Setcache[s.top()].size() << endl;
}
cout << "***" << endl;
}
return 0;
}

2
9
PUSH
DUP
ADD
PUSH
ADD
DUP
ADD
DUP
UNION
5
PUSH
PUSH
ADD
PUSH
INTERSECT

5-6 UVa540 Team Queue

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
#include <cstdio>
#include <map>
#include <queue>
using namespace std;

const int MAXT = 1000 + 10;

int main () {
int t, kase = 1;
while (scanf("%d", &t) == 1 && t) {
printf("Scenario #%d\n", kase++);

map<int, int> team;
for (int i = 0; i < t; i++) {
int n, x;
scanf("%d", &n);
while (n--) { scanf("%d", &x); team[x] = i; }
}

queue<int> q, q2[MAXT];
for ( ; ; ) {
int x;
char cmd[10];
scanf("%s", cmd);
if (cmd[0] == 'S') { break; }
else if (cmd[0] == 'E') {
scanf("%d", &x);
int t = team[x];
if (q2[t].empty()) q.push(t);
q2[t].push(x);
}
else if (cmd[0] == 'D') {
int t = q.front();
printf("%d\n", q2[t].front());
q2[t].pop();
if (q2[t].empty()) q.pop();
}
}
printf("\n");
}

return 0;
}

5-7 UVa136 Ugly Numbers

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
// UVa136 Ugly Numbers
// Rujia Liu
#include<iostream>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long LL;
const int coeff[3] = {2, 3, 5};

int main() {
priority_queue<LL, vector<LL>, greater<LL> > pq;
set<LL> s;
pq.push(1);
s.insert(1);
for(int i = 1; ; i++) {
LL x = pq.top(); pq.pop();
if(i == 1500) {
cout << "The 1500'th ugly number is " << x << ".\n";
break;
}
for(int j = 0; j < 3; j++) {
LL x2 = x * coeff[j];
if(!s.count(x2)) { s.insert(x2); pq.push(x2); }
}
}
return 0;
}

1 2
123412341

5-8 UVa400 Unix ls

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
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

const int MAXCOL = 60;
const int MAXN = 100 + 5;
string filenames[MAXN];

void print(const string& s, int len, char extra) {
cout << s;
for (int i = 0; i < len - s.length(); i++) {
cout << extra;
}
}

int main() {
int n;
while (cin >> n) {
int M = 0;
for (int i = 0; i < n; i++) {
cin >> filenames[i];
M = max(M, (int)filenames[i].length());
}
// 计算列数cols和行数rows
int cols = (MAXCOL - M) / (M + 2) + 1;
// (M+2)(M+2)......M,几个(M+2)加一
int rows = (n - 1) / cols + 1;
// 如果clos为3,n为12,那么结果为5,但其实只要4行就可以
// (n - 1) / cols 避免行列填满的情况导致结果多1
// +1是为了不够clos的部分也得给他们留一行
print("", 60, '-');
cout << "\n";
sort(filenames, filenames + n);
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
int idx = c * rows + r;
// 只能一行一行来,因为每一行需要一个回车
// 从0行开始,0行0列,0行1列,0行2列,所以一开始r是0
if (idx < n) print(filenames[idx], c == cols - 1 ? M : M + 2, ' ');
}
cout << "\n";
}
}

return 0;
}

5-9 UVa1592 Database

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
// UVa1592 Database
// Rujia Liu
// 本程序只是为了演示STL各种用法,效率较低。实践中一般用C字符串和哈希表来实现。




using namespace std;

typedef pair<int,int> PII;

const int maxr = 10000 + 5;
const int maxc = 10 + 5;

int m, n, db[maxr][maxc], cnt;

map<string, int> id;
int ID(const string& s) {
if(!id.count(s)) {
id[s] = ++cnt;
}
return id[s];
}

void find() {
for(int c1 = 0; c1 < m; c1++)
for(int c2 = c1+1; c2 < m; c2++) {
map<PII, int> d;
for(int i = 0; i < n; i++) {
PII p = make_pair(db[i][c1], db[i][c2]);
if(d.count(p)) {
printf("NO\n");
printf("%d %d\n", d[p]+1, i+1);
printf("%d %d\n", c1+1, c2+1);
return;
}
d[p] = i;
}
}
printf("YES\n");
}


int main() {
string s;
while(getline(cin, s)) {
stringstream ss(s);
if(!(ss >> n >> m)) break;
cnt = 0;
id.clear();
for(int i = 0; i < n; i++) {
getline(cin, s);
int lastpos = -1;
for(int j = 0; j < m; j++) {
int p = s.find(',', lastpos+1);
if(p == string::npos) p = s.length();
db[i][j] = ID(s.substr(lastpos+1, p - lastpos - 1));
lastpos = p;
}
}
find();
}
return 0;
}

`c++

#include

#include

#include

#include

#include

#include
using namespace std;

typedef pair<int, int> PII;

const int MAXR = 10000 + 5;
const int MAXC = 10 + 5;

int m, n, db[MAXR][MAXC], cnt;
map<string, int> id;

int ID(const string& s) {
if (!id.count(s)) {
id[s] = ++cnt;
}
return id[s];
}

int main() {

return 0;

}

`10-11 UVa11181 ProbabilityGiven

123…8

REQg

78 日志
4 分类
22 标签
© 2020 REQg
由 Hexo 强力驱动
|
主题 — NexT.Mist v5.1.4
浙ICP备 - 19004121号