Google Kick Start 2019 C轮 第一题 Wiggle Walk 题解
题目地址：https://codingcompetitions.withgoogle.com/kickstart/round/0000000000050ff2/0000000000150aac
四个解法：
- 暴力模拟
- 使用HashMap优化，理论时间复杂度最小（好像也是并查集）
- (推荐)使用BitSet，实际占用空间特别小，仅仅是 2mn 个比特大小
- 使用HashMap实现的并查集方法，在东南西北4个方向上用并查集处理
解法1：暴力模拟
下面的代码是我写的暴力模拟办法，只能过样例，提交上去会 Runtime Error.
import java.util.*;
import java.io.*;
public class Solution {
static String input = "3" + "\n"
+ "5 3 6 2 3" + "\n"
+ "EEWNS" + "\n"
+ "4 3 3 1 1" + "\n"
+ "SESE" + "\n"
+ "11 5 8 3 4" + "\n"
+ "NEESSWWNESE" + "\n";
public static void main(String[] args) {
//Scanner sc = new Scanner(System.in);
Scanner sc = new Scanner(new StringReader(input));
int T = sc.nextInt();
int[][] D = new int[128][2];
D['E'] = new int[]{0, 1};
D['W'] = new int[]{0, -1};
D['N'] = new int[]{-1,0};
D['S'] = new int[]{1,0};
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int R = sc.nextInt();
int C = sc.nextInt();
int Sr = sc.nextInt();
int Sc = sc.nextInt();
sc.nextLine();
String seq = sc.nextLine();
boolean[][] map = new boolean[R + 1][C + 1];
map[Sr][Sc] = true;
for (int j = 0; j < N; j++) {
do {
Sr += D[seq.charAt(j)][0];
Sc += D[seq.charAt(j)][1];
} while (map[Sr][Sc] == true);
map[Sr][Sc] = true;
}
System.out.println("Case #" + (i + 1) + ": " + Sr + " " + Sc);
}
}
}
解法2：HashMap优化
下面是使用HashMap能过的版本，原答案来自StackExchange上的Python解法.
注意静态内部类 Point，我重写了对象的equals()方法和hashCode()方法，以便 HashMap 能正确查找对象。hashCode()方法用于计算哈希值，不重写的会采用对象内存地址作为哈希值，这是我们不希望看到的。equals()方法用于解决哈希冲突后的对象实际内容比对。
import java.util.*;
import java.io.*;
public class Solution {
static class Point {
int x;
int y;
Point() {}
Point(int xx, int yy) { x = xx; y = yy; }
@Override
public boolean equals(Object obj) {
Point that = (Point) obj;
return this.x == that.x && this.y == that.y;
}
@Override
public int hashCode() {
return x * 50000 + y;
}
}
static HashMap<Point, Point>[] neighbors;
public static void init() {
neighbors = new HashMap[128];
neighbors['W'] = new HashMap<Point, Point>();
neighbors['E'] = new HashMap<Point, Point>();
neighbors['S'] = new HashMap<Point, Point>();
neighbors['N'] = new HashMap<Point, Point>();
}
public static Point getNeighbor(Point cur, char direction) {
if (neighbors[direction].containsKey(cur)) {
return neighbors[direction].get(cur);
}
switch(direction) {
case 'W': return new Point(cur.x - 1, cur.y);
case 'E': return new Point(cur.x + 1, cur.y);
case 'N': return new Point(cur.x, cur.y - 1);
case 'S': return new Point(cur.x, cur.y + 1);
default: return null;
}
}
public static void linkNeighbors(Point cur) {
Point west = getNeighbor(cur, 'W');
Point east = getNeighbor(cur, 'E');
Point north = getNeighbor(cur, 'N');
Point south = getNeighbor(cur, 'S');
neighbors['W'].put(east, west);
neighbors['E'].put(west, east);
neighbors['N'].put(south, north);
neighbors['S'].put(north, south);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int R = sc.nextInt();
int C = sc.nextInt();
int Sr = sc.nextInt();
int Sc = sc.nextInt();
sc.nextLine(); // skip \n at end of previous line
String seq = sc.nextLine();
init();
Point cur = new Point(Sc, Sr);
for (int j = 0; j < N; j++) {
linkNeighbors(cur);
cur = getNeighbor(cur, seq.charAt(j));
}
System.out.println("Case #" + (i + 1) + ": " + cur.y + " " + cur.x);
}
}
}
解法3: BitSet
思路来源： http://codeforces.com/blog/entry/67224?#comment-513594
核心就是利用 BitSet 提供的 previousSetBit() 和 nextSetBit() 方法，虽然这两个方法理论上是 O(n) 时间复杂度，但由于是位操作，且Java肯定做了某些特殊优化，所有不仅占用内存特别小，运行速度也快。
import java.util.*;
import java.io.*;
public class Solution {
static BitSet[] rowBitsets; // m horizontal bitset
static BitSet[] colBitsets; // n vertical bitsets
public static void init(int rows, int cols) {
// initilize m + n bitsets
rowBitsets = new BitSet[rows + 1];
colBitsets = new BitSet[cols + 1];
for (int i = 1; i <= rows; i++) rowBitsets[i] = new BitSet(cols + 1);
for (int i = 1; i <= cols; i++) colBitsets[i] = new BitSet(rows + 1);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int R = sc.nextInt();
int C = sc.nextInt();
int Sr = sc.nextInt();
int Sc = sc.nextInt();
sc.nextLine(); // skip \n at end of previous line
String seq = sc.nextLine();
init(R, C);
for (int j = 0; j < N; j++) {
rowBitsets[Sr].set(Sc);
colBitsets[Sc].set(Sr);
switch(seq.charAt(j)) {
case 'W': Sc = rowBitsets[Sr].previousClearBit(Sc); break;
case 'E': Sc = rowBitsets[Sr].nextClearBit(Sc); break;
case 'N': Sr = colBitsets[Sc].previousClearBit(Sr); break;
case 'S': Sr = colBitsets[Sc].nextClearBit(Sr); break;
default: break;
}
}
System.out.println("Case #" + (i + 1) + ": " + Sr + " " + Sc);
}
}
}
解法4：使用并查集
import java.util.*;
import java.io.*;
public class Solution {
static class Point {
int x, y;
Point(int xx, int yy) { x = xx; y = yy; }
@Override
public boolean equals(Object obj) {
Point that = (Point) obj;
return this.x == that.x && this.y == that.y;
}
@Override
public int hashCode() {
return x * 50001 + y;
}
}
public static Point findNeighbor(HashMap<Point, Point> map, Point cur) {
// 向某个方向查找
if (!map.containsKey(cur) || map.get(cur).equals(cur)) {
// 当前结点cur在目标方向上没有已知的邻居，返回当前结点
return cur;
} else {
// 当前结点cur在目标方向上有个邻居，在目标方向上查找邻居的邻居，直到找到最远的邻居
// 并将当前结点在目标方向上的邻居更新为最远邻居，返回最远邻居
Point res = findNeighbor(map, map.get(cur));
map.put(cur, res);
return res;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int R = sc.nextInt();
int C = sc.nextInt();
int Sr = sc.nextInt();
int Sc = sc.nextInt();
sc.nextLine(); // skip \n at end of previous line
String seq = sc.nextLine();
HashMap<Point, Point> mapN = new HashMap<>();
HashMap<Point, Point> mapS = new HashMap<>();
HashMap<Point, Point> mapW = new HashMap<>();
HashMap<Point, Point> mapE = new HashMap<>();
Point cur = new Point(Sr, Sc);
for (int j = 0; j < N; j++) {
// 实在是搞不懂这句
mapN.put(new Point(cur.x + 1, cur.y), cur);
mapS.put(new Point(cur.x - 1, cur.y), cur);
mapW.put(new Point(cur.x, cur.y + 1), cur);
mapE.put(new Point(cur.x, cur.y - 1), cur);
// 更新4个点
switch(seq.charAt(j)) {
case 'N':
Point t1 = findNeighbor(mapN, cur); // 找到当前结点的最远邻居
cur = new Point(t1.x - 1, t1.y);
break;
case 'S':
Point t2 = findNeighbor(mapS, cur); // 找到当前结点的最远邻居
cur = new Point(t2.x + 1, t2.y);
break;
case 'E':
Point t3 = findNeighbor(mapE, cur); // 找到当前结点的最远邻居
cur = new Point(t3.x, t3.y + 1);
break;
case 'W':
Point t4 = findNeighbor(mapW, cur); // 找到当前结点的最远邻居
cur = new Point(t4.x, t4.y - 1);
break;
default: break;
}
System.out.println(seq.charAt(j) + " " + cur.x + " " + cur.y);
}
System.out.println("Case #" + (i + 1) + ": " + cur.x + " " + cur.y);
}
}
}