DouKaku?

| 各階待ち人数 階数 最大搭乗人数 ボックス内人数 ボックス停止階 
  ラウンド数 移動数 完了ラウンド数 放置ラウンド数 ボックス移動 状態出力 |

各階待ち人数 := #(0 7 3 11 7).
階数 := 各階待ち人数 size.
最大搭乗人数 := 3.
ボックス内人数 := 0.
ボックス停止階 := 1.
ラウンド数 := 0.
移動数 := 0.
完了ラウンド数 := Array new: 階数 withAll: 0.
放置ラウンド数 := Array new: 階数 withAll: 0.
放置ラウンド数 at: 1 put: -1.
World findATranscript: nil.

ボックス移動 := [:行き先階 |
    ラウンド数 := ラウンド数 + ((行き先階 - ボックス停止階) abs * 2) + 5.
    移動数 := 移動数 + (行き先階 - ボックス停止階) abs.
    (放置ラウンド数 at: 行き先階) = 0
        ifTrue: [放置ラウンド数 at: 行き先階 put: ラウンド数].
    行き先階 = 1 ifTrue: [ボックス停止階 := 1. ボックス内人数 := 0] ifFalse: [
        | 待ち人数 搭乗者数 残り人数 |
        待ち人数 := 各階待ち人数 at: 行き先階.
        搭乗者数 := 待ち人数 min: 最大搭乗人数 - ボックス内人数.
        残り人数 := 待ち人数 - 搭乗者数.
        ボックス停止階 = 1 ifTrue: [Transcript cr].
        ボックス停止階 := 行き先階.
        Transcript
            show: ボックス停止階; show: '階: '; show: 待ち人数; show: ' -> ';
            show: (各階待ち人数 at: ボックス停止階 put: 残り人数); show: '. '.
        "Transcript
            show: ' (ラウンド: ', ラウンド数 printString, ', 移動数: ', 移動数 printString, ')'."
        ボックス内人数 := ボックス内人数 + 搭乗者数.
        残り人数 = 0 ifTrue: [完了ラウンド数 at: ボックス停止階 put: ラウンド数]]].

状態出力 := [
    Transcript cr.
    5 to: 1 by: -1 do: [:ｎ |
        Transcript cr; show: ｎ; show: '階; ';
            show: (各階待ち人数 at: ｎ);
            show: ' 人 / 完了ラウンド: ';
            show: (完了ラウンド数 at: ｎ)].
    Transcript cr].

状態出力 value.

[   ボックス内人数 = 最大搭乗人数 ifTrue: [ボックス移動 value: 1] ifFalse: [
        | 呼び出し階 |
        呼び出し階 := 各階待ち人数 findLast: [:各階 | 各階 > 0].
        呼び出し階 = 0
            ifTrue: [ボックス移動 value: 1]
            ifFalse: [ボックス移動 value: 呼び出し階]].
    ボックス停止階 > 1 or: [各階待ち人数 anySatisfy: [:各階 | 各階 > 0]]
] whileTrue.

状態出力 value.

Transcript cr; show: '経過時間: '; show: ラウンド数.
"Transcript cr; show: '階別の放置時間一覧: '; show: 放置ラウンド数."
Transcript cr; show: '階別の最大放置時間: '; show: 放置ラウンド数 max.
Transcript cr; show: 'のべ移動階数: '; show: 移動数

"出力 => 
5階; 7 人 / 完了ラウンド: 0
4階; 11 人 / 完了ラウンド: 0
3階; 3 人 / 完了ラウンド: 0
2階; 7 人 / 完了ラウンド: 0
1階; 0 人 / 完了ラウンド: 0

5階: 7 -> 4. 
5階: 4 -> 1. 
5階: 1 -> 0. 4階: 11 -> 9. 
4階: 9 -> 6. 
4階: 6 -> 3. 
4階: 3 -> 0. 
3階: 3 -> 0. 
2階: 7 -> 4. 
2階: 4 -> 1. 
2階: 1 -> 0. 

5階; 0 人 / 完了ラウンド: 65
4階; 0 人 / 完了ラウンド: 138
3階; 0 人 / 完了ラウンド: 158
2階; 0 人 / 完了ラウンド: 202
1階; 0 人 / 完了ラウンド: 0

