Pipes, Java - rextester

Language: Layout:

//Title of this code
//'main' method must be in a class 'Rextester'.
//Compiler version 1.7.0_51

import java.util.Random;
import java.util.*;
import java.lang.*;

class Pipe implements Cloneable {

// Types:
    //
    // 1. ╩ ╣ ╠ ╦
    //
    // 2. ╗ ╝ ╚ ╔
    //
    // 3. ║ ═
    //
    // 4. ╬
  
    private Random rand;
    private int type;
    private boolean up;
    private boolean down;
    private boolean left;
    private boolean right;
    
    public Pipe() {
        rand = new Random();
        this.type  = 0;
        this.up    = false;
        this.down  = false;
        this.left  = false;
        this.right = false;
    }
    
    public Pipe(int type, boolean up, boolean down, boolean left, boolean right) {
        rand = new Random();
        this.type = type;
        this.up = up;
        this.down = down;
        this.left = left;
        this.right = right;
    }
    
    public boolean getUp()    { return up; }
    public boolean getDown()  { return down; }
    public boolean getLeft()  { return left; }
    public boolean getRight() { return right; }
    
    public void setUp()    { up    = true; }
    public void setDown()  { down  = true; }
    public void setLeft()  { left  = true; }
    public void setRight() { right = true; }
    
    public void rotateLeft() {
        boolean u = false;
        boolean d = false;
        boolean l = false;
        boolean r = false;
        
        if (up)    l = true;
        if (down)  r = true;
        if (left)  d = true;
        if (right) u = true;
        
        up    = u;
        down  = d;
        left  = l;
        right = r;
    }
    
    public void rotateRight() {
        boolean u = false;
        boolean d = false;
        boolean l = false;
        boolean r = false;
        
        if (up)    r = true;
        if (down)  l = true;
        if (left)  u = true;
        if (right) d = true;
        
        up    = u;
        down  = d;
        left  = l;
        right = r;
    }
    
    public char getChar() {
        if (type == 4)
            return '╬';
        
        if (type == 3) {
            if (up)
                return '║';
            else
                return '═';
        }
        
        if (type == 2) {
            if (up) {
                if (left)
                    return '╝';
                else
                    return '╚';
            } else {
                if (left)
                    return '╗';
                else
                    return '╔';
            }
        }

if (!up)
            return '╦';
        if (!down)
            return '╩';
        if (!left)
            return '╠';
        
        return '╣';
    }
    
    public static Pipe getRandom() {
        Random rand = new Random();
        int randomNum = rand.nextInt(11);
        
        switch (randomNum) {
            case 0:
                // ╩
                return new Pipe(1, true, false, true, true);
            case 1:
                // ╣
                return new Pipe(1, true, true, false, true);
            case 2:
                // ╠
                return new Pipe(1, true, true, true, false);
            case 3:
                // ╦
                return new Pipe(1, false, true, true, true);
            
            
            case 4:
                // ╗
                return new Pipe(2, false, true, true, false);
            case 5:
                // ╝
                return new Pipe(2, true, false, true, false);
            case 6:
                // ╚
                return new Pipe(2, true, false, false, true);
            case 7:
                // ╔
                return new Pipe(2, false, true, false, true);
            
            
            case 8:
                // ║
                return new Pipe(3, true, true, false, false);
            case 9:
                // ═
                return new Pipe(3, false, false, true, true);
            
            
            default:
            //case 10:
                // ╬
                return new Pipe(4, true, true, true, true);
        }
    }
    
    public boolean isSetAny() {
        return (up || down || left || right);
    }
    
    public void setType() {
        int dirs = 0;
        if (up)    dirs++;
        if (down)  dirs++;
        if (left)  dirs++;
        if (right) dirs++;
        
        if (dirs == 4) {
            type = 4;
        } else if (dirs == 3) {
            type = 1;
        } else {
            if ((up && down) || (left && right))
                type = 3;
            else
                type = 2;   
        }
    }

public Pipe deepCopy() { 
        try {
			return (Pipe)this.clone();
		} catch (CloneNotSupportedException e) {
			return null;
		}
    }
    
    
    public void getPic() {}

}

class Direction {
    final static int UP = 1;
    final static int DOWN = 2;
    final static int LEFT = 3;
    final static int RIGHT = 4;
}

class Board {
    
