代码展示处

[DakerHub]

大家交流解法和思路的地方（最好贴下代码）

[ZxcSoft]

const findNext = function findNext(curPos, around, payload, helpers) {
    console.log(curPos)
    if (!payload.stack) {
        payload.stack = []
    }
    if (!payload.idx) {
        payload.idx = 0
    }

    let next = function (around, curPos) {
        let findIdx = null
        console.log(around)
        for (let index = payload.idx; index < around.length; index++) {
            let val = around[index]
            if (val == 0 || val == -2) {
                let nextPos = { x: curPos.x, y: curPos.y }
                switch (index) {
                    case 0: {
                        nextPos.y = nextPos.y - 1;
                        break;
                    }
                    case 1: {
                        nextPos.x = nextPos.x + 1;
                        break;
                    }
                    case 2: {
                        nextPos.y = nextPos.y + 1;
                        break;
                    }
                    case 3: {
                        nextPos.x = nextPos.x - 1;
                        break;
                    }
                    default: {
                        break;
                    }
                }
                console.log(nextPos)
                if (payload.stack.some(v => v.x === nextPos.x && v.y === nextPos.y)) {
                    continue
                }
                findIdx = index
                break;
            }
        }
        return findIdx
    }

    let nextIdx = next(around, curPos)
    if (nextIdx != null) {
        console.log(nextIdx)
        payload.stack.push({
            ...curPos,
            nextIdx
        })
        payload.idx = 0
        return { dx: nextIdx == 1 ? 1 : (nextIdx == 3) ? -1 : 0, dy: nextIdx == 0 ? -1 : (nextIdx == 2) ? 1 : 0 }
    } else {
        console.log(7)
        let pre = payload.stack.pop();
        payload.idx = pre.nextIdx + 1
        console.log(pre)
        console.log(curPos)
        return { dx: pre.x - curPos.x, dy: pre.y - curPos.y }
    }
}

[ciiiii]

const findNext = function findNext(curPos, around, payload, helpers) {
  if (!payload.map) {
    payload.map = [];
  }
  record(payload.map, curPos);
  if (!payload.stack) {
    payload.stack = [];
  }
  payload.stack.push({ x: curPos.x, y: curPos.y });
  for (let [index, result] of around.entries()) {
    if (result == -2) {
      return goMap[index];
    } else if (result === 0) {
      const pos = caculatePos(curPos, index);
      if (!exist(payload.map, pos)) {
        console.log(`go ${dirMap[index]}`);
        return goMap[index];
      }
    }
  }
  console.log("go back");
  payload.stack.pop(); // pop current
  const last = payload.stack.pop(); // pop get last
  return helpers.diffPos(last, { x: curPos.x, y: curPos.y });
};

const goUp = { dx: 0, dy: -1 };
const goDown = { dx: 0, dy: 1 };
const goLeft = { dx: -1, dy: 0 };
const goRight = { dx: 1, dy: 0 };
const goMap = [goUp, goRight, goDown, goLeft];
const dirMap = ["up", "right", "down", "left"];

function record(map, pos) {
  if (map[pos.x] == undefined) {
    map[pos.x] = [];
  }
  if (map[pos.x][pos.y] == undefined) {
    map[pos.x][pos.y] = true;
  }
}

function exist(map, pos) {
  if (map[pos.x] == undefined) {
    return false;
  }
  return map[pos.x][pos.y] != undefined;
}

function caculatePos(pos, index) {
  const diff = goMap[index];
  return { x: pos.x + diff.dx, y: pos.y + diff.dy };
}

[kingwrcy]

思路都是一样的,记录走过的点,不走已经走过的路,遇到无路可走,就回退,回退的路上遇到没走过的继续走,直到终点.

我也是这个思路,有没有人有些不一样的思路?期待ing

const up = { dx: 0, dy: -1 };
const right = { dx: 1, dy: 0 };
const down = { dx: 0, dy: 1 };
const left = { dx: -1, dy: 0 };
const dir = [up, right, down, left];

