1.    F1 : 선택된 항목에 대한 비주얼 베이직 도움말 보기
2.    F2 : 개체 찾아보기
3.    F3 : 다음 찾기
4.    F5 : 컴파일하기
5.    Crtl+F5 : 전체 컴파일한 후 다시 시작하기
6.    Crtl+F : 찾아보기 (Find)
7.    Crtl+H : 바꾸기
8.    Crtl+I : 변수등의 요약 정보
9.    Crtl+J : 속성과 메소드 목록보기
10.    Crtl+Z : 실행 취소
11.    Crtl+DEL : 한 단어만 지우기
12.    Crtl+오른쪽 화살표 : 한 단어만큼 오른쪽으로 이동
13.    Crtl+왼쪽 화살표 : 한 단어만큼 왼쪽으로 이동
14.    Crtl+Home : 해당 모듈의 처음으로 이동
15.    Crtl+End : 해당 모듈의 끝으로 이동
16.    Crtl+아래쪽 화살표 : 다음 프로시저의 첫번째 줄로 이동
17.    Crtl+위쪽 화살표 : 이전 프로시저의 첫번째 줄로 이동
18.    Crtl+Page Up : 이전 프로시저 선언으로 가기
19.    Crtl+Page down : 다음 프로시저 선언으로 가기
20.    Crtl+스페이스바 : 나머지 단어 채우기
21.    Shift+F2 : 프로시저 정의 보기
22.    Shift+F3 : 이전 찾기
23.    Shift+F10 : 오른쪽 마우스 버튼 클릭한것과 동일한 효과
24.    Shift+Tab : 선택된 부분의 들여쓰기 해제
25.    Shift+오른쪽 화살표 : 오른쪽으로 한 단어 더 선택하기
26.    Shift+왼쪽 화살표 : 왼쪽으로 선택된 한 단어 해제하기
27.    Shift+아래쪽 화살표 : 위로 한 줄 더 선택하기/지우기
28.    Ctrl+Shift+F2 : 가장 마지막으로 가기
29.    Ctrl+Shift+J : 상수 열거
30.    Ctrl+Shift+I : 인수 정보 보기

  1. Shift + F2        : 선언된 함수, 변수로 이동하기
  2. Shift + Ctrl + F2 : Shift + F2 로 가서 되돌아오기
  3. F8                : 한문장씩 실행하기(중지모드에서 사용)
  4. Shift + F8        : 어떤 문장이 사용자 정의 함수를 호출할시
                         F8키는 함수안으로 들어가지만, Shift + F8 키는
                         함수를 모두 실행하고 다음 문장으로 이동합니다.
                         (중지모드에서 사용)
  5. Ctrl + F9         : 노란색선을 원하는 위치로 이동하기
                         중지모드에서 현재 실행중인 코드가 노란색으로
                         나타납니다. 마우스나 키보드로 특정문장으로
                         커서를 이동 시킨뒤 Ctrl + F9키를 누르면 
                         여기부터 다시 실행할 수 있습니다.
  6. Ctrl + SpaceBar   : 단어채우기
                         코딩중 긴함수나 긴변수를 일일히 쓰는건 아주
                         짜증나는 일입니다. 만약 변수명이 mintRecordCount
                         일 경우 mintR 한다음에 Ctrl + SpaceBar를
                         누르면 단어가 자동으로 채워 집니다. 
                         (중복 단어가 있으면 골라서 사용할 수 있습니다.)
  7. 꽁수(....^^)
     만약 어떤 이벤트를 테스트할 목적으로 디버깅 하려면 여러분들은
     보통 어떤식으로 하십니까?... 아마 그 이벤트에 F9키를 눌러서
     중단점을 잡아 놓고서 F5키를 눌러서 실행 할 것입니다.
     그런데 중단점을 잡아 놓지 않고, 할수 있는 방법이 있는데 그 방법을
     설명해 드리겠습니다...

     먼저 실행도중에 Ctrl + Break키를 눌러서 중지모드 상태로 들어갑니다.
     다음에 F8키를 누르고, 어떤 이벤트(버튼클릭 또는 키보드 입력 ....)를 
     발생시키면 디버깅 상태로 들어갈 것입니다.(전재조건 : 발생시킨 이벤트 
     안에는 반드시 코드가 있어야겠죠...)