経過時間: 209
階別の最大放置時間: 174
のべ移動階数: 52 "

/** エレベータ */
class Elevator {
  static final int MOVE_COST       = 2 // 移動コスト
  static final int GETTING_ON_COST = 5 // 乗降コスト
  static final int MAX_PERSONS     = 3 // 最大人数
  def floors                           // フロア
  int currentFloor                     // 現在のフロア
  int persons                          // 乗っている人数
  int elapsedRound = 0                 // 経過ラウンド
  int moved        = 0                 // 総移動距離

  /** 階を移動する */
  def moveTo(toFloor) {
    int movin = Math.abs(toFloor - currentFloor)
    println("Elevator move from [${currentFloor + 1} → ${toFloor + 1}]")
    moved += movin
    currentFloor = toFloor
    elapseByMove(movin * MOVE_COST)
  }

  /** フロアからエレベータへ一人乗せる */
  def getOn() {
    if (persons < MAX_PERSONS && floors[currentFloor].persons) {
      persons++
      int before = floors[currentFloor].persons--
      elapseByGettingOn(GETTING_ON_COST)
      println("Person get on at [${currentFloor + 1}]th Floor / "
      + "Floor's member [${before} → ${floors[currentFloor].persons}]")
    }
  }

  /** エレベータからフロアへ一人降ろす */
  def getOff() {
    if (persons) {
      persons--
      int before = floors[currentFloor].persons++
      elapseByGettingOn(GETTING_ON_COST)
      println("Person get off at [${currentFloor + 1}]th Floor / "
      + "Floor's member [${before} → ${floors[currentFloor].persons}]")
    }
  }

  /** 移動によるラウンドの経過 */
  def elapseByMove(round) {
    floors.each{ it.elapse(round) }
    elapsedRound += round
  }
  
  /** 乗降によるラウンドの経過 */
  def elapseByGettingOn(round) {
    floors.eachWithIndex{ f, idx ->
      if (currentFloor == idx) {
        f.resetRound()
      } else {
        f.elapse(round)
      }
    }
    elapsedRound += round
  }
  
  /** フロア情報を出力 */
  def dispFloorsInfo(){
    (1..floors.size()).reverseEach{
      println("[${it}]th Floor: "
      + "[${(floors[it-1].persons as String).padLeft(2)}] /"
      + " last_round:[${floors[it-1].maxWaitRound}]")
    }
  }
  
  /** ラウンド情報を出力 */
  def dispRoundInfo() {
    println """\
      経過時間:[${elapsedRound}]
  最大待ち時間:[${floors*.maxWaitRound.max()}]
移動距離合計数:[${moved}]"""
  }

}

/** フロア */
class Floor {
  int persons          // 待っている人数
  int waitRound    = 0 // 待っているラウンド
  int maxWaitRound = 0 // 最大待ちラウンド
  boolean noRound      // ラウンド経過なし

  /** ラウンド経過 */
  def elapse(round) {
    if (persons && !noRound) {
      waitRound += round
      maxWaitRound = [maxWaitRound, waitRound].max()
    }
  }
  
  /** ラウンドリセット */
  def resetRound() {
    waitRound = 0
  }
}


def elev = new Elevator(
  floors:[
    new Floor(persons: 0, noRound:true), // 1階 (ラウンド経過なし)
    new Floor(persons: 7              ), // 2階
    new Floor(persons: 3              ), // 3階
    new Floor(persons:11              ), // 4階
    new Floor(persons: 7              )  // 5階
  ],
  currentFloor: 0,
  persons     : 0
)

// メイン処理
println 'INIT --------------------'
elev.dispFloorsInfo()
println '-------------------------'

// 1階以外で待っている人がいる間繰り返す
while(elev.floors.tail()*.persons.sum()) {
  // 待っている人がいる最上階を探す
  def nextList = []
  elev.floors.tail()*.persons.eachWithIndex{ item, idx ->
    nextList << [idx+1, item]
  }
  def topFloor = nextList.findAll{ it[1] != 0 }.last()[0]

  // 上から順に一人ずつスライドさせてくる
  for (i in topFloor..0) {
    elev.moveTo(i)
    switch (i) {
      case topFloor:                elev.getOn();  break
      case        0: elev.getOff();                break
      default      : elev.getOff(); elev.getOn();  break
    }
  }
}