const findNext = function findNext(curPos, around, payload, helpers) {
  if (!payload.visted) {
    payload.visted = {};
  }
  if (!payload.history) {
    payload.history = [];
  }
  payload.visted[getKey(curPos)] = true;

  for (let index = 0; index < around.length; index++) {
    if (
      (around[index] == 0 || around[index] == -2) &&
      !payload.visted[getKey(addPoint(curPos, dir[index]))]
    ) {
      payload.history.push(addPoint(curPos, dir[index]));
      return dir[index];
    }
  }

  let prev = payload.history.pop();
  if (prev.x === curPos.x && prev.y === curPos.y) {
    prev = payload.history.pop();
  }
  payload.history.push(prev);
  return helpers.diffPos(prev, curPos);
};

const getKey = (curPos, delta) => {
  if (delta) {
    return curPos.x + delta.x + "-" + (curPos.y + delta.y);
  }
  return curPos.x + "-" + curPos.y;
};

const addPoint = (curPos, delta) => {
  return {
    x: curPos.x + delta.dx,
    y: curPos.y + delta.dy,
  };
};

[BlueSky-07]

模拟手摸着右边墙壁走法

const findNext = function findNext(curPos, around, payload, helpers) {
  const { faceTo = 0 } = payload
  const paths = [(faceTo + 1) % 4, faceTo, (faceTo + 3) % 4, (faceTo + 2) % 4]
  for (let i = 0; i < paths.length; i ++) {
    const path = paths[i]
    if (parseInt(around[path]) <= 0) {
      payload.faceTo = path
      return {
        dx: [0, 1, 0, -1][path],
        dy: [-1, 0, 1, 0][path],
      }
    }
  }
}

[DakerHub]

模拟手摸着右边墙壁走法

有意思哈哈

[mengkym]

歪个楼

const findNext = function findNext(curPos, around, payload, helpers) {
  curPos.x = 20
  curPos.y = 0
  return { dx: 1, dy: 0 };
}

[ciiiii]

太过分了，哈哈哈

歪个楼

const findNext = function findNext(curPos, around, payload, helpers) {
  curPos.x = 20
  curPos.y = 0
  return { dx: 1, dy: 0 };
}

[zt52875287]

左手扶墙找路。

建议多加一些地图，要不然场景测不全。

注意，有一个场景可能无法解决：出生点在地图中央，四个方向都有柱子，用这个思路就摸不到墙了，只能顺着柱子原地绕圈了

const detectUp = { dx: 0, dy: -1 };
const detectRight = { dx: 1, dy: 0 };
const detectDown = { dx: 0, dy: 1 };
const detectLeft = { dx: -1, dy: 0 };
const matrix=[detectUp,detectRight,detectDown,detectLeft];


const findNext = function findNext(curPos, around, payload, helpers) {
 
  if(!payload.preDirection){
    // 先向上摸，找到一张墙
    if(around[0]==0){
      return detectUp;
    // 找到一张墙之后，先走一步，初始化 payload
    } else if(around[1]!=1){
      payload.preDirection = detectRight;
      return detectRight;
    } else if(around[3]!=1){
      payload.preDirection = detectLeft;
      return detectLeft;
    } else {
      payload.preDirection = detectDown;
      return detectDown;
    }

  } 

  for (let i = 0; i < 4; i++) {
    if(payload.preDirection.dx == matrix[i].dx && payload.preDirection.dy == matrix[i].dy){
      if(around[(i+3)%4]!=1){
        payload.preDirection = matrix[(i+3)%4]     // 摸空了，逆时针转着摸
      } else if(around[i]!=1){
        // 顺着摸，方向不变 do nothing
      } else if(around[(i+1)%4]!=1){
        payload.preDirection =  matrix[(i+1)%4];   // 撞墙了，顺时针转着摸
      } else {
        payload.preDirection = matrix[(i+2)%4];    // 反方向
      }
      return payload.preDirection;
    }
  }

}

[tcbaby]

const findNext = function findNext (curPos, around, payload, helpers) {
    helpers.setCellStyle('background-color: pink')
    if (!payload.marks) payload.marks = []
    if (!payload.stack) payload.stack = []

    let diff = {}
    const nextPos = getNextPos(curPos, around, payload)

    if (nextPos) {
        diff = helpers.diffPos(nextPos, curPos)
        payload.marks.push({ x: curPos.x, y: curPos.y })
        payload.stack.push({ x: curPos.x, y: curPos.y })
    } else {
        console.log('到死路啦，开始回退！')
        payload.marks.push({ x: curPos.x, y: curPos.y })
        diff = helpers.diffPos(payload.stack.pop(), curPos)
    }

    console.log(diff)
    return diff
}

