재미있게 코드를 치자

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Stack;

import java.util.StringTokenizer;

class Home {

int x, y;

public Home(int y, int x) {

this.y = y;

this.x = x;

}

}

class Solution {

static boolean Debug = false;

static int MapSize, ServFee;

static int[][] Map;

static ArrayList<Home> hList;

private static int T;

private static int MaxCount;

public static void main(String args[]) throws Exception {

BufferedReader br;

if (Debug) {

File f = new File("디렉토리", "sample_input (7).txt");

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

br = new BufferedReader(new InputStreamReader(System.in)); // 직접입력시 이용

}

StringTokenizer st;

int TestSize = Integer.parseInt(br.readLine());

for (T = 1; T <= TestSize; T++) {

// MapSize , ServFee ;

st = new StringTokenizer(br.readLine());

MapSize = Integer.parseInt(st.nextToken());

ServFee = Integer.parseInt(st.nextToken());

// 맵 데이터 & 홈 집합

hList = new ArrayList<>();

Map = new int[MapSize][];

for (int i = 0; i < MapSize; i++) {

Map[i] = new int[MapSize];

st = new StringTokenizer(br.readLine());

for (int j = 0; j < MapSize; j++) {

Map[i][j] = Integer.parseInt(st.nextToken());

if (Map[i][j] == 1) {

hList.add(new Home(i, j));

}

}

}

// 완전탐색

MaxCount = 0;

findPath();

System.out.println(String.format("#%d %d", T, MaxCount));

}

}

private static void findPath() {

// [준비] 최대 방범 크기는?

int maxSize = -1;

for (int k = 1; ; k++) {

int profit = ServFee * hList.size() - (k * k + (k - 1) * (k - 1));

if (profit >= 0) {

maxSize = k;

} else {

break;

}

}

// log("hSize: %d  ,  maxSize: %d", hList.size(), maxSize);

int tempCount;

// 1. 크기를 적용한다.

for (int s = maxSize; s >= 0; s--) {

// 2. 좌표를 돈다.

for (int i = 0; i < MapSize * MapSize; i++) {

// 해당 좌표에서 해당 크기에, 몇개의 집이 들어가는가?

tempCount = countHome(s, i);

// log("countHome(%d,%d) = %d", s, i, tempCount);

if (MaxCount < tempCount) {

MaxCount = tempCount;

}

}

}

}

private static int countHome(int scanSize, int xy) {

// log("countHome(%d,%d)", scanSize, xy);

int y = xy / MapSize;

int x = xy % MapSize;

Stack<Home> dStack = new Stack<>();

int gap;

for (Home home : hList) {

gap = ((x - home.x) > 0 ? (x - home.x) : (home.x - x));

gap += ((y - home.y) > 0 ? (y - home.y) : (home.y - y));

if (gap < scanSize) {

dStack.add(home);

} else {

// Non-target

}

}

int Profit = dStack.size() * ServFee;

Profit -= scanSize * scanSize + (scanSize - 1) * (scanSize - 1);

return Profit >= 0 ? dStack.size() : 0;

}

private static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

private static void log(String input, Object... args) {

if (Debug) {

System.out.println(String.format(input, args));

}

}

}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Stack;

import java.util.StringTokenizer;

class Virus {

int x, y;

int amount;

int rIndex;

public Virus(int y, int x, int amount, int rIndex) {

this.y = y;

this.x = x;

this.amount = amount;

this.rIndex = rIndex;

}

public int getXY() {

return Solution.MapSize * y + x;

}

}