단축키(ShortCut Key) 설명 
   CTRL+C              선택영역 복사하기  
   CTRL+X              선택영역 잘라내기 
   CTRL+Y              현재줄 잘라내기  
   CTRL+V              붙여넣기  
   CTRL+DELETE         문장단위로 지우기 
   TAB                 선택영역 한번에 내여쓰기  
   SHIFT+TAB           선택영역 한번에 들여쓰기  
   CTRL+Z              되돌리기(실행취소)  
   CTRL+RIGHT ARROW    다음 단어로 이동  
   CTRL+LEFT ARROW     이전 단어로 이동  
   CTRL+DOWN ARROW     다음 프로시져로 이동  
   CTRL+UP ARROW       이전 프로시져로 이동 
   SHIFT+F2            정의 보기  
   CTRL+F              찾기  
   CTRL+H              바꾸기  
   CTRL+S              저장하기  
   F7                  코드창으로 이동하기 
   F4                  속성창으로 이동하기  
   CTRL+R              프로젝트 탐색기로 이동하기  
   F5                  실행  
   F8                  한 단계씩 코드 실행

교환국을 통해 불특정 다수의 가입자들에게 음성 전화나 자료 교환 서비스를 제공한다. 이를 이용하여 자료 전송을 하려는 경우에는 모뎀을 사용하여야 한다. 우리나라에는 약 1,800만 이상의 전화 가입자가 접속되어 있으며 어느 전화기에서도 상대방 전화번호를 누르면 15초 이내에 1,800만여 개 번호 중에서 오직 다이얼한 그 번호를 정확하게 골라 접속할 수 있도록 되어 있다.

각 가정(또는 사무실)의 전화기는 가입자 선을 통하여 전화국의 교환기에 접속되어 있는데 가입자 선을 수용하는 이 교환기를 지역교환기(LS:Local Switch, 가입자 선 교환기라고도 함)라고 한다. LS가 설치되어 있는 전화국은 보통 가입자를 수용하기 편리하도록 그 구역의 중심에 자리잡고 있으며, 수km 내지 십수km 간격으로 설치되어 있다.

교환기는 작은 스위치의 집합으로, 다이얼한 번호를 따라 차례로 스위치를 닫아서 전화를 걸고자 하는 상대방의 가입자 선에 접속하게 해준다. 상대방이 같은 구역 내에 거주하고 있으면 같은 LS 내에서 쉽게 접속될 수 있지만, 다른 구역에 있을 경우에는 그 구역의 LS까지 전송로를 연결시키지 않으면 안 된다. 그래서 시외전화일 때는 경로가 훨씬 복잡해진다. 다이얼 숫자를 보고 시외전화임을 식별하게 되면 LS는 시외전화국의 교환기를 선택하여 접속하고, 여기서 상대방의 구역에 접속하는 구조로 되어 있다. 

가입자와는 직접 접속하지 않고 교환기와 교환기를 중계하는 기능을 가진 교환기는 시외 교환기 또는 시외 중계교환기라고 부른다. 전화국과 전화국 사이를 연결하는 전송로는 국간 전송로라고 하며, 전송로 매체로는 동축케이블, 마이크로웨이브 무선, 그리고 광섬유 케이블 등이 사용된다.

Wave 파일 압축 코덱 비교

오디오 압축 관리

PCM, GSM, ADPCM, CELP, SBC, TrueSpeech, 및 MPEG Layer-3 등의 오디오 압축 관리자를 사용하여 ".wav" 및 ".dct"에 사용할 수 있는 다양한 wave 압축 코덱의 오디오 품질과 압축 비트 레이트의 목록입니다. 참고: 오디오 압축 관리자 (ACM)는 .wav (wave) 또는 .dct (dictation) 파일로 녹음할 때 사용됩니다. 기타 포맷에 대해서는 사운드 파일 포맷 페이지를 참조하십시오.

ACM을 사용하는 제품:

• WavePad - 사운드 편집 소프트웨어
• Express Dictate - 구술 녹음기
• Switch - 오디오 파일 포맷 변환기
• Pocket Dictate - Pocket PC 버전 음성 레코더
• AudioTime - 프로그램 가능한 레코더 및 플레이어
• VRS 레코딩 소프트웨어
• MSRS 법정 및 회의 레코더
• RecordPad 사운드 리코더 소프트웨어
• SoundTap 스트리밍 오디오 레코더
• 및 많은 다른 음향 관련 프로그램

이 페이지에 기재되어 있는 오디오 파일의 압축 형식은 낮은 비트레이트 오디오 형식입니다. 높은 비트레이트의 음악 및 방송 음성 포맷은 표시되지 않았습니다.

각각의 오디오 형식의 샘플을 청취하려면, "견본" 링크를 클릭하십시오.

댓글

위에 열거한 것들은 wave 파일들입니다 - mp3 코덱을 포함하더라도 ".wav" 또는 ".dct" 확장자가 붙습니다. 다른 파일 포맷의 개요에 대해서는, 사운드 파일 포맷 페이지를 참조하십시오.

추천 코덱

현재 NCH 소프트웨어는 음성 녹음의 경우에 GSM6.10 8000Hz를 권장하고 있습니다.

