前端面試(算法篇) - 約塞夫環

在上一篇《前端面試 - 算法篇（二分法）》的評論中，有朋友提出了一個“循環殺人游戲”

就在我為之苦惱的時候，一位同事在我身旁經過，突然說了一句：“咦，這不是約塞夫問題嗎？”

 

一、面試題

原題目不太明朗（一號到底殺不殺？）

於是把題目優化一下，更接近於原本的約塞夫問題

假設有100人，分別編號 1~100

從 1 號開始報數，報數到 3 號時，3 號就被淘汰，然后由下一人從 1 報數，以此類推

最后誰會活下來？

 

二、面向過程

最開始我按照自己的思路，模擬了整個過程

雖然能解決問題，但一旦遇到較大的數據量，查詢的次數太多，性能太低

不過這種方法最容易理解

/**
 * 面向過程的約塞夫環解決辦法
 * @param {Array} peoples 參與游戲的數組
 * @param {Number} kill 淘汰的報數數字
 * @return {Object} 幸存者
 */

function killer(peoples, kill) {
  
  let flag = 0 // 初始化報數

  while(peoples.length > 1) { // 只剩下一個人時，循環結束

    let len = peoples.length // 剩余人數
    let out = 0 // 已淘汰的人數

    for (let i = 0; i < len; i++) {
      flag++ // 報數+1

      if (kill == flag) { // 當報數到指定數字，淘汰該玩家
        // 淘汰后剩余人數(數組)會發生變化，所以被淘汰玩家下標應為 i-out
        peoples.splice(i-out, 1)

        flag = 0 // 重置報數
        out++ // 淘汰人數+1
      }
    }
  }
  return peoples[0]
}

 

二、面向對象

在數據結構中，具有鏈式存儲結構的線性表被稱為鏈表

其特點是每個數據元素在存儲本身的信息之外，還要存儲其直接后繼的信息

數據元素之間不要求在存儲空間中連續

而當這些數據元素構成一個邏輯上的環，任意元素都有一個前驅和后繼，這就構成了一個循環鏈表

 

在這個游戲中，可以將玩家抽象成一個對象，然后由玩家組成了一個環

根據循環鏈表的特性，每個玩家除了存儲本身的信息（編號），還需要存儲前后的編號

class Player { // 創建玩家
 constructor(n) { this.index = n; // 玩家編號
    this.before = {}; // 前一個玩家
    this.after = {}; // 后一個玩家
 } }

 

然后分析整個環，除了構造函數之外，還應當具備淘汰玩家、開始游戲的功能

為了保證環的完整，需要一個起點和一個終點，這兩個點在邏輯上是相鄰的

在整個游戲過程中，我們只需要關心環的完整（起點、終點、玩家的前驅與后繼）就可以了

/**
 * 面向對象的約塞夫環解決辦法
 * @param {Number} length 玩家總數
 * @param {Number} kill 淘汰的報數數字
 * @return
 */
class Cycle { // 創建循環鏈表
  constructor (length) {
    this.count = 0; // 玩家總數
    this.start = new Player(1) // 鏈表起點
    this.end = new Player(length) // 鏈表終點

    for(let i = 1; i <= length; i++) {
      // 創建玩家
      let player = new Player(i)
      this.count++

      if (this.count <= 1) {
        // 只有一個玩家的時候，起點和終點為同一個玩家
        this.start = this.end = player
      } else {
        // 新創建的玩家一定位於鏈表終點之后
        this.end.after = player
        player.before = this.end
        // 而該玩家即為新的鏈表終點
        this.start.before = player
        player.after = this.start
        this.end = player
      }
    }
  }

  delete (player) {
    if (this.count <= 1) { // 錯誤校驗
      this.start = this.end = null
      return
    } else {
      // 將前后的玩家關聯起來
      player.before.after = player.after
      player.after.before = player.before
      // 如果處於終點或起點，則修改相關信息
      if (player == this.start) {
        this.start = player.after
      } else if(player == this.end) {
        this.end = player.before
      }
    }
    // 淘汰該玩家
    player = null
    this.count--
  }

  play (kill) {
    let flag = 0 // 初始化報數
    let k = this.start // 從起點開始游戲
    while (this.count > 1) { // 只剩一個玩家，循環結束
      flag++
      if (flag == kill) { // 報數到目標數字，淘汰玩家
        flag = 0
        this.delete(k)
      }
      // 無論淘汰與否，讓下一個玩家報數
      k = k.after
    }
    return `幸存者：${k.index}`
  }
}

new Cycle(100).play(3)

  

三、遞歸算法 

在吃透了整個游戲規則之后。。。

function Joseph(sum, value, n) {
    if ( n==1 ) {
        return ( sum + value - 1) % sum;
    } else {
        return ( Joseph( sum - 1, value, n - 1) + value ) % sum;
    }
}

console.log("剩下的人號數為：" + (Joseph(100, 3, 100) + 1))

emmmmmmmmmm

難怪《美麗心里》里開頭就說，是數學家改變了世界

  

四、問題拓展

1. 如何用 js 快速創建一個 1~100 的數組？

2. 如果報數到 2 就淘汰，最后剩下誰？