public static void main(String[] args) {
// scale of the coordinate system
StdDraw.setXscale(-1.0, 1.0);
StdDraw.setYscale(-1.0, 1.0);
double rx = 0.0, ry = 0.0;
double rx2 = rx + 0.10, ry2 = ry + 0.10;
double rx3 = rx2 + 0.10, ry3 = ry2 + 0.10;
double vx = 0.005, vy = 0.003;
double vx2 = vx + 0.05, vy2 = vy + 0.05;
double vx3 = vx2 + 0.05, vy3 = vy2 + 0.05;
double radius = 0.10;
// main loop
while (true) {
// bounce off wall according to law of elastic collision
if (Math.abs(rx + vx) > 1.0 - radius) vx = -vx;
if (Math.abs(ry + vy) > 1.0 - radius) vy = -vy;
if (Math.abs(rx2 + vx2) > 1.0 - radius) vx2 = -vx2;
if (Math.abs(ry2 + vy2) > 1.0 - radius) vy2 = -vy2;
if (Math.abs(rx3 + vx3) > 1.0 - radius) vx3 = -vx3;
if (Math.abs(ry3 + vy3) > 1.0 - radius) vy3 = -vy3;
// position
rx += vx;
ry += vy;
rx2 = vx2 / Math.tan(vy / vx);
ry2 = vy2 / Math.tan(vy / vx);
rx3 += vx3;
ry3 += vy3;
// clear
StdDraw.setPenColor(StdDraw.GRAY);
StdDraw.filledSquare(0, 0, 1.0);
// ball
StdDraw.setPenColor(StdDraw.BLUE);
StdDraw.filledCircle(rx, ry, radius);
// ball2
StdDraw.setPenColor(StdDraw.BLACK);
StdDraw.filledCircle(rx2, ry2, radius / 2);
// ball3
StdDraw.setPenColor(StdDraw.YELLOW);
StdDraw.filledCircle(rx3, ry3, radius / 2);
// display and pause for 20 ms
StdDraw.show(20);
}
}
// draw the maze
public void draw() {
StdDraw.setPenColor(StdDraw.RED);
StdDraw.filledCircle(N / 2.0 + 0.5, N / 2.0 + 0.5, 0.375);
StdDraw.filledCircle(1.5, 1.5, 0.375);
StdDraw.setPenColor(StdDraw.BLACK);
for (int x = 1; x <= N; x++) {
for (int y = 1; y <= N; y++) {
if (south[x][y]) StdDraw.line(x, y, x + 1, y);
if (north[x][y]) StdDraw.line(x, y + 1, x + 1, y + 1);
if (west[x][y]) StdDraw.line(x, y, x, y + 1);
if (east[x][y]) StdDraw.line(x + 1, y, x + 1, y + 1);
}
}
StdDraw.show(1000);
}
/**
* @param tn - TreeNode object
* @param even - Vertical or horizontal cuts
* @param left - left or right
* @param pivot - Pivot point This function recursively draws the binary tree and displays how the
* tree slices the unit square. It works by sending it the current node to draw, whether or
* not it is a vertical cut, whether or not it is a left node, and a "pivot" point. The pivot
* point tells the method where to start and stop the line.
*/
private void drawPoints(TreeNode tn, boolean even, boolean left, double pivot) {
if (tn == null) return;
StdDraw.setPenColor();
// StdDraw.filledCircle(tn.p.x(), tn.p.y(), .005);
if (even) { // Vertical cuts
StdDraw.setPenColor(Color.red);
if (left) {
StdDraw.line(tn.p.x(), 0, tn.p.x(), pivot);
} else {
StdDraw.line(tn.p.x(), pivot, tn.p.x(), 1);
}
pivot = tn.p.x();
} else { // Horizontal cuts
StdDraw.setPenColor(Color.blue);
if (left) {
StdDraw.line(0, tn.p.y(), pivot, tn.p.y());
} else {
StdDraw.line(pivot, tn.p.y(), 1, tn.p.y());
}
pivot = tn.p.y();
}
StdDraw.setPenColor();
StdDraw.filledCircle(tn.p.x(), tn.p.y(), .007);
drawPoints(tn.left, !even, true, pivot);
drawPoints(tn.right, !even, false, pivot);
} // End drawPoints() function
private void drawNode(TreePosition p, Node x) {
StdDraw.setPenColor(Color.GREEN);
StdDraw.filledCircle(p.x, p.y, 0.3);
StdDraw.setPenColor(Color.RED);
StdDraw.text(p.x, p.y, x.key.toString());
StdDraw.setPenColor(Color.BLACK);
}
@Override
public void draw() {
if (!hidden) {
StdDraw.setPenColor(StdDraw.YELLOW);
StdDraw.filledCircle(myX, myY, radius);
}
}
// solve the maze using depth-first search
private void solve(int x, int y) {
if (x == 0 || y == 0 || x == N + 1 || y == N + 1) return;
if (done || visited[x][y]) return;
visited[x][y] = true;
StdDraw.setPenColor(StdDraw.BLUE);
StdDraw.filledCircle(x + 0.5, y + 0.5, 0.25);
StdDraw.show(30);
// reached middle
if (x == N / 2 && y == N / 2) done = true;
if (!north[x][y]) solve(x, y + 1);
if (!east[x][y]) solve(x + 1, y);
if (!south[x][y]) solve(x, y - 1);
if (!west[x][y]) solve(x - 1, y);
if (done) return;
StdDraw.setPenColor(StdDraw.GRAY);
StdDraw.filledCircle(x + 0.5, y + 0.5, 0.25);
StdDraw.show(30);
}
/**
* 猫由身体（三角形）、头（圆形）、左耳（三角形）、右耳（三角形）构成 已知中心坐标(x, y) 身体三角形：(x, y + 3)、(x - 2.5, y - 9)、(x + 2.5, y -
* 9) 头：圆心(x, y + 5)，半径2.5 左耳三角形：(x, y + 5)、(x - 2.5, y + 5)、(x - 2.5, y + 10) 右耳三角形：(x, y + 5)、(x
* + 2.5, y + 5)、(x + 2.5, y + 10)
*/
private void drawCat(double x, double y) {
StdDraw.setPenColor(StdDraw.BLACK);
StdDraw.filledPolygon(new double[] {x, x - 2.5, x + 2.5}, new double[] {y + 3, y - 9, y - 9});
StdDraw.filledCircle(x, y + 5, 2.5);
StdDraw.filledPolygon(new double[] {x, x - 2.5, x - 2.5}, new double[] {y + 5, y + 5, y + 10});
StdDraw.filledPolygon(new double[] {x, x + 2.5, x + 2.5}, new double[] {y + 5, y + 5, y + 10});
StdDraw.setPenRadius(0.005);
StdDraw.line(x - 2, y - 8, x - 5, y);
}
// 描绘当前场景
public void show(int t) {
StdDraw.clear();
StdDraw.setFont(font1);
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (board[i][j] <= 0) StdDraw.setPenColor(StdDraw.LIGHT_GRAY);
else StdDraw.setPenColor(StdDraw.ORANGE);
StdDraw.filledCircle(getX(i, j), getY(i), 10); // 画格子
if (board[i][j] == 20) drawShit(getX(i, j), getY(i)); // 画猫屎
else if (board[i][j] > 0 && board[i][j] < 10) { // 填数字
StdDraw.setPenColor(StdDraw.RED);
StdDraw.text(getX(i, j), getY(i) - 2, String.valueOf(board[i][j]));
}
}
}
drawCat(getX(cat.getPos() / 9, cat.getPos() % 9), getY(cat.getPos() / 9)); // 画猫
StdDraw.setFont(font2);
StdDraw.setPenColor(StdDraw.ORANGE);
StdDraw.text(175, 195, "已用：" + count + " 步"); // 右上角步数统计
StdDraw.show(t); // 延时
}
public NFADemo(String regexp) {
// use stack to keep track of the positions of '('and '|'
// issue : or的优先级最低
Stack<Integer> ops = new Stack<Integer>();
re = regexp.toCharArray();
M = re.length;
G = new Digraph(M + 1);
// 第一次遍历，确定层次，仅为作图用
int[] levels = new int[M]; // levels仅在 * 和 | 处非零
for (int i = 0; i < M; i++) {
int lp = i;
if (re[i] == '(' || re[i] == '|') ops.push(i);
else if (re[i] == ')') {
int or = ops.pop();
if (re[or] == '|') {
lp = ops.pop();
levels[or] = maxOfArr(levels, lp, i) + 1;
} else lp = or;
}
if (i < M - 1 && re[i + 1] == '*') levels[i + 1] = maxOfArr(levels, lp, i + 1) + 1;
}
int maxLevel = maxOfArr(levels, 0, M);
StdDraw.setCanvasSize(800, 800 * 2 * maxLevel / M);
StdDraw.setXscale(0, M);
StdDraw.setYscale(-maxLevel, maxLevel);
double r = 0.2;
for (int v = 0; v < G.V(); v++) {
if (v < M) {
StdDraw.circle((double) v, 0.0, r);
StdDraw.text((double) v, 0.0, (new Character(re[v]).toString()));
} else StdDraw.filledCircle((double) v, 0.0, r);
}
StdDraw.setPenColor(StdDraw.RED);
StdDraw.setPenRadius(0.005);
ops = new Stack<Integer>();
for (int i = 0; i < M; i++) {
int lp = i;
if (re[i] == '(' || re[i] == '|') ops.push(i);
else if (re[i] == ')') {
int or = ops.pop();
if (re[or] == '|') {
lp = ops.pop();
G.addEdge(lp, or + 1);
G.addEdge(or, i);
// connect (lp, or+1), (or, i)
double level = (double) levels[or];
StdDraw.line(or, r, or, level);
StdDraw.line(or, level, i, level);
StdDraw.arrow(i, level, i, r);
StdDraw.line(lp, -r, lp, -level);
StdDraw.line(lp, -level, or + 1, -level);
StdDraw.filledArrow(or + 1, -level, or + 1, -r);
} else lp = or; // 此时是'(', 在后面跟的是*时会用到
}
if (i < M - 1 && re[i + 1] == '*') {
// look ahead
G.addEdge(lp, i + 1);
G.addEdge(i + 1, lp);
// connect (lp, i+1), (i+1, lp)
double level = (double) levels[i + 1];
StdDraw.line(i + 1, r, i + 1, level);
StdDraw.line(i + 1, level, lp, level);
StdDraw.filledArrow(lp, level, lp, r);
StdDraw.line(lp, -r, lp, -level);
StdDraw.line(lp, -level, i + 1, -level);
StdDraw.filledArrow(i + 1, -level, i + 1, -r);
}
if (re[i] == '(' || re[i] == '*' || re[i] == ')') {
G.addEdge(i, i + 1);
StdDraw.filledArrow(i + r, 0.0, i + 1 - r, 0.0);
} else if (re[i] != '|') { // match transitions
StdDraw.setPenColor();
StdDraw.filledArrow(i + r, 0.0, i + 1 - r, 0.0);
StdDraw.setPenColor(StdDraw.RED);
}
}
}