형식 문제

Windows 2000/XP에 포함된 "마이크로 소프트 G.723.1"는 ACM 코덱에 버그가 있기 때문에 인코딩 / 리코딩에 사용할 수 없습니다. 이 포맷은 사용하지 마십시오.

토론 포럼

ACM 코덱에 대한 질문이나 또는 관심이 있다면, 사운드 포맷 토론 포럼을 참조하십시오.

ACM을 지원하는 소프트웨어

많은 NCH 소프트웨어 전문 오디오 소프트웨어 응용 프로그램은 오디오 압축 관리자를 포함하고 있습니다:

• VRS 여러 채널 레코더
• Express Dictate - 컴퓨터 딕터폰
• MSRS 법정 및 회의 레코더
• DialDictate - 전화 구술
• Express Scribe -페달 전사 플레이어
• IVM 음성 메일 접수
• Pocket Dictate - Pocket PC 용 받아쓰기 레코더
• WavePad - 사운드 편집 소프트웨어
• Switch - 사운드 파일 형식 변환기

mysql transaction

트랜잭션을 알아보기 이전에 먼저 엔진을 확인해야 합니다.

MySQL에는 많은 엔진이 있지만 대표적으로 InnoDB와 MyISAM을 사용하고 있는데요

InnoDB인 경우에만 트랜잭션을 사용할 수 있습니다

트랜잭션이란 쉽게 설명해드리면 은행 입출금을 생각해볼 수 있습니다

A라는 사람이 B한데 10만원을 송금하는 과정에서 A계좌에서 -10만원을 하고 B계좌에 +10만원하는 과정에서 오류가 나면 A계좌에만 10만원이 빠져있는 현상이 발생하겠죠

그래서 필요한게 트랜잭션입니다

트랜잭션은 여러 단계의 처리를 하나의 처리처럼 다루는 기능입니다.

트랜잭션의 실행 결과를 데이터베이스에 반영하는것을 커밋(commit), 다시 이전으로 되돌리는 것을 롤백(rollback)이라고 합니다

트랜잭션 시작하기

> START TRANSACTION;

> A 계좌에 -10만원

> B 계좌에 +10만원

> COMMIT

결과 : A계좌에 10만원이 빠져나가있고 B계좌에 10만원이 들어와있음

> START TRANSACTION;

> A 계좌에 -10만원

> B 계좌에 +10만원

> ROLLBACK

결과 : A,B계좌 금액 변동 없음

트랜잭션은 기본적으로 자동커밋을 사용하고 있습니다.

이를 OFF로 하기 위해서는

> set autocommit=0;

을 실행하면 됩니다.

만약에 데이터베이스를 여럿이서 공유하고 있다면 set autocommit을 수행하면 다른 사람들에게는 꼭 알려줘야겠죠?

그래서 데이터베이스에서 직접 바꾸는 것이 아닌 코드상에서 자동커밋을 막고 하는걸 권해드립니다

단, 아래의 쿼리는 트랜잭션을 지원하지 않으니 주의해주세요

* DROP DATABASE

* DROP TABLE

* DROP

* ALTER TABLE

해당 페이지에 가면 다른 사용법을 터득할 수 있다.

https://www.jetbrains.com/datagrip/whatsnew/#executing-queries

DataGrip now prompts you to choose a database/schema along with a data source when you try to run an SQL file from the context menu.

A similar enhancement: the list of data sources with related consoles will appear when attaching the console to a file.

G.711

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Stack;

import java.util.StringTokenizer;

class Point {

int y, x;

public Point(int y, int x) {

this.y = y;

this.x = x;

}

}

class Process {

int y, x;

public Process(int y, int x) {

this.y = y;

this.x = x;

}

HashSet<Point> moveSet = new HashSet();

public boolean on(int rIndex) {

// 해당 방향으로 전선을 잇는다.

int nextY = y;

int nextX = x;

int endIndex = Solution.MapSize - 1;

while (true) {

nextY += Solution.rotY[rIndex];

nextX += Solution.rotX[rIndex];

if (isRight(nextY, nextX)) {

// 경로기록

moveSet.add(new Point(nextY, nextX));

//경계지점에 도달

if (nextX == 0 || nextY == 0 || nextX == endIndex || nextY == endIndex) {

// 전선연결

for (Point item : moveSet) {

Solution.Visited[item.y][item.x] = 1;

}

return true;

}

} else {

// 경로 삭제

moveSet.clear();

return false;

}

}

}

public boolean isRight(int y, int x) {

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

// 배열범위

return false;

} else if (Solution.Visited[y][x] != 0) {

// 해당구획

return false;

}

return true;

}

