【参赛经验分享】俄罗斯方块的Rust解题记录（腾讯内部赛道第7名）

    self.evaluated =
      min_occupied.iter().enumerate().fold(0i64, |a, (_col, b)| {
        //const LVL: i64 = 5;
        let b = *b as i64;
        //if _col < 8 {
        let b = b - avg_occupied;
        a - b * b
        // if b < LVL {
        //   let b = (LVL - b) as i64;
        //   a - b * b
        // } else {
        //   // a + b
        //   a
        // }
        // } else {
        //   if avg_occupied > 6 {
        //     let b = 20 - b;
        //     a - b * b
        //   } else {
        //     let b = b - avg_occupied;
        //     a - b * b
        //   }
        // }
        //}) + space_count.iter().fold(0i64, |a, b| a - std::cmp::min(6, *b) * 15)
      }) + space_count.iter().fold(0i64, |a, b| a - b * 20)
        + occupied_grid as i64 * 4
        + match full_rows.len() {
          1 => occupied_grid,
          2 => occupied_grid * 3,
          3 => occupied_grid * 6,
          4 => occupied_grid * 10,
          _ => 0,
        } as i64;

  fn find_task<T>(
    local: &Worker<T>,
    global: &Injector<T>,
    stealers: &[Stealer<T>],
  ) -> Option<T> {
    // Pop a task from the local queue, if not empty.
    local.pop().or_else(|| {
      // Otherwise, we need to look for a task elsewhere.
      iter::repeat_with(|| {
        // Try stealing a batch of tasks from the global queue.
        global
          .steal()
          //.steal_batch_and_pop(local)
          // Or try stealing a task from one of the other threads.
          .or_else(|| stealers.iter().map(|s| s.steal()).collect())
      })
      // Loop while no task was stolen and any steal operation needs to be retried.
      .find(|s| !s.is_retry())
      // Extract the stolen task, if there is one.
      .and_then(|s| s.success())
    })
  }

  pub fn search(
    mut init: AIState,
    depth: usize,
    min_row: usize,
  ) -> Option<AIState> {
    let end_level = init.level + depth;

    let injector: Injector<AIState> = Injector::new();
    let mut workers = Vec::new();
    let mut stealers = Vec::new();
    let (tx, rx) = channel::unbounded();

    for _ in 0..THREADS {
      let worker = Worker::new_fifo();
      workers.push(worker);
    }
    for worker in workers.iter() {
      stealers.push(worker.stealer());
    }

    let global = &injector;
    let stealers = &stealers[0..];

    let mut roots = init.search_next_step(min_row)?;

    for (index, state) in roots.iter_mut().enumerate() {
      state.root_index = index as i8;
      injector.push(*state);
    }

    let rt = thread::scope(|s| {
      for (_i, local) in workers.into_iter().enumerate() {
        let tx = tx.clone();
        s.spawn(move |_| {
          while let Some(mut state) = BFS::find_task(&local, global, &stealers)
          {
            if state.level < end_level {
              if let Some(states) = state.search_next_step(min_row) {
                //let width = std::cmp::min(14, (end_level - state.level) * 2);
                let width = std::cmp::max(3, end_level - state.level);
                for mut sub_state in states.into_iter().take(width) {
                  //for mut sub_state in states.into_iter() {
                  sub_state.evaluated += state.evaluated;
                  local.push(sub_state);
                }
              } else {
                tx.send(state).unwrap();
              }
            } else {
              tx.send(state).unwrap();
            }
          }
          drop(tx);
        });
      }
      drop(tx);

      let result_join = s.spawn(|_| {
        let mut chosen: Option<AIState> = None;
        for state in rx.iter() {
          chosen = chosen
            .and_then(|selected| {
              if state.evaluated > selected.evaluated {
                Some(state)
              } else {
                Some(selected)
              }
            })
            .or_else(|| Some(state));
        }
        chosen
      });

      result_join.join().unwrap()
    })
    .unwrap()?;

    Some(roots[rt.root_index as usize])
  }