println 'END --------------------'
elev.dispFloorsInfo()
elev.dispRoundInfo()

function log(str, lineContinue) {
    // for Rhino
    java.lang.System.out.print(str);
    if (!lineContinue) java.lang.System.out.println();
}

function Elevator(capacity, t1, t2) {
    this.capacity = capacity;
    this.t1 = t1;
    this.t2 = t2;
    this.init([]);
}

Elevator.prototype = {
    simulate: function (data) {
        this.init(data);
        var c;
        while (c = this.callingFrom()) {
            this.upTo(c);
            while (this.floor != 0) this.down();
        }
        this.printResult();
    },
    printResult: function () {
        log("Finish.");
        log("\tTotal time: " + this.round);
        log("\tTotal move: " + this.move);
        log("\tMax wait:   " + Math.max.apply(null, this.waitTime));
    }, 
    init: function (data) {
        this.floor = 0; // 英国式
        this.count = 0;
        this.round = 0;
        this.move = 0;
        this.waitTime = [];
        for(var i=0,n=data.length+1;i<n;i++) this.waitTime[i]=0;
        this.data = [0].concat(data);
    },
    upTo: function (f) {
        this.round += this.t1 * (f - this.floor);
        this.move += (f - this.floor);
        this.aliveAt(f);
    },
    down: function () {
        this.round += this.t1;
        this.move++;
        this.aliveAt(this.floor-1);
    },
    aliveAt: function (f) {
        this.floor = f;
        if (this.floor == 0) {
            this.round += this.t2;
            this.count = 0;
            log("0F. (Round: " + this.round + ")");
        } else {
            var n = Math.min(this.capacity - this.count, this.data[f]);
            if (n != 0) {
                this.round += this.t2;
                this.data[f] -= n;
                this.count += n;
                if(this.waitTime[f]==0) this.waitTime[f] = this.round;
                log(f + "F[" + (this.data[f] + n) + "->" + this.data[f] + "] -> ", true);
            }
        }
    },
    callingFrom: function () {
        for (var f = this.data.length - 1; f > 0; f--)
            if (this.data[f] > 0) return f;
        return 0;
    }
}

if (arguments.length > 0) {
    new Elevator(arguments.shift()*1, arguments.shift()*1, arguments.shift()*1).simulate(arguments);
} else {
    new Elevator(3, 2, 5).simulate([7, 3, 11, 7]);
}

%!PS

% [[待ち人] 現在位置 乗員 定員 時刻 評価]   Check1  [...]
/Check1 {
    dup 0 get true exch { 0 eq and } forall % 待ち無し
    1 index 1 get 0 eq and                  % 地上階    
} bind def

% [[待ち人] 現在位置....] FindNext1 num
/FindNext1 {
    0 2 getinterval aload
    0 get length 1 sub 1 exch {
        2 copy get 0 gt {
            exch pop true exit
        } if
        pop
    } for
    true ne {
        0
    } if
} bind def

/FindNext2 {
    (==) = ppstack (==)=
    0 get
    dup length 1 sub -1 1
    {
        2 copy get 0 gt {
            exch pop true exit
        } if
        pop
    } for
    true ne {
        0
    } if
} bind def

/AddVal { % [] pos tt  AddVal  []
    2 index 2 index get add 2 index 3 1 roll put
} bind def