public void off() {

// 전선을 제거한다.

for (Point item : moveSet) {

Solution.Visited[item.y][item.x] = 0;

}

moveSet.clear();

}

}

class Solution {

static boolean Debug = true;

private static int T;

static int MapSize;

static int[][] Visited; // 시간정보

private static ArrayList<Process> pList;

private static int processLen;

private static int[] checkMin;

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

BufferedReader br;

if (Debug) {

File f = new File("C:\\Users\\wvimi\\Downloads", "sample_input (14).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 = Integer.parseInt(br.readLine());

// 프로세스 리스트

pList = new ArrayList<>();

Visited = new int[MapSize][];

// Map 읽기

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++) {

int item = Integer.parseInt(st.nextToken());

// 맵, Visited 초기화

Visited[i][j] = item == 1 ? 2 : item; // 0:빈공간, 1:방문, 2:프로세스

// 프로세스 등록

if (item == 1) {

boolean inner = i != 0 && j != 0 && i != MapSize - 1 && j != MapSize - 1;

if (inner) {

// 관리 프로세스에 등록

pList.add(new Process(i, j));

}

}

}

}

offProcLen = Integer.MAX_VALUE;

processLen = pList.size();

checkMin = new int[13];

// 최대 값을 저장할 배열

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

checkMin[i] = Integer.MAX_VALUE;

}

// 탐색

findPath(0, 0);

// 결과 출력

for (int i = 11; i >= 0; i--) {

// 성공한 길이를 탐색

if (checkMin[i] != Integer.MAX_VALUE) {

System.out.println(String.format("#%d %d", T, checkMin[i]));

break;

}

// 그 어떤 전선도 없는 경우

if (i == 0) {

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

}

}

}

}

static int offProcLen; // 도달한 0의 개수 (브레이크 조건으로 활용)

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

private static void findPath(int index, int bitmask) {

// 끝지점에 도달

if (index == processLen) {

// 0을 몇 번 썼는지 체크

int count_one = countOne(bitmask);

int offLen = processLen - count_one;

if (offProcLen > offLen) {

offProcLen = offLen;

}

// 전선의 길이

int length = 0;

for (Process process : pList) {

length += process.moveSet.size();

}

// 프로세스 개수 별로 최대 개수를 달리한다.

if (checkMin[count_one] > length) {

checkMin[count_one] = length;

}

return;

}

Process item = pList.get(index);

// 프로세스에 전선을 잇는 경우

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

// 연결이 가능한 경우에만 탐색

int nextBitmask = bitmask + (1 << index);

// 최대 끌 수 있는 프로세스를 고려 (1개까지 꺼서 성공했으면, 2개는 허용 못함)

if (index + 1 - countOne(nextBitmask) <= offProcLen)

if (item.on(i)) {

// debStack.add(i + 1);

findPath(index + 1, nextBitmask);

item.off();

// debStack.pop();

}

}

// 프로세스에 전선을 잇지 않는 경우

// debStack.add(0);

findPath(index + 1, bitmask);

// debStack.pop();

}

static void printMap() {

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

String temp = "";

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

temp += Visited[i][j];

}

log(temp);

}

}

private static int countOne(int bitmask) {

int count = 0;

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

if ((bitmask & (1 << i)) != 0) {

count++;

} else {

}

}

return count;

}

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

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

public static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

public 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.HashSet;

import java.util.StringTokenizer;

public class Main {

private static boolean Debug = true;

private static int PrimeCount;

static int[] pocket;

static HashSet<String> primeSet;

private static int NumberLen;

private static int T;

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

BufferedReader br;

if (Debug) {

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

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

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

}

StringTokenizer st;

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

for (T = 0; T < TestLen; T++) {

String NumberStr = br.readLine();

NumberLen = NumberStr.length();

pocket = new int[NumberLen];

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

pocket[i] = NumberStr.charAt(i) - '0';

}

// 탐색 리스트 초기화

primeSet = new HashSet();

findPath(0, "");

primeSet.remove("");

PrimeCount = 0;

for (String item : primeSet) {

// 소수라면 PrimeCount++

isPrime(Integer.parseInt(item));

}

// 소수의 개수 출력

System.out.println(PrimeCount);

}

}

// 소수 판별

private static boolean isPrime(int num) {

// 2 ~ 제곱근까지 검색

int end = (int) Math.sqrt(num);

for (int i = 2; i <= end; i++) {

if (num % i == 0) {

return false;

}

}

// 2보다 작으면 안되!

if (num < 2) {

return false;

}

PrimeCount++;

return true;

}