function isMark (pos, payload) {
    return payload.marks.find(e => e.x === pos.x && e.y === pos.y) != undefined
}

function getNextPos (curPos, around, payload) {
    const list = [
        { dx: 0, dy: -1 },
        { dx: 1, dy: 0 },
        { dx: 0, dy: 1 },
        { dx: -1, dy: 0 }
    ]

    for (let i = 0; i < around.length; ++i) {
        if (around[i] === 0 || around[i] === -2) {
            const pos = { x: curPos.x + list[i].dx, y: curPos.y + list[i].dy }
            if (!isMark(pos, payload)) {
                return pos
            }
        }
    }
}

[liusanp]

const findNext = function findNext(curPos, around, payload, helpers) {
  // 上一步1向下，-1向上，2向左，-2向右
  var l = payload.last
  // 判断是否三面围墙
  var c = around[0] * 1 + around[1] * 3 + around[2] * 5 + around[3] * 7
  console.log(c)
  console.log(around)
  if (around[0] == -2 || (around[0] == 0 && (l != 1 || c == 15))) {
    payload.last = -1
    return {dx: 0, dy: -1};
  }
  if (around[1] == -2 || (around[1] == 0 && (l != -2 || c == 13))) {
    payload.last = 2
    return {dx: 1, dy: 0};
  }
  if (around[2] == -2 ||(around[2] == 0 && (l!= -1 || c == 11))) {
    payload.last = 1
    return {dx: 0, dy: 1};
  }
  if (around[3] == -2 || (around[3] == 0 && (l != 2 || c == 9))) {
    payload.last = -2
    return {dx: -1, dy: 0};
  }
}

[aeonick]

顺着墙的一侧走

const findNext = function findNext(curPos, around, payload, helpers) {
  payload.dir=(~~payload.dir+1)%4
  while(!(parseInt(around[payload.dir])<1)) payload.dir = (payload.dir+3)%4
  return [{dx:0,dy:-1},{dx:1,dy:0},{dx:0,dy:1},{dx:-1,dy:0}][payload.dir];
}

[vacuityv]

const findNext = function findNext(curPos, around, payload, helpers) {

    let stack = payload.stack;
    let road = payload.road;
    if (stack == null) {
        stack = []
        for (let i = 0; i < 1000; i++) {
            stack[i] = [0, 0];
        }
    }
    if (road == null) {
        road = []
        for (let i = 0; i < 1000; i++) {
            let yroad = []
            for (let j = 0; j < 1000; j++) {
                yroad[j] = 0;
            }
            road[i] = yroad
        }
    }

    // 如果当前点第一次进入，则标记当前点进路径切压入栈
    if (road[curPos.x][curPos.y] == 0) {
        console.log(road[curPos.x][curPos.y])
        road[curPos.x][curPos.y] = 1;
        stack.push([curPos.x, curPos.y])
    }
    payload.stack = stack
    payload.road = road


    // 上且上没走过
    if ((around[0] == 0 || around[0] == -2) && road[curPos.x][curPos.y - 1] == 0) {
        return { dx: 0, dy: -1 };
    }
    // 右且右没走过
    if ((around[1] == 0 || around[1] == -2) && road[curPos.x + 1][curPos.y] == 0) {
        return { dx: 1, dy: 0 };
    }
    // 下且下没走过
    if ((around[2] == 0 || around[2] == -2) && road[curPos.x][curPos.y + 1] == 0) {
        return { dx: 0, dy: 1 };
    }
    // 左且左没走过
    if ((around[3] == 0 || around[3] == -2) && road[curPos.x - 1][curPos.y] == 0) {
        return { dx: -1, dy: 0 };
    }

    // 需要后退一步
    stack.pop()
    let pre_pos_loc = stack[stack.length - 1]
    let pre_pos = {}
    pre_pos.x = pre_pos_loc[0]
    pre_pos.y = pre_pos_loc[1]
    let fr = helpers.diffPos(pre_pos, curPos)
    return fr
}