最近码代码手感不错哟

package edu.zju.ee;

enum Color {
    YELLOW, WHITE, ORANGE, RED, BLUE, GREEN
}

class Tile {
    public final Color color;
    private int[] coordinate;
    
    public Tile(Color color, int x, int y, int z) {
        this.color = color;
        this.coordinate = new int[] {x, y, z};
    }
    
    public Tile(Tile tile) {
        this.color = tile.color;
        this.coordinate = new int[] { tile.coordinate[0], tile.coordinate[1], tile.coordinate[2] };
    }
    
    public void rotate(int index, int sign, int wise) {
        if(coordinate[index]*sign <= 0) return;
        
        int indexOne = (index+1) % 3;
        int indexTwo = (index+2) % 3;
        
        int t = coordinate[indexOne];
        coordinate[indexOne] = coordinate[indexTwo];
        coordinate[indexTwo] = t;
        
        if(sign*wise > 0) coordinate[indexOne] = -coordinate[indexOne];
        else coordinate[indexTwo] = -coordinate[indexTwo];
    }
    
    public void rotate(int faceIndex, int wise) {
        //rotate(faceIndex/2, faceIndex%2==1? -1:1, wise);
        rotate(faceIndex/2, (faceIndex%2)*(-2)+1, wise);
    }
    
    public int getAxisIndex() {
        int index = 0;
        for(int i=0; i<3; ++i)
            if( Math.abs(coordinate[i]) > Math.abs(coordinate[index]) )
                index = i;
        return index;
    }
    
    public int getFaceIndex() {
        int index = getAxisIndex();
        return coordinate[index]>0 ? index*2 : index*2+1;
    }
    
    public int getLocationIndex() {
        int index = getAxisIndex();
        
        int indexOne = (index+1) % 3;
        int indexTwo = (index+2) % 3;
        
        if(coordinate[index]>0)
            return (coordinate[indexOne]+1) * 3 + (coordinate[indexTwo]+1);
        else
            return (coordinate[indexTwo]+1) * 3 + (coordinate[indexOne]+1);
    }
    
    public String toString() {
        return "The color of Tile at Location NO." + getLocationIndex()
                + " on Face NO." + getFaceIndex()
                + " is " + color;
    }
}

public class Cube {
    public static final int MAX_NUMBER_OF_STEPS = 100;
    
    private Tile[] tiles;
    private int[] rotationSteps = new int[MAX_NUMBER_OF_STEPS];
    private int numberOfSteps = 0;
    
    public Cube() {
        tiles = new Tile[54];
        int rear = 0;
        
        for(int i=-1; i<=1; ++i)
            for(int j=-1; j<=1; ++j)
                tiles[rear++] = new Tile(Color.YELLOW, 2, i, j);
        
        for(int i=-1; i<=1; ++i)
            for(int j=-1; j<=1; ++j)
                tiles[rear++] = new Tile(Color.WHITE, -2, i, j);
        
        for(int i=-1; i<=1; ++i)
            for(int j=-1; j<=1; ++j)
                tiles[rear++] = new Tile(Color.ORANGE, j, 2, i);
        
        for(int i=-1; i<=1; ++i)
            for(int j=-1; j<=1; ++j)
                tiles[rear++] = new Tile(Color.RED, j, -2, i);
        
        for(int i=-1; i<=1; ++i)
            for(int j=-1; j<=1; ++j)
                tiles[rear++] = new Tile(Color.BLUE, i, j, 2);
        
        for(int i=-1; i<=1; ++i)
            for(int j=-1; j<=1; ++j)
                tiles[rear++] = new Tile(Color.GREEN, i, j, -2);
    }
    
    public Cube(Cube cube) {
        tiles = new Tile[54];
        for(int i=0; i<54; ++i) tiles[i] = new Tile(cube.tiles[i]);
        for(numberOfSteps=0; numberOfSteps<cube.numberOfSteps; ++numberOfSteps)
            rotationSteps[numberOfSteps] = cube.rotationSteps[numberOfSteps];
    }
    
    public void rotate(int index, int sign, int wise) {
        for(int i=0; i<54; ++i) tiles[i].rotate(index, sign, wise);
        int faceIndex = sign>0 ? index*2 : index*2+1;
        rotationSteps[numberOfSteps++] = wise>0 ? faceIndex*2 : faceIndex*2+1;
    }
    
    public void rotate(int faceIndex, int wise) {
        for(int i=0; i<54; ++i) tiles[i].rotate(faceIndex, wise);
        rotationSteps[numberOfSteps++] = wise>0 ? faceIndex*2 : faceIndex*2+1;
    }
    
    public void rollback() {
        int step = rotationSteps[--numberOfSteps];
        int faceIndex = step/2, wise = step%2==1? -1:1;
        for(int i=0; i<54; ++i) tiles[i].rotate(faceIndex, -wise);
    }
    