private static void findPath(int check, String input) {

// 중복되는 경우는 제거

if (primeSet.contains(input)) {

return;

} else {

primeSet.add(input);

}

// 0인 비트를 골라 1로 채운뒤, 문자열을 조립한다.

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

int using = 1 << i;

// 시작은 0을 제외한다.

if (check == 0 && pocket[i] == 0) {

continue;

}

if ((check & using) == 0) {

findPath(check + using, input + pocket[i]);

}

}

}

public static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

public 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.HashMap;

import java.util.Map.Entry;

import java.util.StringTokenizer;

class Block {

HashMap<Integer, int[][]> shapeList;

int[][] origin;

int[] flag;

ArrayList<Integer> fList;

// 블록에 해당하는 모양 Data를 만들어줍니다.

public Block(int[][] data, int[] flag) {

this.origin = data;

this.flag = flag;

fList = new ArrayList<>();

for (int item : flag) {

fList.add(item);

}

shapeList = new HashMap<>();

createShape();

// printAllShape();

}

// 회전과 대칭에 따른 데이터(모양) 생성

private void createShape() {

int[][] temp = origin;

// 0번 모양

shapeList.put(0, origin);

// 1~3번 모양(90, 180, 270)

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

temp = rotate(temp);

if (fList.contains(i)) {

shapeList.put(i, temp);

}

}

// 4번 모양

int[][] rev = null;

if (fList.contains(4)) {

rev = reverse(origin);

shapeList.put(4, rev);

}

temp = rev;

// 5~7번 모양 rev + (90, 180, 270)

if (fList.contains(5)) {

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

temp = rotate(temp);

shapeList.put(i, temp);

}

}

}

// 디버깅을 위한 출력

public void printAllShape() {

int[][] shape;

int ysize, xsize;

for (Entry<Integer, int[][]> entry : shapeList.entrySet()) {

shape = entry.getValue();

ysize = shape.length;

xsize = shape[0].length;

Main.log("[%d]", entry.getKey());

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

String line = "";

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

line += String.format("%d ", shape[i][j]);

}

Main.log(line);

}

}

}

// 회전 유틸

private int[][] rotate(int[][] data) {

int ysize = data.length;

int xsize = data[0].length;

int end_index = ysize - 1;

int[][] rData = new int[xsize][];

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

rData[i] = new int[ysize];

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

rData[i][j] = data[end_index - j][i];

}

}

return rData;

}

// 대칭 유틸

private int[][] reverse(int[][] data) {

int ysize = data.length;

int xsize = data[0].length;

int end_index = xsize - 1;

int[][] rData = new int[ysize][];

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

rData[i] = new int[xsize];

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

rData[i][j] = data[i][end_index - j];

}

}

return rData;

}

}

public class Main {

private static int MapSize_Y;

private static int MapSize_X;

static int[][] Map;

static private ArrayList<Block> bList;

private static boolean Debug = true;

private static int MaxSum;

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

BufferedReader br;

if (Debug) {

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

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

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

}

StringTokenizer st;

// 맵 크기

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

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

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

// 맵 데이터 입력

Map = new int[MapSize_Y][];

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

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

Map[i] = new int[MapSize_X];

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

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

}

}

// 블록을 담을 리스트

bList = new ArrayList<>();

Block item; // 블록에는 모양 값들이 저장 된다.

// 블록 모양, 필요한 모양 값 (0: 원형, 1~3: 회전, 4: 대칭, 5~7: 대칭 후 회전)

int[][] 네모Shape = { { 1, 1 }, { 1, 1 } };

item = new Block(네모Shape, new int[] { 0 });

bList.add(item);

int[][] 일자Shape = { { 1, 1, 1, 1 } };

item = new Block(일자Shape, new int[] { 0, 1 });

bList.add(item);

int[][] 산Shape = { { 1, 1, 1 }, { 0, 1, 0 } };

item = new Block(산Shape, new int[] { 0, 1, 2, 3 });

bList.add(item);

int[][] 기역Shape = { { 1, 0 }, { 1, 0 }, { 1, 1 } };

item = new Block(기역Shape, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });

bList.add(item);

int[][] 어긋Shape = { { 1, 0 }, { 1, 1 }, { 0, 1 } };

item = new Block(어긋Shape, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });

bList.add(item);

// 완전탐색

MaxSum = -1;

dfs();

// 시간 출력

System.out.println(MaxSum);

}

public static void dfs() {

int blockLen = bList.size();

// 모든 블록에 대한 경우

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

Block block = bList.get(i);

// 각 블록에 따른 데이터를 가져온다. (대칭 및 회전이 포함된 데이터)

for (Entry<Integer, int[][]> item : block.shapeList.entrySet()) {

int[][] data = item.getValue();

int ysize = data.length, xsize = data[0].length;

// 탐색범위 지정(드레그)

int endy, endx;

endy = MapSize_Y - ysize;

endx = MapSize_X - xsize;

// 지정된 탐색 범위에서, data에 맞도록 검색

search(endy, endx, data);

}

}

}