    private Random rand;
    private int rows;
    private int columns;
    private Pipe[][] board;
    
    
    public Board(boolean random, int rows, int columns) {
        
        rand = new Random();
        
        this.rows = rows;
        this.columns = columns;
        
        board = new Pipe[rows][columns];
        
        if (random) {
            
            for (int i = 0; i < rows; ++i)
                for (int j = 0; j < columns; ++j)
                    board[i][j] = Pipe.getRandom();
            
        } else {
        
            for (int i = 0; i < rows; ++i)
                for (int j = 0; j < columns; ++j)
                    board[i][j] = new Pipe();
 
            for (int i = 0; i < rows; ++i)   {
                boolean[][] b = new boolean[rows][columns];
                for (int k = 0; k < rows; ++k)
                    for (int l = 0; l < columns; ++l)
                        b[k][l] = false;
                fillPath(b, i, columns - 1);
            }
            
            for (int i = 0; i < rows; ++i) {
                board[i][columns - 1].setRight();
            }
            
            
            for (int i = 0; i < rows; ++i)
                for (int j = 0; j < columns; ++j) {
                    if (!board[i][j].isSetAny())
                        board[i][j] = Pipe.getRandom();
                    board[i][j].setType();
                }
        }
    }
    
    
    
    private void fillPath(boolean[][] b, int i, int j) {
        
        if (j == 0 || board[i][j].isSetAny())
        {
            if (j == 0) {
                System.out.println("i:" + i + " j:" + j);
                board[i][j].setLeft();
            }
            return;
        }
        
        
        b[i][j] = true;
        
        
        boolean found = false;
        int k = 30;
        while (!found) {
            k--;
            if (k < 0) {
                System.out.println("Fuuuck");
                
                while (j > 0) {
                    board[i][j].setLeft();
                    board[i][j-1].setRight();
                    j--;
                }
                
                board[i][j].setLeft();
                break;
            }
            
            
            int randomDir = rand.nextInt(4);
            
            // Up
            if (randomDir == 0 && i > 0 && !b[i-1][j]) {
                board[i][j].setUp();
                fillPath(b, i-1, j);
                board[i-1][j].setDown();
                found = true;
                
            // Down
            } else if (randomDir == 1 && i < rows - 1 && !b[i+1][j]) {
                board[i][j].setDown();
                fillPath(b, i+1, j);
                board[i+1][j].setUp();
                found = true;
                
            // Left
            } else if (randomDir == 2 && j > 0 && !b[i][j-1]) {
                board[i][j].setLeft();
                fillPath(b, i, j-1);
                board[i][j-1].setRight();
                found = true;
                
            // Right
            } else if (randomDir == 3 && j < columns - 1 && !b[i][j+1]) {
                board[i][j].setRight();
                fillPath(b, i, j+1);
                board[i][j+1].setLeft();
                found = true;
            }
        }
    }
    
    
    public int flowScore() {
        boolean[][] b = calcFlow();
        int sum = 0;
        
        for (int i = 0; i < rows; ++i)
            if (b[i][columns-1] && board[i][columns-1].getRight())
                ++sum;
        return sum;
    }

public void decreaseFlow() {
        int min = flowSize();
        
        for (int j = columns-1; j >= 0; --j) {
            for (int i = 0; i < rows; ++i) {
                
                Pipe bestPipe = board[i][j].deepCopy();
                int k = 4;
                while (k >= 0) {
                    --k;
                    
                    board[i][j].rotateLeft();
                    int curr = flowSize();
                    if (curr < min) {
                        bestPipe = board[i][j].deepCopy();
                        min = curr;
                    }  
                }
                    
                board[i][j] = bestPipe;  
            }
        }
    }
    
    public void increaseFlow() {
        int max = flowSize();
        
        for (int j = 0; j < columns; ++j) {
            for (int i = 0; i < rows; ++i) {
                
                Pipe bestPipe = board[i][j].deepCopy();
                int k = 4;
                while (k >= 0) {
                    --k;
                    
                    board[i][j].rotateLeft();
                    int curr = flowSize();
                    if (curr > max) {
                        bestPipe = board[i][j].deepCopy();
                        max = curr;
                    }  
                }
                    
                board[i][j] = bestPipe;  
            }
        }
    }
    
    private int flowSize() {
        boolean[][] b = calcFlow();
        int sum = 0;
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < columns; ++j)
                if (b[i][j])
                    sum++;
                
