개발생각

[Baekjoon][https://www.acmicpc.net/problem/10026]

그래프 문제 > DFS로 풀이

풀이)

 (1) 영역을 배열값에 저장 : map[n][n] 

 (2) DFS 탐색 메소드를 두개 생성 

     - 적록색약 DFS 탐색 : GetColorWeaknessDFS()

     - 그 외 DFS 탐색 : GetDFS

     // 방문 체크 배열도 각각 선언해서 체크한다. ( visit_for_color_weakness[n][n] / visit[n][n])

 (3) current_color 변수를 선언하여 현재 좌표의 색상을 저장하였고,

     해당 값이 다음 진행 방향이랑 같은지 체크해서 DFS 탐색 트리를 적용하였다.

 (4) 적록색약의 경우 아래 코드와 같이 분기 체크하여 다음 탐색 영역이 G,R 인 경우 같은 값으로 보도록 처리.

[ Java > Code ]

import java.io.ObjectInputStream.GetField;
import java.util.ArrayList;
import java.util.Scanner;

public class baekjoon_10026 {

	static int n;
	static char[][] map;
	static int[][] visit;
	static int[][] visit_for_color_weakness;
	
	static int[] xx = {-1, 0, 1, 0};
	static int[] yy = {0, 1, 0, -1};
	static char current_color;
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		
		n = sc.nextInt();
		map = new char[n][n];
		visit_for_color_weakness = new int[n][n];
		visit = new int[n][n];
		
		int weak_color_answer = 0;
		int color_answer = 0;

		for(int i=0;i<n;i++)
		{
			String str = sc.next();
			for(int j=0;j<n;j++)
			{
				map[i][j] = str.charAt(j);
			}
		}
		
		for(int i =0;i<n;i++) {
			for(int j=0;j<n;j++) {
				if(visit[i][j] == 0)
				{
					current_color = map[i][j];
					GetDFS(i, j);
					color_answer++;
				}
				
				if(visit_for_color_weakness[i][j] == 0)
				{
					current_color = map[i][j];
					GetColorWeaknessDFS(i, j);
					weak_color_answer++;
				}
			}
		}
		
		System.out.print(color_answer + " " + weak_color_answer);
	}

	// 적록색약 적용 DFS 탐색 (Red == Green)
	public static void GetColorWeaknessDFS(int x, int y)
	{
		visit_for_color_weakness[x][y] = 1;
		
		for(int i=0;i<4;i++)
		{
			int mx = x + xx[i];
			int my = y + yy[i];
			
			if(current_color == 'G' || current_color == 'R')
			{
				if(mx >= 0 && mx < n && my >= 0 && my < n && visit_for_color_weakness[mx][my] == 0 && (map[mx][my] == 'G' || map[mx][my] == 'R'))
				{
					GetColorWeaknessDFS(mx, my);
				}
			}
			else
			{
				if(mx >= 0 && mx < n && my >= 0 && my < n && visit_for_color_weakness[mx][my] == 0 && map[mx][my] == 'B')
				{
					GetColorWeaknessDFS(mx, my);
				}
			}			
		}
	}
	
	// 적록색약 아닌 경우 DFS 탐색
	public static void GetDFS(int x, int y)
	{
		visit[x][y] = 1;
		
		for(int i=0;i<4;i++)
		{
			int mx = x + xx[i];
			int my = y + yy[i];
			
			if(mx >= 0 && mx < n && my >= 0 && my < n && visit[mx][my] == 0 && map[mx][my] == current_color)
			{
				GetDFS(mx, my);
			}
		}
	}
}

[Baekjoon][https://www.acmicpc.net/problem/2667]

기본적인 DFS 그래프 문제

풀이)

  (1) 입력한 영역을 배열로 저장: map[n]

  (2) getDFS 메소드로 DFS 탐색 처리

       - visit[n][n] : 1인 구간은 탐색 완료 / 0 은 이동 가능

  (3) ←,↑,→,↓ 방향 순으로 체크하며 getDFS 내 재귀함수로 탐색 시, 연결되어 있는 단지로 파악하여

      연결 값 증가되도록 처리 (connected++)

  (4) main 메소드 내 > 호출하는 getDFS는 연결이 아닌 단지를 처음 발견 (map[n][n] == 1 && visit[n][n] == 0)

      이므로 connected 값 초기 화 및 총 단지 값(complex_cnt)을 +1 처리한다.