// 해당 블록 모양을 가지고, 해당 위치에서 검색을 해봅니다.

public static void search(int endy, int endx, int[][] data) {

// 탐색 사이즈

int yszie = data.length, xsize = data[0].length;

// 탐색 구간은 (0,0) ~ (endy, endx) 드레그

for (int y = 0; y <= endy; y++) {

for (int x = 0; x <= endx; x++) {

// Block 모양에 따른 탐색

int sum = 0;

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

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

if (data[i][j] == 1) { // 탐색

sum += Map[y + i][x + j];

}

}

}

// 최대값 판별

if (MaxSum < sum) {

MaxSum = sum;

}

}

}

// log("합: " + sum);

}

public static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

public 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.Stack;

import java.util.StringTokenizer;

class Ball {

int y, x;

static int MapSize_Y;

static int MapSize_X;

static int holeY;

static int holeX;

public Ball(int y, int x) {

this.y = y;

this.x = x;

Main.Map[y][x] = 'X'; // 공의 위치 표기

}

public void move(int rIndex) {

int tempY = y;

int tempX = x;

int moveY = y + Main.rotY[rIndex];

int moveX = x + Main.rotX[rIndex];

// 한 방향으로 직진

while (isRight(moveY, moveX)) {

// 성공좌표를 저장 한다.

y = moveY;

x = moveX;

// 전진

moveY += Main.rotY[rIndex];

moveX += Main.rotX[rIndex];

}

// 공의 위치를 변경한다.

Main.Map[tempY][tempX] = '.';

Main.Map[y][x] = isHoll() ? 'O' : 'X';

}

public void move(int inputY, int inputX) {

Main.Map[this.y][this.x] = isHoll() ? 'O' : '.';

this.y = inputY;

this.x = inputX;

Main.Map[this.y][this.x] = isHoll() ? 'O' : 'X';

}

public boolean isRight(int inputY, int inputX) {

if (inputY < 0 || inputX < 0 || inputY >= MapSize_Y || inputX >= MapSize_X) {

// 배열 밖이라면 No

return false;

} else if (isHoll()) {

// 구멍에 있다면 No

return false;

} else if (Main.Map[inputY][inputX] == 'O') {

// 구멍으로 간다면 Yes

return true;

}

// 빈칸이라면 Yes

return Main.Map[inputY][inputX] == '.';

}

public int getXY() {

return y * MapSize_X + x;

}

public boolean isHoll() {

return Ball.holeX == x && Ball.holeY == y;

}

}

public class Main {

private static boolean Debug = true;

private static final int left = 3, right = 1, up = 0, down = 2;

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

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

private static int MapSize_Y;

private static int MapSize_X;

static char[][] Map;

private static int minFindRed;

static Ball rBall;

private static Ball bBall;

private static int[][] Visited;

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

BufferedReader br;

if (Debug) {

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

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

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

}

StringTokenizer st;

// 맵 크기, 사과 개수

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

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

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

Ball.MapSize_Y = MapSize_Y;

Ball.MapSize_X = MapSize_X;

// 맵 생성

Map = new char[MapSize_Y][];

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

Map[i] = new char[MapSize_X];

String input = br.readLine();

char item;

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

// 맵에 기록, Ball 객체 생성

item = input.charAt(j);

switch (item) {

case 'B':

bBall = new Ball(i, j);

Map[i][j] = 'X';

break;

case 'R':

rBall = new Ball(i, j);

Map[i][j] = 'X';

break;

case 'O':

Ball.holeY = i;

Ball.holeX = j;

Map[i][j] = 'O';

break;

default:

Map[i][j] = item;

break;

}

}

}

// 방문배열 생성 [rBall.getXY()][bBall.getXY()]

int vSize = MapSize_X * MapSize_Y;

Visited = new int[vSize][];

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

Visited[i] = new int[vSize];

}

minFindRed = Integer.MAX_VALUE;

// 프레임 체크 (첫 번째 순간은 중복되지 않는다.)

Visited[rBall.getXY()][bBall.getXY()] = 1;

// printMap();

tiltBoard(0);

// 시간 출력

System.out.println(minFindRed == Integer.MAX_VALUE ? -1 : minFindRed);

}

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