class Solution {

static boolean Debug = false;

static int MapSize, TimeSize, VirusLen;

static ArrayList<Virus> vList;

private static int T;

public static void main(String args[]) throws Exception {

BufferedReader br;

if (Debug) {

File f = new File("디렉토리", "sample_input (5).txt");

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

br = new BufferedReader(new InputStreamReader(System.in)); // 직접입력시 이용

}

StringTokenizer st;

int TestSize = Integer.parseInt(br.readLine());

for (T = 1; T <= TestSize; T++) {

// MapSize , TimeSize , VirusLen;

st = new StringTokenizer(br.readLine());

MapSize = Integer.parseInt(st.nextToken());

TimeSize = Integer.parseInt(st.nextToken());

VirusLen = Integer.parseInt(st.nextToken());

// 균데이터

vList = new ArrayList<>();

int y, x, amount, rIndex;

for (int i = 0; i < VirusLen; i++) {

st = new StringTokenizer(br.readLine());

y = Integer.parseInt(st.nextToken());

x = Integer.parseInt(st.nextToken());

amount = Integer.parseInt(st.nextToken());

rIndex = Integer.parseInt(st.nextToken()) - 1;

vList.add(new Virus(y, x, amount, rIndex));

}

// 매초마다 시뮬레이션

for (int i = 0; i < TimeSize; i++) {

moveVirus();

modifyVirus();

}

// 결과 출력

int sumAmount = 0;

for (Virus item : vList) {

sumAmount += item.amount;

}

// 길찾기 (시작점은 가장 큰 수)

System.out.println(String.format("#%d %d", T, sumAmount));

}

}

private static void modifyVirus() {

int[] check = new int[MapSize * MapSize];

Stack<Integer> dStack = new Stack();

// 방향변경(반전) 및 해독제 효과(1/2)

for (Virus virus : vList) {

if (virus.x == 0 || virus.x == MapSize - 1) {

virus.rIndex = (virus.x == 0 ? 3 : 2); // 2(좌) 3(우)

virus.amount = virus.amount / 2;

} else if (virus.y == 0 || virus.y == MapSize - 1) {

virus.rIndex = (virus.y == 0 ? 1 : 0); // 0(상) 1(하)

virus.amount = virus.amount / 2;

}

// 중복값에 대한 좌표값 체크

// log("virus x:%d , y:%d", virus.x, virus.y);

if (++check[virus.getXY()] == 2) {

dStack.add(virus.getXY());

}

}

// 좌표가 중복되는  Virus

Stack<Virus> vStack = new Stack<>();

for (int xy : dStack) {

int maxAmount = -1;

int sumAmount = 0;

// 좌표가 같은 Virus 집단

for (Virus virus : vList) {

// log("v.amount: %d", virus.amount);

if (virus.getXY() == xy) {

vStack.add(virus);

sumAmount += virus.amount;

if (maxAmount < virus.amount) { // 같을 경우는 없다고 문제에서 가정

maxAmount = virus.amount;

}

} else {

// Non-target

}

}

// log("max: %d, sum: %d", maxAmount, sumAmount);

// 중복균 제거 & 병합

while (!vStack.isEmpty()) {

Virus virus = vStack.pop();

virus.amount = (virus.amount != maxAmount) ? 0 : sumAmount;

if (virus.amount == 0) {

vList.remove(virus);

}

}

}

}

// 상하좌우

static int[] rotX = { 0, 0, -1, 1 };

static int[] rotY = { -1, 1, 0, 0 };

private static void moveVirus() {

// 움직인다.

for (Virus virus : vList) {

int index = virus.rIndex;

virus.x = virus.x + rotX[index];

virus.y = virus.y + rotY[index];

}

}

private static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

private static void log(String input, Object... args) {

if (Debug) {

System.out.println(String.format(input, args));

}

}

}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Stack;

import java.util.StringTokenizer;