이번 알고리즘을 풀면서 다시 체크해야할 부분은 단지 정보를 입력하는 부분으로

map[n] : 1차 배열에 String ar = sc.nextLine() 으로 입력 받은 후, 

이를 toCharArray(); 메소드를 이용하여 배열로 처리되도록 처리하였다.

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class baekjoon_2667 {

	static int n;
	static int[][] map;
	static int[][] visit;
	static int complex_cnt = 0;
	static int connected = 0;
	static ArrayList<Integer> connected_complex; 
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		n = sc.nextInt();
		map = new int[n][n];
		visit = new int[n][n];
		connected_complex = new ArrayList<Integer>();
		
		sc.nextLine();
		
		for(int i =0;i<n;i++) {
			String ar = sc.nextLine();
			char[] visit = ar.toCharArray();
			
			for(int j=0;j<n;j++) {
				map[i][j] = (int)visit[j] - '0';
			}
		}
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<n;j++) {
				if(map[i][j] == 1 && visit[i][j] != 1) {
					getDFS(i, j);
					
					complex_cnt++;
					connected_complex.add(connected);
					connected = 0;
				}
			}
		}
		
		System.out.println(complex_cnt);
		Collections.sort(connected_complex);
		for(int i=0;i<connected_complex.size();i++) {
			System.out.println(connected_complex.get(i));
		}
	}
	
	public static void getDFS(int x, int y)
	{
		visit[x][y] = 1;
		connected++;
		
		int[] xx = {-1, 0, 1, 0};
		int[] yy = {0, 1, 0, -1};
		
		for(int i=0;i<4;i++)
		{
			int mx = x + xx[i];
			int my = y + yy[i];
			
			if(mx >= 0 && mx < n && my >= 0 && my < n && map[mx][my] == 1 && visit[mx][my] != 1) {
				getDFS(mx, my);
			}
		}
	}
}

[Baekjoon][https://www.acmicpc.net/problem/2583]

기본적인 그래프 문제

풀이)

  (1) 이미지와 같이 노출을 하기 위해 m을 y축 n을 x 축으로 받아서 처리 : 배열 map[n][m]로 선언

  (2) 칠해진 직사각형 내 좌표의 값은 DFS 처리 시 해당 영역을 접근하지 않게끔 값 : '1'로 선언

  (3) 2번 내용 처리 시 아래 이미지와 같이 체크된 직사각형 영역은 1 그렇지 않은 부분은 0 으로 처리된다.

   (4) DFS를 이용하여 이미 방문한 좌표와 (배열 visited[n][m] = 1) 과 좌표의 값이 1인 (map[n][m] = 1)

       부분을 제외하여 하나씩 값을 체크

map[n][m] : 배열로 직사각형 좌표 저장 // 1 : 빗줄 그어진 영역, 0 : 그 외

visited[n][m] : 이미 방문한 지역 저장 // 1 : 방문, 0 : 미방문

DFS 그래프로 <왼쪽, 위, 아래, 오른쪽 > 방향 이동

// int mx = x+xx[i]; int my = y+yy[i];

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {

   static int n;
   static int m;
   static int k;
   static int[][] map;
   static int[][] visited;
   static int space;
   static int space_cnt;
   
   public static void main(String[] args) {
      // TODO Auto-generated method stub
      Scanner sc = new Scanner(System.in);
      
      m = sc.nextInt(); // y축
      n = sc.nextInt(); // x축
      k = sc.nextInt(); // 개수
      map = new int[n][m];
      visited = new int[n][m];
      
      for(int i=0; i<k; i++) {
         int start_y = sc.nextInt();
         int start_x = sc.nextInt();
         int end_y = sc.nextInt();
         int end_x = sc.nextInt();
         
         SetVisited(start_y, start_x, end_y, end_x);
      }
      
      ArrayList<Integer> ar_space_cnt = new ArrayList<Integer>();
      
      for(int i=0;i<m;i++) {
         for(int j=0;j<n;j++) {
            if(map[j][i] == 0 && visited[j][i] == 0) {
               space++;
               GetDfs(j, i);
               ar_space_cnt.add(space_cnt);
               space_cnt = 0;
            }
         }
      }
      
      Collections.sort(ar_space_cnt);
      
      System.out.println(space);
      if(ar_space_cnt.size() == 0 ) System.out.println("0");
      for(int i=0;i<ar_space_cnt.size();i++) {
         System.out.print(ar_space_cnt.get(i) + " ");
      }
   }
   
   // map[][] 색칠된 영역 1로 설정
   public static void SetVisited(int start_y, int start_x, int end_y, int end_x) {
      for(int i=start_y;i<end_y;i++) {
         for(int j=start_x;j<end_x;j++) {
        	 map[i][j] = 1;
         }
      }
   }
   
   // DFS 로직 처리
   public static void GetDfs(int x, int y) {
      visited[x][y] = 1;
      space_cnt++;

      int[] xx = {-1, 0, 1, 0};
      int[] yy = {0, 1, 0, -1};
      
      for(int i=0; i<4; i++) {
         int mx = x+xx[i];
         int my = y+yy[i];
         
         if(mx >=0 && mx < n && my >= 0 && my < m && map[mx][my] == 0 && visited[mx][my] == 0) {
        	 GetDfs(mx, my);
         }
      }
   }
}