private static void tiltBoard(int index) {

if (minFindRed <= index) {

// log("탐색불필요 " + debStack);

return;

} else if (bBall.isHoll()) {

// log("[블루볼] " + debStack);

return;

}

// 1.레드볼 여부 && 2. index == 10

if (rBall.isHoll()) { // && !bBall.isHoll() // 위에서 이미 체크

if (minFindRed > index) {

minFindRed = index;

}

// log("[레드볼]" + debStack.toString());

return;

} else if (index == 10) {

// log("[index 10] " + debStack);

return;

}

int redY = rBall.y;

int redX = rBall.x;

int blueY = bBall.y;

int blueX = bBall.x;

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

// 1. 공을 움직인다.

switch (i) {

case left:

if (redX < blueX) {

rBall.move(i);

bBall.move(i);

} else {

bBall.move(i);

rBall.move(i);

}

break;

case right:

if (redX > blueX) {

rBall.move(i);

bBall.move(i);

} else {

bBall.move(i);

rBall.move(i);

}

break;

case up:

if (redY < blueY) {

rBall.move(i);

bBall.move(i);

} else {

bBall.move(i);

rBall.move(i);

}

break;

case down:

if (redY > blueY) {

rBall.move(i);

bBall.move(i);

} else {

bBall.move(i);

rBall.move(i);

}

break;

}

// 2. 가능한 위치로 이동하여 탐색한다. (좌표 정보는 Ball 객체에 담겨있다.)

// 모두 제자리에 있으면, 탐색X

// 실행됬던 프레임이라면, 탐색X

if (rBall.x == redX && rBall.y == redY && bBall.x == blueX && bBall.y == blueY) {

// non-target

} else if (Visited[rBall.getXY()][bBall.getXY()] == 0) {

Visited[rBall.getXY()][bBall.getXY()] = 1;

// debStack.push(i);

// printMap();

tiltBoard(index + 1);

Visited[rBall.getXY()][bBall.getXY()] = 0;

// debStack.pop();

}

// 3. 공을 원위치로 시킨다.

rBall.move(redY, redX);

bBall.move(blueY, blueX);

}

}

// 디버깅용 프린트 맵

private static void printMap() {

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

String temp = "";

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

temp += Map[i][j];

}

if (i == 0) {

temp += "시작";

}

log(temp);

}

}

public static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

public 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.LinkedList;

import java.util.Queue;

import java.util.StringTokenizer;

public class Main {

private static boolean Debug = true;

private static int MapSize;

private static int[][] OriginMap;

private static int[][] CopyMap;

private static Queue<Integer>[] bQueue;

static int MaxNum = 0;

final static int north = 0, east = 1, south = 2, west = 3;

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

BufferedReader br;

if (Debug) {

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

FileReader reader = new FileReader(f);

br = new BufferedReader(reader);

} else {

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

}

StringTokenizer st;

// 맵 크기, 사과 개수

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

MaxNum = 0;

// 맵 생성

OriginMap = new int[MapSize][];

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

OriginMap[i] = new int[MapSize];

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

int item;

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

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

OriginMap[i][j] = item;

// 합칠 수 없는 경우, 처음 주어진 수가 가장 크다.

if (MaxNum < item) {

MaxNum = item;

}

}

}

// 큐 초기화 (블록을 옮기는 데 사용된다.

bQueue = new LinkedList[MapSize];

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

bQueue[i] = new LinkedList<>();

}

// 00000 ~ 33333

int[] bitmasking = new int[5];

execute(bitmasking, 0);

// 시간 출력

System.out.println(MaxNum);

}

private static void execute(int[] bitmask, int index) {

// 비트마스킹을 조립

if (index <= 4) {

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

bitmask[index] = i;

execute(bitmask, index + 1);

}

return;

}

// 맵초기화

initMap();

// 실행

int rIndex;

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

rIndex = bitmask[i];

tiltMap(rIndex);

}

}

private static void initMap() {

// Merge를 위한 지도 초기화

CopyMap = new int[MapSize][];

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

CopyMap[i] = new int[MapSize];

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

int num = OriginMap[i][j];

if (num != 0) { // 0은 빈공간

CopyMap[i][j] = num;

} else {

// non-target

}

}

}

}

private static void tiltMap(int rIndex) {

// log("tiltMap(%d)", rIndex);

// 정방향|역방향

// 행기준|열기준

boolean good = (rIndex == west || rIndex == north);

boolean isRow = (rIndex == west || rIndex == east);

// 방향에 따른 병합 및 매칭

int j_start = (good ? 0 : MapSize - 1);

int j_end = (good ? MapSize : -1);

int j_add = (good ? 1 : -1);

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

// 1. 큐에 대입

int j = j_start;

while (j != j_end) {

// 행기준 열기준에 따라 값을 큐에 넣는다. 

int item = isRow ? CopyMap[i][j] : CopyMap[j][i];

if (item != 0) {

bQueue[i].add(item);

// 값을 옮기면, 해당 자리는 빈공간으로 체크

if (isRow) {

CopyMap[i][j] = 0;

} else {

CopyMap[j][i] = 0;

}

}

j += j_add;

}

// 2. 머지

bQueue[i] = mergeBlock(bQueue[i]);

// 3. 맵에 매칭

j = j_start;

while (j != j_end) {

if (!bQueue[i].isEmpty()) {

if (isRow) {

CopyMap[i][j] = bQueue[i].poll();

// log("큐 방출 [%d][%d] = %d", i, j, CopyMap[i][j].num);

} else {

CopyMap[j][i] = bQueue[i].poll();

// log("큐 대입 [%d][%d] = %d", j, i, CopyMap[j][i].num);

}

} else {

break;

}

j += j_add;

}

}

}