% [[待ち人] 現在位置 乗員 定員 時刻 評価]  /Next  Move1  [...]
/Move1 {
    exch
    (Move: ) print dup 1 get 1 add 3 string cvs print ( ==> ) print

    (==) = ppstack
    dup 2 2 getinterval aload pop lt {
        dup 3 -1 roll cvx exec
        1 index 1 get
        2 index 2 index 1 exch put
        sub abs
        2 copy 6 exch AddVal pop
        MoveTime mul 4 exch AddVal
    } {
        exch pop
        dup 1 get
        2 copy 6 exch AddVal pop
        MoveTime mul 4 exch AddVal
        dup 1 0 put
    } ifelse
    dup 1 get 1 add 3 string cvs =
    dup ===
} bind def
/RideOn {
    % [[] ... ] n RideOn [[] ...]
    1 index 0 get 2 index 1 get 2 index neg
    AddVal pop
    2 exch AddVal
} bind def
/IO1 {
    dup 1 get 0 eq {
        (Floor 1 =[Out]= ) print dup 2 get =
        dup 2 get 0 gt {
            4 IOTime AddVal
            dup 2 get exch dup 4 get 3 -1 roll mul
            5 exch AddVal
            dup 2 0 put
        }if
        dup ===
    } {
        (Floor ) print dup 1 get 1 add 3 string cvs print ( =[In]= ) print
        dup 1 get exch dup 0 get 3 -1 roll get
        exch dup 2 get exch dup 3 get 3 -1 roll sub
        3 copy 3 -1 roll lt {
            pop 3 -1 roll pop
        } {
            pop pop exch
        } ifelse
        dup 0 gt {
            dup =
            RideOn
            4 IOTime AddVal
        } {
            (noop) =
        } ifelse
    } ifelse
} bind def


/Run {
    exch
    {
        Check1 { exit } if
        1 index Move1
    IO1
    } loop
    (Score =) print dup 5 get =
    (Time  =) print dup 4 get =
    (Run   =) print dup 6 get =
    pop pop
} bind def

% ===== Test Code =====
/MoveTime 2 def
/IOTime 5 def
[[0 7 3 11 7] 0 0 3 0 0 0] /FindNext2 Run
[[0 7 3 11 7] 0 0 3 0 0 0] /FindNext1 Run

module Main where