Cache

Cache

: 웹 서버측의 임시 메모리 공간이며, 

 서버의 효율을 위해 사용한다.

Output Cache (출력 캐시)

: 출력 캐시 같은 경우 임시 페이지를 잠시 저장해놓는 공간이며,

 한 페이지를 여러명이 접속 시 DB 접속 보다

 Cache 에 저장된 페이지를 조회해서 보여준다.

사용방법을 알아보면,

[ 사용 방법 ]

<%@ OutputCache Duration="30" VaryByParam="none" %>

코드 내에 선언

 - Duration="30" 30초 간격으로 페이지를 새로 호출을 의미

Ex ) 현재 오후 10시 24분 50초를 웹페이지에 출력 후 

새로고침을 해도 30초 동안 시간 변동이 없게 된다. 

왜냐하면, Duration을 30초로 설정했긴 때문으로 30초 후 부터

다시 코드를 실행.

-------------------------------- 31초 후  새로고침

- VaryByParam="none"

현재 none 으로 설정을 했지만 값을 입력하면 해당 문자열 파라미터에 따라

캐시가 초기화 됩니다.

Ex) VaryByParam="test"

 1) www.url?test=1

 2) www.url?test=2

1,2 번의 경로는 test 파라미터 값에 따라 캐시가 달라집니다.

Transaction Isolation Level

Mssql를 처음 사용하면서 SP(저장 프로시저) 라는 것을 처음 접했고, 어려움을 겪고 있네요! 후!

Isolation Level 이란 트랜잭션에서 일관성이 없는 데이터를 허용하도록 하는 수준

또한, 어떤 데이터를 수정하고 있는 경우 다른 사용자들이 해당 데이터에 접근하는 것을 차단 또는 읽기 작업을 수행할 수 있도록 

Isolation Level을 변경할 수 있다.

SET TRANSACTION ISOLATION LEVEL
{
READ COMMITTED
| READ UNCOMMITTED
| REPEATABLE READ
| SERIALIZABLE
}

- 네 종류의 Transaction Isolation Level 을 정리하면,

1. Read Uncommitted Isolation Level

 사용자가 'A' 라는 데이터를 'B' 라는 데이터로 변경 하는 동안 다른 사용자는 아직 완료되지 않은 데이터 'B'를 읽을 수 있다

 즉, 'Shared Lock' 이 걸리지 않는다.

2. Read Committed Isolation Level (SQL Server Default 값)

 사용자가 'A' 라는 데이터를 변경하는 동안 다른 사용자는 해당 데이터에 접근 할 수 없다.

 즉, 'Shared Lock'

3. Repeatable Read Isolation Level

 트랜잭션이 완료되는 동안 Select 문장이 사용하는 모든 데이터는 'Shared Lock' 상태 

 다른 사용자는 해당 영역에 해당되는 데이터 수정 불가능

4. Serializable Isolation Level

 트랜잭션이 완료되는 동안 Select 문장이 사용하는 모든 데이터는 'Shared Lock' 상태

 다른 사용자는 해당 영역에 해당되는 데이터 수정 및 입력 불가능

[출처 : https://support.microsoft.com/ko-kr/help/601430]