class Solution {

static boolean Debug = false;

static int MapSize, DigSize;

static int Highset;

static int[][] Map;

static int[][] Visited;

private static int T;

private static int Answer;

public static void main(String args[]) throws Exception {

BufferedReader br;

if (Debug) {

File f = new File("C:\\Users\\wvimi\\Downloads", "sample_input (4).txt");

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

br = new BufferedReader(new InputStreamReader(System.in)); // 직접입력시 이용

}

StringTokenizer st;

int TestSize = Integer.parseInt(br.readLine());

for (T = 1; T <= TestSize; T++) {

// MapSize , DigSize , 본문 예제

st = new StringTokenizer(br.readLine());

MapSize = Integer.parseInt(st.nextToken());

DigSize = Integer.parseInt(st.nextToken());

// 지도데이터

Map = new int[MapSize][];

Visited = new int[MapSize][];

Highset = 0;

for (int i = 0; i < MapSize; i++) {

Map[i] = new int[MapSize];

Visited[i] = new int[MapSize];

st = new StringTokenizer(br.readLine());

for (int j = 0; j < MapSize; j++) {

Map[i][j] = Integer.parseInt(st.nextToken());

if (Highset < Map[i][j]) {

Highset = Map[i][j];

}

}

}

// 길찾기 (시작점은 가장 큰 수)

ArrayList<Integer> startList = new ArrayList<>();

for (int i = 0; i < MapSize; i++) {

for (int j = 0; j < MapSize; j++) {

if (Highset == Map[i][j]) {

startList.add(i * MapSize + j);

}

}

}

Answer = 0;

for (int item : startList) {

findPath(item / MapSize, item % MapSize, 0);

}

System.out.println(String.format("#%d %d", T, Answer));

}

}

static int rotX[] = { 0, 1, 0, -1 };

static int rotY[] = { 1, 0, -1, 0 };

static Stack<Integer> pStack = new Stack<>();

// 모든 경로를 탐색하는 알고리즘

private static void findPath(int y, int x, int hint) {

Visited[y][x] = 1;

pStack.push(Map[y][x]);

Boolean isLast = true;

for (int i = 0; i < 4; i++) {

int moveY = y + rotY[i];

int moveX = x + rotX[i];

int path = isRight(moveY, moveX, Map[y][x]);

if (path == 1) { // 힌트 없이 전진

findPath(moveY, moveX, hint);

isLast = false;

} else if (path == 0 && hint == 0) {

// 힌트 사용하여 전진

findPath(moveY, moveX, 1);

isLast = false;

} else {

// 못간다.

}

}

if (isLast) {

// 모든 가능한 경로에 도달한 경우

int count = countLength(pStack);

if (count>0) {

if(Answer < count) {

Answer = count;

}

}

}

Visited[y][x] = 0;

pStack.pop();

}

// 탐색경로에서 길이를 체크해주는 함수

private static int countLength(Stack<Integer> inStack) {

ArrayList<Integer> list = new ArrayList<>();

list.addAll(inStack);

// [9, 7, 7, 3, 2]

// a = 7, b= 7, c =3

int temp = list.get(0);

int findIndex = -1;

int size = list.size();

for (int i = 1; i < size; i++) {

if (temp > list.get(i)) {

temp = list.get(i);

} else {

findIndex = i; // found b-index

break;

}

if(i==size-1) {

return list.size();

}

}

int a, b, c; // 오름차순

a = list.get(findIndex - 1);

b = list.get(findIndex);

c = (findIndex + 1 != list.size()) ? list.get(findIndex + 1) : -1;

if(((b - a) + 1 <= DigSize)) { // 땅을 팔 수 있는 경우

if(a > c + 1) { // c가 a보다 2이상 차이 나는 경우, 이 후 순서도 보장

return size;

}else { // c가 a보다 크거나 같은 경우

return findIndex + 1; // b까지 옳음  (b_index + 1개 )

}

}else {

return findIndex ; // b-1 까지 옳음 (b_index-1 + 1개 )

}

}

// 경로 가능성 판단

private static int isRight(int y, int x, int num) {

// 갈수 있으면 1, 숫자 크기 때문에 못가면 0, 범위 밖이면 -1, 방문했던 곳 -1

if (y < 0 || y >= MapSize || x < 0 || x >= MapSize) {

return -1;

}

if (Visited[y][x] == 1) {

return -1;

}

return Map[y][x] < num ? 1 : 0;

}

private static void log(String input) {

System.out.println(input);

}

}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.Stack;