static Queue<Integer> rQue;

private static Queue<Integer> mergeBlock(Queue<Integer> que) {

// 반환을 위한 큐

rQue = new LinkedList<>();

// 합치고

int item1 = 0, item2 = 0;

while (true) {

// 합칠 대상1 픽업

if (item1 == 0) {

if (!que.isEmpty()) {

item1 = que.poll();

} else {

// 큐가 비었으므로

break;

}

}

// 합칠 대상2 픽업

if (item2 == 0) {

if (!que.isEmpty()) {

item2 = que.poll();

} else {

// 비교대상이 없으므로

rQue.add(item1);

break;

}

}

// item1과 item2를 합친다.

if (item1 == item2) {

int mergeNum = item1 * 2;

rQue.add(mergeNum);

// 최고값 측정

if (MaxNum < mergeNum) {

MaxNum = mergeNum;

}

item1 = 0;

item2 = 0;

} else { // 합칠수 없는 경우, 이전 비교대상은 rQue에 넣는다.

rQue.add(item1);

item1 = item2; // 다음비교 대상이 첫번 째가 된다.

item2 = 0;

}

}

return rQue;

}

public static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

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

if (Debug) {

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

}

}

}

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.Hashtable;

import java.util.LinkedList;

import java.util.Queue;

import java.util.StringTokenizer;

class Snake {

Queue<Integer> body = new LinkedList<>();

// 해당 위치로 움직인다.

void move(int where, boolean hasApple) {

if (hasApple) {

body.add(where);

} else {

body.poll();

body.add(where);

}

}

// 자기 자신에 충돌하는지 체크한다.

boolean isSelf(int where) {

return body.contains(where);

}

}

public class Main {

private static boolean Debug = false;

private static int MapSize;

private static int[][] Map;

private static Hashtable<Integer, Character> comMap;

private static Snake snake = new Snake();

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

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

StringTokenizer st;

// 맵 크기, 사과 개수

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

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

// 맵 생성

Map = new int[MapSize][];

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

Map[i] = new int[MapSize];

}

// 사과 위치 배정

int y, x;

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

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

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

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

Map[y][x] = 1;

}

// 커맨드 읽기

comMap = new Hashtable();

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

int time;

char direct;

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

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

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

direct = st.nextToken().charAt(0);

comMap.put(time, direct);

}

// 위치 초기화, 시간 초기화

y = x = 0;

rIndex = 1;

timer = 0;

// 뱀이 움직인다.

snake.move(0, false);

findPath();

// 시간 출력

System.out.println(timer);

}

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

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

static int y, x;

static int rIndex;

static int timer;

private static void findPath() {

// 해당 시간에 방향 전환이 발생하는가?

if (comMap.containsKey(timer)) {

char direct = comMap.get(timer);

// 왼쪽 회전 =>  rIndex--;  // 오른쪽 회전 => rIndex++;

if (direct == 'L') {

rIndex = rIndex == 0 ? 3 : rIndex - 1;

} else {

rIndex = rIndex == 3 ? 0 : rIndex + 1;

}

comMap.remove(timer);

}

// 움직임이 시작되는 순간

timer++;

// 움직이려는 방향이 맞다면 움직인다.

if (isVaild(rIndex)) {

y += rotY[rIndex];

x += rotX[rIndex];

int where = y * MapSize + x;

// 자신의 몸에 충돌하는가?

if (snake.isSelf(where)) {

return;

}

// 사과가 있다면

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

Map[y][x] = 0;

snake.move(where, true);

} else { // 사과가 없다면

snake.move(where, false);

}

findPath();

} else {

// 움직이는 방향이 맵 밖인 경우, 이탈한다.

return;

}

}

// 해당 방향이 맵의 범위를 초과하는지를 판단한다.

private static boolean isVaild(int index) {

switch (index) {

case 0:

return y - 1 >= 0;

case 2:

return y + 1 < MapSize;

case 1:

return x + 1 < MapSize;

case 3:

return x - 1 >= 0;

}

return false;

}

public static void log(String input) {

if (Debug) {

System.out.println(input);

}

}

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

if (Debug) {

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

}

}

}