        return sum;
    }
    
 
    
    private boolean flow(boolean[][] b, int i, int j) {
        
        if (j == columns-1 && board[i][j].getRight()) {
            b[i][j] = true;
            return true;
        }
        
        if (b[i][j])
            return false;
        
        b[i][j] = true;
        
        boolean up=false, down=false, left=false, right=false;
        
        if (board[i][j].getUp() && i > 0 && board[i-1][j].getDown())
            up = flow(b, i-1, j);
        
        if (board[i][j].getDown() && i < rows-1 && board[i+1][j].getUp())
            down = flow(b, i+1, j);
        
        if (board[i][j].getLeft() && j > 0 && board[i][j-1].getRight())
            left = flow(b, i, j-1);
        
        if (board[i][j].getRight() && j < columns-1 && board[i][j+1].getLeft())
            right = flow(b, i, j+1);
        
        return up || down || left || right;
    }
    
    
    public boolean[][] calcFlow() {
        boolean[][] b = new boolean[rows][columns];
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < columns; ++j)
                b[i][j] = false;
            
        for (int i = 0; i < rows; ++i)
            if (board[i][0].getLeft())
                flow(b, i, 0);
            
        return b;
    }
    
    
    private void merge(boolean[][] b, boolean[][] n) {
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < columns; ++j)
                if (n[i][j])
                    b[i][j] = true;
    }
    
    
    private boolean[][] calcFlowExplosion() {     
        boolean[][] b = new boolean[rows][columns];
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < columns; ++j)
                b[i][j] = false;
            
        for (int i = 0; i < rows; ++i)
            if (board[i][0].getLeft()) {
            
                boolean[][] n = new boolean[rows][columns];
                for (int k = 0; k < rows; ++k)
                    for (int l = 0; l < columns; ++l)
                        n[k][l] = false;
            
                if (flow(n, i, 0))
                    merge(b, n);
                
            }
            
        return b;
    }
    
    
    public void printFlowExplosion() {
        System.out.println("Exploison map:");
        boolean[][] b = calcFlowExplosion();
        
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                if (b[i][j])
                    System.out.print(board[i][j].getChar());
                else
                    System.out.print(".");
            }
            System.out.println();
        } 
    }
        
    public void printFlow() {
        System.out.println("Flow map:");
        boolean[][] b = calcFlow();
        
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                if (b[i][j])
                    System.out.print(board[i][j].getChar());
                else
                    System.out.print(".");
            }
            System.out.println();
        } 
    }
    
    
    
    
    public void print() {
        System.out.println("Board:");
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                System.out.print(board[i][j].getChar());    
            }
            System.out.println();
        }
        
        /*
        System.out.println("Info:");
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                System.out.println("i: " + i + " j: " + j + "  " +
                                   board[i][j].getUp() + " " + board[i][j].getDown() + " " +
                                   board[i][j].getLeft() + " " + board[i][j].getRight() + " " + board[i][j].getChar());    
            }
        }
        */
    }

}

class Rextester
{  
    final static int rows = 8;
    final static int columns = 80;
    
   
    public static void main(String args[])
    {
        
        Board b = new Board(true, rows, columns);
        b.print();
        System.out.println();
        b.printFlow();
        System.out.println();
        
        b.increaseFlow();
        b.printFlow();
        System.out.println("Score: " + b.flowScore());
        System.out.println();
        
        b.printFlowExplosion();
        System.out.println();
        
        
        b.decreaseFlow();
        b.printFlow();
        
        
        
        /*
        Board b1 = new Board(false, rows, columns);
        b1.print();
        System.out.println();
        b1.printFlow();
        
        System.out.println("Score: " + b1.flowScore());
        */
        
        /*
        Pipe[][] board = new Pipe[rows][columns];
        
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < columns; ++j)
                board[i][j] = Pipe.getRandom();
        
        
        System.out.println("Board:");
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                System.out.print(board[i][j].getChar());    
            }
            System.out.println();
        }
        
        
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < columns; ++j)
                board[i][j].rotateLeft();

System.out.println("Board:");
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                System.out.print(board[i][j].getChar());    
            }
            System.out.println();
        }        
        
        */
        
        
        
    }
}

[ + ] Show input
Compilation time: 1.03 sec, absolute running time: 0.43 sec, cpu time: 0.5 sec, memory peak: 36 Mb, absolute service time: 1.47 sec