import Data.Array.Unboxed (UArray, listArray, assocs, (//), (!))
import Control.Monad.State
import Data.Function (on)
import Data.List (minimumBy)
import Data.Ord (compare)

-- Data Types --
data Elevator = E {
    cPassenger :: Int,
    iFloor :: Int
    } deriving Show

data Wait = W {
    unW :: (UArray Int Int)
    } deriving Show

type Cost = (Int, String)

type ElevState = (Cost, (Elevator, Wait))

type ElevM = State (Elevator, Wait) Cost

-- Data --
initialWait = W $ listArray (1, 5) [0, 7, 3, 11, 7]
initialElev = E 0 1

initial = ((0, ""), (initialElev, initialWait))

-- Primitives --
isFull :: Elevator -> Bool
isFull (E p fl) = p == 3

comb :: Cost -> Cost -> Cost
comb (c1, st1) (c2, st2) = (c1 + c2, st1 ++ " " ++ st2)

waitingFloor :: Wait -> [Int]
waitingFloor = map (fst) . filter ((/=0).snd) . assocs . unW

-- (Quasi) Monadic Combinators --
combM :: Cost -> ElevM -> ElevM
combM c m = m >>= \c' -> return $ c `comb` c'

(<*>) :: ElevM -> ElevM -> ElevM
a1 <*> a2 = a1 >>= \c1 -> combM c1 a2

ifFull :: ElevM -> Cost -> ElevM
ifFull ifM c = State $ \i@(e, w) -> case (isFull e) of
    False     -> (c, i)
    otherwise -> runState (combM c ifM) i

ifFullM :: ElevM -> ElevM -> ElevM
ifFullM pM tM = pM >>= \c -> ifFull tM c

-- Monadic Primitive Elevator Operations --
pickupM :: ElevM
pickupM = State $ _pickup

_pickup (E p fl, W ar) = ((5, str), (E p' fl, W ar'))
    where
        ar' = ar//[(fl, cWaiting - cPickup)]
        p' = p + cPickup
        cWaiting = ar!fl
        cPickup = min cWaiting (3 - p)
        str = '*' : (show cPickup)
        
dropM :: ElevM
dropM = State $ \(E p fl, w) -> case (p) of
    0         -> ((0, ""),  (E 0 fl, w))
    otherwise -> ((5, "/"), (E 0 fl, w))

moveByM :: Int -> ElevM
moveByM d =  State $ \((E p fl), w) -> (c, (E p $ fl + d,  w))
    where
        c = (abs $ d * 2, cat d)
        cat  d
            | d == 0 = ""
            | d < 0 = show d
            | otherwise = '+' : (show d)

-- Composit Monadic Operations --
takeHomeM :: ElevM
takeHomeM = State $ \i@((E _ fl), _) -> (runState $ (moveByM $ 1 - fl) <*> dropM) i

goM :: Int -> ElevM
goM flTo = State $ \i@((E _ fl), _) -> (runState $ moveByM $ flTo - fl) i

turnM :: Int -> ElevM
turnM flTo = ((goM flTo) <*> pickupM) `ifFullM` takeHomeM

-- Permutation Traversers --
tryAll :: ElevState -> [ElevState]
tryAll (c, i@(_, w)) 
    | fls == [] = [runState (combM c takeHomeM) i]
    | otherwise = map (\fl -> runState (combM c $ turnM fl) i) fls >>= tryAll
    where
        fls = waitingFloor w

-- Main --
main = (print.fst . minimumBy (byCost) . tryAll) initial
    where
        byCost :: ElevState -> ElevState -> Ordering
        byCost = compare `on` (fst . fst)

class Elevator
  CAPACITY = 3
  MOVE_COST = 2
  GETTING_ON_COST = 5

  attr_reader :current_floor, :number_of_people, :total_round, :travel_distance
  
  def initialize
    @current_floor = 0 # 現在の階
    @number_of_people = 0 # 乗っている人数
    @total_round = 0 # 現在の合計ラウンド
    @travel_distance = 0 # 現在の総移動距離
  end

  def move_to(floor)
    distance = (@current_floor - floor).abs
    @total_round += MOVE_COST * distance
    @travel_distance += distance
    @current_floor = floor
  end

  def get_on(n)
    raise if (@number_of_people + n) > CAPACITY
    @total_round += GETTING_ON_COST
    @number_of_people += n
  end

  def get_off(n)
    raise if @number_of_people < n
    @total_round += GETTING_ON_COST
    @number_of_people -= n
  end

  def room_for_getting_on
    CAPACITY - @number_of_people
  end
end


class Building

  def initialize(floors)
    @floors = floors # 各階の人数(階数は0から)
    @elevator = Elevator.new
    @first_visited_round = [] # 各階に初めて止まったときのラウンド
    @floors.size.times { @first_visited_round << nil }
    @first_visited_round[0] = 0
  end

  def get_on_to_evevator
    n = (@floors[@elevator.current_floor] <= @elevator.room_for_getting_on) ? @floors[@elevator.current_floor] : @elevator.room_for_getting_on
    @elevator.get_on(n)
    @floors[@elevator.current_floor] -= n
  end

  def get_off_from_elevator
    n = @elevator.number_of_people
    @elevator.get_off(n)
    @floors[@elevator.current_floor] += n
  end

  def finished?
    @floors[1..@floors.size].inject(0) { |s, a| s + a } == 0
  end

  def where_to_go
    floor = nil
    (@floors.size - 1).downto(0) { |i|
      if @floors[i] > 0
        floor = i
        break
      end
    }
    raise if floor.nil?
    floor
  end
  
  def simulate
    until finished?
      floor = where_to_go
      prev = @floors[floor]
      @elevator.move_to(floor)
      get_on_to_evevator
      print "#{floor + 1}階 [#{prev} => #{@floors[floor]}] => "
      @first_visited_round[floor] = @elevator.total_round if @first_visited_round[floor].nil?
      if (@elevator.number_of_people == Elevator::CAPACITY) || (@elevator.current_floor == 1)
        @elevator.move_to(0)
        get_off_from_elevator
        puts "1階"
      end
    end
  end

  def get_total_round
    @elevator.total_round
  end

  def get_travel_distance
    @elevator.travel_distance
  end

  def get_max_waiting_round
    @first_visited_round.max
  end

  def get_floors_status
    status = ''
    @floors.reverse.each_with_index { |n, i| status << "#{i + 1}階:\t#{n}人\n" }
    status
  end
end

b = Building.new([0, 7, 3, 11, 7]) # 1階 0人, 2階 7人, 3階 3人, 4階 11人, 5階 7人
puts '[INIT]'
puts b.get_floors_status
puts '-' * 20
b.simulate
puts '-' * 20
puts '[END]'
puts b.get_floors_status
puts '-' * 20
puts '[RESULT]'
puts "経過時間:\t#{b.get_total_round}"
puts "最大待ち時間:\t#{b.get_max_waiting_round}"
puts "移動距離:\t#{b.get_travel_distance}"