    public String getSteps() {
        String steps = "";
        for(int i=0; i<numberOfSteps; ++i) {
            int faceIndex = rotationSteps[i]/2, wise = rotationSteps[i]%2==1? -1:1;
            steps += " " + Color.values()[faceIndex] + "." + (wise<0 ? "Clockwise" : "AntiClockwise");
        }
        return steps;
    }
    
    public int counts() {
        boolean[][] hasColor = new boolean[6][6];
        for(int i=0; i<54; ++i)
            hasColor[tiles[i].getFaceIndex()][tiles[i].color.ordinal()] = true;
        int faceIndex = 0, maxCountOfColor = 0;
        for(int i=0; i<6; ++i) {
            int countOfColor = 0;
            for(int j=0; j<6; ++j) if(hasColor[i][j]) ++countOfColor;
            if(countOfColor > maxCountOfColor) {
                faceIndex = i;
                maxCountOfColor = countOfColor;
            }
        }
        return faceIndex + maxCountOfColor*6;
    }
    
    public Cube searchCounts(int n) {
        if(n==0) return new Cube(this);
        
        Cube cubeOfMaximumCount = this;
        for(int i=0; i<6; ++i) for(int j=-1; j<=1; j+=2) {
            rotate(i, j);
            Cube cube = searchCounts(n-1);
            rollback();
            int count = cube.counts()/6, maxCount = cubeOfMaximumCount.counts()/6;
            if(count > maxCount || count == maxCount && cube.numberOfSteps < cubeOfMaximumCount.numberOfSteps)
                cubeOfMaximumCount = cube;
        }
        if(cubeOfMaximumCount == this) return new Cube(this);
        return cubeOfMaximumCount;
    }
    
    public void showSteps() {
        System.out.println("The Rotation Steps is as follow");
        System.out.println(getSteps());
    }
    
    public void showColorsOfFace(int faceIndex) {
        Color[][] face = new Color[3][3];
        for(int i=0; i<54; ++i)
            if(tiles[i].getFaceIndex() == faceIndex) {
                int locationIndex = tiles[i].getLocationIndex();
                face[locationIndex/3][locationIndex%3] = tiles[i].color;
            }
        
        System.out.println("The colors on Face NO." + faceIndex + " is as follow");
        for(int i=0; i<3; ++i)
            System.out.printf("%8s%8s%8s%n", face[i][0], face[i][1], face[i][2]);
    }
    
    public static void main(String[] args) {
        Cube cube = new Cube();
        
        Cube cubeOfMaximumCount = cube.searchCounts(4);
        cubeOfMaximumCount.showSteps();
        System.out.println("");
        
        int count = cubeOfMaximumCount.counts();
        int faceIndexOfMaximumCount = count%6, maxCountOfColor = count/6;
        cubeOfMaximumCount.showColorsOfFace(faceIndexOfMaximumCount);
        System.out.println("");
        System.out.println("Thus, Face NO." + faceIndexOfMaximumCount + " has " + maxCountOfColor + " different colors");
        
        //mainOldVersion(null);
    }
    
    public static void mainOldVersion(String[] args) {
        //　ｏｌｄ　ｖｅｒｓｉｏｎ　旋转五步之后找到一面之中颜色数目最多的魔方
        Cube cube = new Cube();
        
        Cube cubeOfMaximumCount = cube;
        int faceIndexOfMaximumCount = 0, maxCountOfColor = 1;
        for(int i1=0; i1<6; ++i1) for(int j1=-1; j1<=1; j1+=2) {
            cube.rotate(i1, j1);
            for(int i2=0; i2<6; ++i2) for(int j2=-1; j2<=1; j2+=2) {
                cube.rotate(i2, j2);
                for(int i3=0; i3<6; ++i3) for(int j3=-1; j3<=1; j3+=2) {
                    cube.rotate(i3, j3);
                    for(int i4=0; i4<6; ++i4) for(int j4=-1; j4<=1; j4+=2) {
                        cube.rotate(i4, j4);
                        for(int i5=0; i5<6; ++i5) for(int j5=-1; j5<=1; j5+=2) {
                            cube.rotate(i5, j5);
                            int count = cube.counts();
                            int faceIndex = count%6, countOfColor = count/6;
                            if(countOfColor > maxCountOfColor) {
                                cubeOfMaximumCount = new Cube(cube);
                                faceIndexOfMaximumCount = faceIndex;
                                maxCountOfColor = countOfColor;
                            }
                            cube.rollback();
                        }
                        cube.rollback();
                    }
                    cube.rollback();
                }
                cube.rollback();
            }
            cube.rollback();
        }
        cubeOfMaximumCount.showSteps();
        System.out.println("");
        cubeOfMaximumCount.showColorsOfFace(faceIndexOfMaximumCount);
        System.out.println("");
        System.out.println("Thus, Face NO." + faceIndexOfMaximumCount + " has " + maxCountOfColor + " different colors");
    }
}