import java.util.StringTokenizer;

class Solution {

static boolean Debug = false;

static int MapSize, GetSize, Capacity;

static int[][] Map;

private static int MaxProfit;

public static void main(String args[]) throws Exception {

BufferedReader br;

if (Debug) {

File f = new File("파일경로", "sample_input (3).txt");

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

br = new BufferedReader(new InputStreamReader(System.in)); // 직접입력시 이용

}

StringTokenizer st;

int T_Count = Integer.parseInt(br.readLine());

for (int T = 1; T <= T_Count; T++) {

// MapSize=4, GetSize=2, Capacity=13

st = new StringTokenizer(br.readLine());

MapSize = Integer.parseInt(st.nextToken());

GetSize = Integer.parseInt(st.nextToken());

Capacity = Integer.parseInt(st.nextToken());

// 지도데이터

Map = new int[MapSize][];

for (int i = 0; i < MapSize; i++) {

Map[i] = new int[MapSize];

st = new StringTokenizer(br.readLine());

for (int j = 0; j < MapSize; j++) {

Map[i][j] = Integer.parseInt(st.nextToken());

}

}

// 이용정보

MaxProfit = -1;

search();

System.out.println(String.format("#%d %d", T, MaxProfit));

}

}

private static void search() {

// 일꾼의 위치1, 위치2

int y1, x1, y2, x2;

for (int i = 0; i < MapSize * MapSize; i++) {

for (int j = i; j < MapSize * MapSize; j++) {

y1 = i / MapSize;

x1 = i % MapSize;

y2 = j / MapSize;

x2 = j % MapSize;

if (isRight(y1, x1, y2, x2) == false) {

continue;

}

// 계산하기

calculate(y1, x1, y2, x2);

}

}

}

private static void calculate(int y1, int x1, int y2, int x2) {

// 현재 좌표에서 최대의 벌꿀 수익량

int maxOne = 0, maxTwo = 0;

int one, two;

for (int i = 0; i < (1 << GetSize); i++) {

// Case (벌꾼 담기)

one = getProfit(y1, x1, i);

two = getProfit(y2, x2, i);

if (maxOne < one) {

maxOne = one;

}

if (maxTwo < two) {

maxTwo = two;

}

}

if(MaxProfit < maxOne + maxTwo) {

MaxProfit = maxOne + maxTwo;

}

}

private static Stack<Integer> pStack = new Stack<>();

private static int getProfit(int y, int x, int bitmask) {

int amount = 0;

for (int i = 0; i < GetSize; i++) {

// 현재 경우에서 일꾼 1의 수익량

if ((bitmask & (1 << i)) > 0) {

// i번째 꿀 수집

amount += Map[y][x + i];

pStack.push(Map[y][x + i]);

}

}

if (amount > Capacity) {

pStack.clear();

return 0;

} else {

int profit = 0;

int temp;

while (!pStack.isEmpty()) {

temp = pStack.pop();

profit += temp * temp;

}

return profit;

}

}

private static boolean isRight(int y1, int x1, int y2, int x2) {

if (y1 >= MapSize || y2 >= MapSize) {

// log("맵 사이즈 초과");

return false;

}

if (x1 + GetSize - 1 >= MapSize || x2 + GetSize - 1 >= MapSize) {

// log("맵 사이즈 초과");

return false;

}

int gap;

if (y1 == y2) {

gap = x1 - x2;

gap = gap > 0 ? gap : -gap;

if (gap < GetSize) {

return false;

}

}

return true;

}

private static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.Arrays;

import java.util.Stack;

import java.util.StringTokenizer;

class Solution {

static boolean Debug = false;

static int[] Ticket = new int[4];

static int[] TicketCounter = new int[4];

static int[] Data = new int[12];

static int[] Visited = new int[12];

static int Data_Length = 12;

static int MIN_COST;

static int FIRST_DAY;

public static void main(String args[]) throws Exception {

BufferedReader br;

if (Debug) {

File f = new File("파일경로", "sample_input.txt");

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

br = new BufferedReader(new InputStreamReader(System.in)); // 직접입력시 이용

}

StringTokenizer st;

int T_Count = Integer.parseInt(br.readLine());

for (int T = 1; T <= T_Count; T++) {

// 가격정보

st = new StringTokenizer(br.readLine());

for (int i = 0; i < 4; i++) {

Ticket[i] = Integer.parseInt(st.nextToken());

TicketCounter[i] = 0;

}

FIRST_DAY = -1;

// 이용정보

st = new StringTokenizer(br.readLine());

for (int i = 0; i < 12; i++) {

Data[i] = Integer.parseInt(st.nextToken());

Visited[i] = (Data[i] == 0 ? 1 : 0);

if(FIRST_DAY == -1 && Data[i]!=0) {

FIRST_DAY = i;

}

}

MIN_COST = Integer.MAX_VALUE;

findFee();

System.out.println(String.format("#%d %d", T, MIN_COST));

}

}

static int[] rot = new int[] { 1, 30, 120, 360 };

static Stack<Integer> debug = new Stack();

private static void findFee() {

// 순차적 접근을 위하여, 가장 최초 index에서 시작

int next = -1;

for (int i = 0; i < Data_Length; i++) {

if (Visited[i] == 0) {

next = i;

break; 

}

}

if (next == -1) {

log(debug.toString());

writeMinCost();

return;

}

for (int i = 0; i < 4; i++) {

if (!isRight(next, rot[i])) {

continue;

}

checkPay(next, i, true);

debug.add(i);

findFee();

checkPay(next, i, false);

debug.pop();

}

}

private static void checkPay(int index, int rindex, boolean isGo) {

if (rot[rindex] == 1) {

TicketCounter[rindex] += isGo ? Data[index] : -Data[index];

} else {

TicketCounter[rindex] += isGo ? 1 : -1;

}

switch (rot[rindex]) {

case 360:

for (int i = 0; i < Data_Length; i++) {

if (Data[i] == 0) {

continue;

}

Visited[i] = isGo ? 1 : 0;

}

break;

case 120:

for (int i = index; (i < index + 3) && i < Data_Length; i++) {

if (Data[i] == 0) {

continue;

}

Visited[i] = isGo ? 1 : 0;

}

break;

case 30:

case 1:

if (Data[index] == 0) {

return;

}

Visited[index] = isGo ? 1 : 0;

break;

}

}

private static boolean isRight(int index, int day) {

if (Visited[index] == 1 || Data[index] == 0) {

return false;

}

// 비용계산

if (day == 360) {

return index == FIRST_DAY;

} else if (day == 120) {

return  Ticket[2] <= getCost(index, 1, 3) && Ticket[2] <= getCost(index, 30, 3);

} else if (day == 30) {

int month_fee = getCost(index, 30, 1);

int day_fee = getCost(index, 1, 1);

return month_fee <= day_fee;

} else if (day == 1) {

int month_fee = getCost(index, 30, 1);

int day_fee = getCost(index, 1, 1);

return month_fee >= day_fee;

}

return false;

}

private static int getCost(int index, int day, int length) {

if (day == 1) { // 1일로 구매한다면

int day_count = 0;

for (int i = index; i < index + length && i < Data_Length; i++) {

day_count += Data[i];

}

return day_count * Ticket[0];

} else if (day == 30) { // 1달로 구매한다면

int month_count = 0;

for (int i = index; i < index + length && i < Data_Length; i++) {

if (Data[i] > 0) {

month_count += 1;

}

}

return month_count * Ticket[1];

}

return Integer.MAX_VALUE;

}

private static void writeMinCost() {

int sum = 0;

for (int i = 0; i < 4; i++) {

if (TicketCounter[i] != 0) {

sum += (Ticket[i] * TicketCounter[i]);

}

}

if(MIN_COST>sum) {

MIN_COST = sum;

}

}

private static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.StringTokenizer;

class Solution {

static int DataLen;

static String[][] map;

static boolean Debug = false;

public static void main(String args[]) throws Exception {

BufferedReader br;

if(Debug) {

File f = new File("C:\\Users\\wvimi\\eclipse-workspace\\HelloWorld2\\input", "input (0).txt");

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

}else {

br = new BufferedReader(new InputStreamReader(System.in)); // 직접입력시 이용

}

DataLen = Integer.parseInt(br.readLine());

int CommandLen = Integer.parseInt(br.readLine());

// 입력부

StringTokenizer st; 

map = new String[DataLen][];

for (int i = 0; i < DataLen; i++) {

map[i] = new String[DataLen];

st = new StringTokenizer(br.readLine());

for (int j = 0; j < DataLen; j++) {

map[i][j] = st.nextToken();

}

}

// 실행부

String result = "";

int y, x, num;

for (int i = 0; i < CommandLen; i++) {

st = new StringTokenizer(br.readLine());

y = Integer.parseInt(st.nextToken()) -1;

x = Integer.parseInt(st.nextToken()) -1;

num = Integer.parseInt(st.nextToken());

Amount = 0;

goPath(y,x, num);

result = String.format("#%d %d", i+1, Amount);

System.out.println(result);

}

}

static int rotX[] = { 1, 0, -1, 0 };

static int rotY[] = { 0, 1, 0, -1 };

static int Amount;

static private void goPath(int y, int x, int num) {

if(num==0) {

Amount = (map[y][x].charAt(1) - '0') * 1000 ;

return;

}

int move_len = map[y][x].charAt(1) - '0'; // 거리

int rot; // 방위

switch (map[y][x].charAt(0)) {

case 'E': // +x

rot = 0;

break;

case 'W': // -x

rot = 2;

break;

case 'S': // y+

rot = 1;

break;

case 'N': // y-

rot = 3;

break;

default: // input case Error

rot = -1; 

}

int move_y = y + move_len* rotY[rot];

int move_x = x + move_len* rotX[rot];

if(isRight(move_y, move_x)) {

goPath(move_y, move_x, num-1);

}else {

Amount = 10000;

}

}

static private boolean isRight(int y, int x) {

if (x < 0 || x > DataLen - 1 || y < 0 || y > DataLen - 1) {

return false;

}

return true;

}

private static void log(String input) {

if (true) {

System.out.println(input);

}

}

}

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.StringTokenizer;

class Solution {

static int knum, depth, Width;

static int[][] data;

static boolean Converse;

private static int Result;

private static boolean Debug = false;

public static void main(String args[]) throws Exception {

BufferedReader br;

br = new BufferedReader(new InputStreamReader(System.in));

StringTokenizer st;

int TestNo = Integer.parseInt(br.readLine());

for (int T = 1; T <= TestNo; T++) {

st = new StringTokenizer(br.readLine());

// 문제 읽기

depth = Integer.parseInt(st.nextToken());

Width = Integer.parseInt(st.nextToken());

knum = Integer.parseInt(st.nextToken());

data = new int[depth][];

// 데이터 읽기

for (int i = 0; i < depth; i++) {

data[i] = new int[Width];

st = new StringTokenizer(br.readLine());

for (int j = 0; j < Width; j++) {

data[i][j] = Integer.parseInt(st.nextToken());

}

}

Result = -1;

if (isOkay()) { // 원형 그대로 두어도 Okay

Result = 0;

}

for (int i = 1; i <= knum; i++) { // i개의 행에 약물 주입

if (Result >= 0) {

break; // 찾았으면 종료

}

visitingList = new ArrayList<>(); // 중복검색 방지

possibleList = new ArrayList<Integer>(); // 1이 i개인 이진수 탐색

int con_i = i > Width / 2 ? Width - i : i;

Converse = i > Width / 2;

findPossible(con_i, 0); // 1이 i개인 이진수 탐색

for (int j = 0; j < possibleList.size(); j++) {

log(Integer.toBinaryString(possibleList.get(j)));

Result = inputMedi(possibleList.get(j)); // (약물 주입) 행들의 집합을 넘긴다.

if (Result > 0) {

break; // 찾았으면 종료

}

}

}

System.out.println(String.format("#%d %d", T, Result));

}

}

static ArrayList<Integer> possibleList;

static ArrayList<Integer> visitingList;

// width개 중 i개를 선택한다.

private static void findPossible(int i, int bitinfo) {

if (bitinfo >= (1 << depth + 1)) {

return;

}

int count = 0;

for (int j = 0; j < depth; j++) {

if ((bitinfo & (1 << j)) > 0) {

count++;

if (count == i) {

log(Integer.toBinaryString(bitinfo));

possibleList.add(bitinfo);

return;

}

}

}

for (int j = 0; j < depth; j++) {

if ((bitinfo & (1 << j)) > 0) {

continue;

}

int next_bitinfo = bitinfo + (1 << j);

if (visitingList.contains(next_bitinfo)) {

continue;

}

visitingList.add(next_bitinfo);

findPossible(i, next_bitinfo);

}

}

public static int inputMedi(int selbit) {

ArrayList<Integer> pocket = new ArrayList<Integer>();

// 사용되는 열 추출

int con_selbit = selbit;

if (Converse) {

con_selbit = 0;

for (int i = 0; i < Width; i++) {

if ((selbit & (1 << i)) == 0) {

con_selbit += (1 << i);

}

}

}

for (int i = 0; i < Width; i++) {

if ((con_selbit & (1 << i)) > 0) {

pocket.add(i);

}

}

// boolean isFound;

int size = pocket.size();

// 1,0의 적용의 경우의 수

for (int i = 0; i < 1 << size; i++) {

// log(Integer.toBinaryString(i));

if (isOkay(i, pocket)) {

return pocket.size();

}

}

return -1;

}

private static boolean isOkay(int bitmask, ArrayList<Integer> pocket) {

int depth = data.length;

int width = data[0].length;

int a_count;

int b_count;

for (int i = 0; i < width; i++) {

a_count = b_count = 0;

int atom;

for (int j = 0; j < depth; j++) { // 한 열을 검사

atom = data[j][i];

if (pocket.indexOf(j) >= 0) {

boolean isOne = (bitmask & (1 << pocket.indexOf(j))) > 0;

atom = isOne ? 1 : 0;

}

if (atom == 1) {

if (b_count != 0) {

a_count = b_count = 0;

}

a_count++;

} else {

if (a_count != 0) {

a_count = b_count = 0;

}

b_count++;

}

if (a_count == knum || b_count == knum) {

break;

}

if (j == depth - 1) {

return false;

}

}

}

log(Integer.toBinaryString(bitmask) + pocket.toString());

return true;

}

private static boolean isOkay() {

int depth = data.length;

int width = data[0].length;

int a_count;

int b_count;

for (int i = 0; i < width; i++) {

a_count = b_count = 0;

for (int j = 0; j < depth; j++) { // 한 열을 검사

if (data[j][i] == 1) {

if (b_count != 0) {

a_count = b_count = 0;

}

a_count++;

} else {

if (a_count != 0) {

a_count = b_count = 0;

}

b_count++;

}

if (a_count == knum || b_count == knum) {

break;

}

if (j == depth - 1) {

return false;

}

}

}

return true;

}

private static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

}