Classes More Than 5 Students

 문제 설명

Create table If Not Exists Courses (student varchar(255), class varchar(255))
Truncate table Courses
insert into Courses (student, class) values ('A', 'Math')
insert into Courses (student, class) values ('B', 'English')
insert into Courses (student, class) values ('C', 'Math')
insert into Courses (student, class) values ('D', 'Biology')
insert into Courses (student, class) values ('E', 'Math')
insert into Courses (student, class) values ('F', 'Computer')
insert into Courses (student, class) values ('G', 'Math')
insert into Courses (student, class) values ('H', 'Math')
insert into Courses (student, class) values ('I', 'Math')

Write an SQL query to report all the classes that have at least five students.

Return the result table in any order.

The query result format is in the following example.

5명 이상의 학생이 있는 클래스 쿼리 확인

 입출력 예

Example 1:

Input: 
Courses table:
+---------+----------+
| student | class    |
+---------+----------+
| A       | Math     |
| B       | English  |
| C       | Math     |
| D       | Biology  |
| E       | Math     |
| F       | Computer |
| G       | Math     |
| H       | Math     |
| I       | Math     |
+---------+----------+
Output: 
+---------+
| class   |
+---------+
| Math    |
+---------+
Explanation: 
- Math has 6 students, so we include it.
- English has 1 student, so we do not include it.
- Biology has 1 student, so we do not include it.
- Computer has 1 student, so we do not include it.

 Oracle Query

/* Write your PL/SQL query statement below */
select class 
from courses
group by class
having count(distinct student) > 4

* 참고 링크 : https://leetcode.com/problems/classes-more-than-5-students/discuss/927995/Oracle-Solution

• 5명 이상의 학생이 있는 class 쿼리— having절은 group by와 같이 사용될 수 있음having count(distinct student) > 4having절은 집계함수를 가지고 조건비교를 할 때 사용한다.
  • 참고 링크 : http://www.gurubee.net/lecture/1032
  집계함수 종류
  • count / sum / avg / max / min 등
  • 참고 링크 : https://life-with-coding.tistory.com/218
• distinct 중복값 처리 (5명 이상의 학생이 중복되는 경우를 having절로 카운트)
• (5명 이상의 학생이 있는 클래스를 찾는 것이니 class로 묶어줌
• group by class

 출처

https://leetcode.com/problems/classes-more-than-5-students/

실습 2일차_Setter Injection

의존성 주입의 방법으로는 크게 3가지가 있다.

• 생성자 주입(Constructor Injection)
• 필드 주입(Field Injection)
• 세터 주입(Setter Injection)

 Spring Setter Injection 1

MainClass.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.service.UserService;

public class MainClass {
	public static void main(String[] args) {
		
		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:com/config/user.xml");

		UserService service =
				ctx.getBean("service", UserService.class);
		System.out.println(service.getMesg());
	}
}

UserService.java

package com.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// POJO Class
public class UserService {

	String mesg; // null ==> 외부에서 문자열을 주입
	
	// setter 메서드 주입
	public void setMesg(String mesg) {
		System.out.println("setMesg 메서드");
		this.mesg = mesg;
	}
	
	public String getMesg() {
		return mesg;
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="service" class="com.service.UserService"> <!-- id는 식별 가능한 값, class는 클래스 입력 -->
		<property name="mesg" value="HelloWorld" />     <!-- System.out.println("setMesg 메서드"); property에 의해 출력 -->
	</bean>
	<!-- 다음 코드와 동일
		UserService service = new UserService();
		service.setMesg("HelloWorld");
	 -->
</beans>

* 출력 화면 

Spring Setter Injection 2

MainClass.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.service.UserService;

public class MainClass {

	public static void main(String[] args) {
		
		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:com/config/user.xml");

		UserService service =
				ctx.getBean("service", UserService.class);
		System.out.println(service.getMesg());
		System.out.println(service);
		
		UserService service2 =
				ctx.getBean("service2", UserService.class);
		System.out.println(service2.getMesg());
		System.out.println(service2);
		
		UserService service3 =
				ctx.getBean("service3", UserService.class);
		System.out.println(service3.getMesg());
		System.out.println(service3);
	}
}

UserService.java

package com.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// POJO Class
public class UserService {
	// property (인스턴스 변수)
	String mesg; // null ==> 외부에서 문자열을 주입
	int num; 	 // 0 ==> 외부에서 값을 주입
	
	// setter 메서드 주입
	public void setMesg(String mesg) {
		this.mesg = mesg;
	}
	
	public void setNum(int num) {
		this.num = num;
	}
	
	public void setMesgNum(String mesg, int num) {
		this.mesg = mesg;
		this.num = num;
	}
	
	// getter
	public String getMesg() {
		return mesg;
	}
	
	public int getNum() {
		return num;
	}

	// toString
	@Override
	public String toString() {
		return "UserService [mesg=" + mesg + ", num=" + num + "]";
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="service" class="com.service.UserService"> <!-- id는 식별 가능한 값, class는 클래스 입력 -->
		<property name="mesg" value="HelloWorld" />     <!-- System.out.println("setMesg 메서드"); property에 의해 출력 -->
	</bean>
	<!-- 다음 코드와 동일
		UserService service = new UserService();
		service.setMesg("HelloWorld");
	 -->
	
	<bean id="service2" class="com.service.UserService">
		<property name="num" value="20" />
	</bean>

	<bean id="service3" class="com.service.UserService">
		<property name="mesg" value="Happy" />
		<property name="num" value="35" />
	</bean>
	<!-- setter based injection -->
</beans>

* 출력 화면

Spring Setter Injection 3_Service_dao 추가

MainClass.java

import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.service.UserService;

public class MainClass {
	public static void main(String[] args) {
		
		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:com/config/user.xml");

		UserService service = ctx.getBean("service", UserService.class);
		List<String> list = service.list();
		System.out.println(list);
	}
}

UserService.java

package com.service;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.dao.UserDAO;

// POJO Class
public class UserService {
	// property (인스턴스 변수)
	UserDAO dao;
	
	// setter 메서드 주입
	public void setDao(UserDAO dao) {
		this.dao = dao;
	}
	
	public List<String> list(){
		return dao.list();
	}
}

UserDAO.java

package com.dao;
import java.util.Arrays;
import java.util.List;

public class UserDAO {

	// DB 연동 가정
	public List<String> list(){
		List<String> list = Arrays.asList("고길동", "홍길동", "신길동");
		return list;
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="userDAO" class="com.dao.UserDAO" /> 		<!-- bean 태그로 등록하면 기본 생성자 호출 가능 -->
	<!--  
		UserDAO userDAO = new UserDAO();
	 --> 
	<bean id="service" class="com.service.UserService"> <!-- id는 식별 가능한 값, class는 클래스 입력 -->
		<property name="dao" ref="userDAO"></property>
	</bean>
	<!-- 다음 코드와 동일
		UserService service = new UserService();
		service.setDAO(UserDAO);
	 -->
</beans>

* 출력 화면 :

 출처

+ 강의 교재

실습 1일차_Injection (Constructor)

의존성 주입의 방법으로는 크게 3가지가 있다.

• 생성자 주입(Constructor Injection)
• 필드 주입(Field Injection)
• 세터 주입(Setter Injection)

Constructor Injection 방식을 권장하는 이유

생성자 주입 방식을 권장하는 이유
- 단일 책임의 원칙
생성자의 인자가 많아지면서 하나의 클래스가 많은 책임을 떠안는다는 걸 알게된다.
그래서 Constructor Injection을 사용해 의존관계, 복잡성을 쉽게 알 수 있다.
 
- 의존성이 숨는다
DI(Dependency Injection) 컨테이너를 사용한다는 것은 클래스가 자신의 의존성만 책임지는게 아니다.
제공된 의존성 또한 책임진다. 그래서 클래스가 어떤 의존성을 책임지지 않을 때, 메소드나 생성자를 통해
커뮤니케이션이 되어야한다. 하지만 Field Injection은 숨은 의존성만 제공해준다.
 
- DI 컨테이너의 결합성과 테스트의 용이성
DI 프레임워크의 핵심은 관리되는 클래스가 DI 컨테이너에 의존성이 없어야한다.
즉, 필요한 의존성을 전달하면 독립적으로 인스턴스화 할 수 있는 단순 POJO여야한다.
DI 컨테이너 없이 유닛테스트에서 인스턴스화 가능하며, 테스트 가능하다.
컨테이너 결합성이 없다면 관리하거나 관리하지 않는 클래스를 사용할 수 있고, 다른 DI 컨테이너로 전환할 수 있다.
 
- Immutability (불변 객체)
생성자 주입 방식에서 필드는 final로 선언할 수 있다.
하지만, 필드 주입 방식에서는 final로 선언할 수 없어 객체가 변경 가능한 상태가 된다.
 
- 순환 의존성
생성자 주입 방식에서 순환 의존성을 가질 경우 BeanCurrentlyCreationExcepiton을 발생시킴으로써 순환 의존성을 알 수 있다.
1번 클래스가 2번 클래스를 참조하는데, 다시 2번 클래스가 1번 클래스를 참조하는 경우 순환 의존성이라고 부른다.

 Spring Constructor Injection 1

MainClass.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.service.UserService;

public class MainClass {
	public static void main(String[] args) {
		
		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:com/config/user.xml");

		UserService service =
				ctx.getBean("service", UserService.class);
		System.out.println(service.getMesg());
	}
}

UserService.java

package com.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// POJO Class
public class UserService {

	String mesg; // null ==> 외부에서 문자열을 주입
	
	// 생성자 주입
	public UserService(String m) {
		this.mesg = m;
	}
	public String getMesg() {
		return mesg;
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="service" class="com.service.UserService">
		<constructor-arg name="m" value="helloWorld" />
	</bean>
	<!-- 
		위의 코드는 다음 코드와 동일하다.
		UserService service = new UserService("helloWorld");
	 -->
</beans>

* 출력 화면 

 Spring Constructor Injection 2

MainClass.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import com.service.UserService;

public class MainClass {

	public static void main(String[] args) {
		
		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:com/config/user.xml");

		UserService service =
				ctx.getBean("service", UserService.class);
		System.out.println(service);
		
		UserService service2 =
				ctx.getBean("service2", UserService.class);
		System.out.println(service2);
		
		UserService service3 =
				ctx.getBean("service3", UserService.class);
		System.out.println(service3);	
	}
}

UserService.java

package com.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// POJO Class
public class UserService {
	// 인스턴스
	String mesg; // null ==> 외부에서 문자열을 주입
	int num; 	 // 0 ==> 외부에서 값을 주입
	
	// 생성자 주입
	public UserService(String m) {
		this.mesg = m;
		
	}
	
	public UserService(int n) {
		this.num = n;
	}
	
	// overriding
	public UserService(String m, int n) {
		this.mesg = m;
		this.num = n;
	}
	
	// getter
	public String getMesg() {
		return mesg;
	}
	
	public int getNum() {
		return num;
	}

	// toString
	@Override
	public String toString() {
		return "UserService [mesg=" + mesg + ", num=" + num + "]";
	}	
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="service" class="com.service.UserService">
		<constructor-arg name="m" value="홍길동"></constructor-arg> 
		<!-- 홍길동이 생성자에 의해서 mesg 변수에 저장이 됨 -->
	</bean>

	<bean id="service2" class="com.service.UserService">
		<constructor-arg name="n" value="20"></constructor-arg>
	</bean>
	
	<bean id="service3" class="com.service.UserService">
		<constructor-arg name="m" value="이순신"></constructor-arg>
		<constructor-arg name="n" value="44"></constructor-arg>
	</bean>

</beans>

* 출력 화면

 Spring Constructor Injection 3_Service_dao 추가

MainClass.java

import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.service.UserService;

public class MainClass {

	public static void main(String[] args) {

		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:com/config/user.xml");
		
		UserService service = ctx.getBean("service", UserService.class);
		List<String> list = service.list();
		System.out.println(list);
	}
}

UserService.java

package com.service;
import java.util.List;
import com.dao.UserDAO;

public class UserService {

	UserDAO dao;
	
	// 생성자 주입
	public UserService(UserDAO dao) {
		this.dao = dao;
	}
	
	public List<String> list(){
		return dao.list();
	}
}

UserDAO.java

package com.dao;
import java.util.Arrays;
import java.util.List;

public class UserDAO {

	// DB 연동 가정
	public List<String> list(){
		List<String> list = Arrays.asList("홍길동", "고길동", "신길동");
		return list;
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="dao" class="com.dao.UserDAO" />
	<!-- UserDAO dao = new UserDAO(); -->
	<bean id="service" class="com.service.UserService">
		<constructor-arg name="dao" ref="dao" /> <!-- 생성자를 이용하여 주입하면  constructor-arg-->
	</bean>
	<!-- 
		UserService service = new UserService();
	 -->
</beans>

* 출력 화면 :

 출처

Constructor Injection 방식을 권장하는 이유 : https://n1tjrgns.tistory.com/230

+ 강의 교재

Spring 실습 1일차_Bean Create

 Bean Create

Main.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.service.UserService;

public class Main {
	public static void main(String[] args) {
		
		// IoC 컨테이너 생성 ==> XXXXApplicationContext	
		ApplicationContext ctx = new GenericXmlApplicationContext("user.xml");
		
		// 생성된 빈 접근
		UserService service = ctx.getBean("service", UserService.class);
		System.out.println(service.getMesg());
	}
}

UserDAO.java

package com.dao;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.service.UserService;

public class UserDAO {
private static final Logger logger = LoggerFactory.getLogger(UserService.class);
	
	public UserDAO() {
		logger.info("UserDAO 생성자");
	}
}

UserService.java

package com.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// POJO Class
public class UserService {

	private static final Logger logger = LoggerFactory.getLogger(UserService.class);
	
	public UserService() {
		logger.info("UserService 생성자");
	}
	
	// 메서드 추가
	public String getMesg() {
		return "UserService";
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<!-- bean 등록  (/:empty tag) -->
	<bean id="service" class="com.service.UserService" />
	<bean id="dao" class="com.dao.UserDAO"/>
</beans>

* Console 출력값 : 

Bean Create_Pakage 추가

MainClass.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {

	public static void main(String[] args) {
		
		// IoC Container
		ApplicationContext ctx = 
				new GenericXmlApplicationContext("com/config/user.xml");
	}
}

UserService.java

package com.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// POJO Class
public class UserService {

	private static final Logger logger = LoggerFactory.getLogger(UserService.class);
	public UserService() {
		logger.info("UserService 생성자");
	}
	
	// 메서드 추가
	public String getMesg() {
		return "UserService";
	}
}

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- bean 등록  (/:empty tag) -->
	<bean id="service2" class="com.service.UserService" />
</beans>

 출처

+ 강의 교재

평균 구하기

 문제 설명

N개의 마을로 이루어진 나라가 있습니다. 이 나라의 각 마을에는 1부터 N까지의 번호가 각각 하나씩 부여되어 있습니다. 각 마을은 양방향으로 통행할 수 있는 도로로 연결되어 있는데, 서로 다른 마을 간에 이동할 때는 이 도로를 지나야 합니다. 도로를 지날 때 걸리는 시간은 도로별로 다릅니다. 현재 1번 마을에 있는 음식점에서 각 마을로 음식 배달을 하려고 합니다. 각 마을로부터 음식 주문을 받으려고 하는데, N개의 마을 중에서 K 시간 이하로 배달이 가능한 마을에서만 주문을 받으려고 합니다. 다음은 N = 5, K = 3인 경우의 예시입니다.

위 그림에서 1번 마을에 있는 음식점은 [1, 2, 4, 5] 번 마을까지는 3 이하의 시간에 배달할 수 있습니다. 그러나 3번 마을까지는 3시간 이내로 배달할 수 있는 경로가 없으므로 3번 마을에서는 주문을 받지 않습니다. 따라서 1번 마을에 있는 음식점이 배달 주문을 받을 수 있는 마을은 4개가 됩니다.
마을의 개수 N, 각 마을을 연결하는 도로의 정보 road, 음식 배달이 가능한 시간 K가 매개변수로 주어질 때, 음식 주문을 받을 수 있는 마을의 개수를 return 하도록 solution 함수를 완성해주세요.

 제한 사항

• 마을의 개수 N은 1 이상 50 이하의 자연수입니다.
• road의 길이(도로 정보의 개수)는 1 이상 2,000 이하입니다.
• road의 각 원소는 마을을 연결하고 있는 각 도로의 정보를 나타냅니다.
• road는 길이가 3인 배열이며, 순서대로 (a, b, c)를 나타냅니다.
  • a, b(1 ≤ a, b ≤ N, a != b)는 도로가 연결하는 두 마을의 번호이며, c(1 ≤ c ≤ 10,000, c는 자연수)는 도로를 지나는데 걸리는 시간입니다.
  • 두 마을 a, b를 연결하는 도로는 여러 개가 있을 수 있습니다.
  • 한 도로의 정보가 여러 번 중복해서 주어지지 않습니다.
• K는 음식 배달이 가능한 시간을 나타내며, 1 이상 500,000 이하입니다.
• 임의의 두 마을간에 항상 이동 가능한 경로가 존재합니다.
• 1번 마을에 있는 음식점이 K 이하의 시간에 배달이 가능한 마을의 개수를 return 하면 됩니다.

 입출력 예

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
주어진 마을과 도로의 모양은 아래 그림과 같습니다.

1번 마을에서 배달에 4시간 이하가 걸리는 마을은 [1, 2, 3, 5] 4개이므로 4를 return 합니다.

 Python 코드

플로이드워셜

def solution(N, road, K):
    INF = 1000000000
    answer = 0
    graph = [[INF] * (N + 1) for _ in range(N + 1)]
 
    for i in range(1, N + 1):
        for j in range(1, N + 1):
            if i == j:
                graph[i][j] = 0
 
    for r in road:
        a, b, c = r[0], r[1], r[2]
        if graph[a][b] > c:
            graph[a][b] = c
            graph[b][a] = c
 
    for i in range(1, N + 1):
        for j in range(1, N + 1):
            for k in range(1, N + 1):
                graph[j][k] = min(graph[j][k], graph[j][i] + graph[i][k])
 
    for j in range(1, N + 1):
        if graph[1][j] <= K:
            answer += 1
 
    return answer

다익스트라 

from queue import PriorityQueue
 
 
def solution(N, road, K):
    INF = 1000000000
    answer = 0
    distance = [INF] * (N + 1)
 
    q = PriorityQueue()
    q.put([1, 0])
    distance[1] = 0
    while not q.empty():
        now, now_cost = q.get()
 
        if now_cost > distance[now]: continue
        for start, dest, cost in road:
            next_cost = now_cost + cost
            if start == now and next_cost < distance[dest]:
                distance[dest] = next_cost
                q.put([dest, next_cost])
            elif dest == now and next_cost < distance[start]:
                distance[start] = next_cost
                q.put([start, next_cost])
 
    for i in range(1, N + 1):
        if distance[i] <= K:
            answer += 1
 
    return answer

* 참고 링크 : https://foameraserblue.tistory.com/86

 C++ 코드

#include <vector>
#include <queue>
using namespace std;
 
vector<pair<int,int>> V[55];
vector<int> Dist;
 
int Min(int A, int B) { if (A < B) return A; return B; }
 
void Dijkstra(int N)
{
    priority_queue<pair<int, int>> PQ;
    PQ.push(make_pair(0, 1));
    Dist[1] = 0;
 
    while (PQ.empty() == 0)
    {
        int Cost = -PQ.top().first;
        int Cur = PQ.top().second;
        PQ.pop();
 
        for (int i = 0; i < V[Cur].size(); i++)
        {
            int Next = V[Cur][i].first;
            int nCost = V[Cur][i].second;
 
            if (Dist[Next] > Cost + nCost)
            {
                Dist[Next] = Cost + nCost;
                PQ.push(make_pair(-Dist[Next], Next));
            }
        }
    }
}
 
int solution(int N, vector<vector<int> > road, int K)
{
    Dist.resize(N + 1, 2e9);
    for (int i = 0; i < road.size(); i++)
    {
        int N1 = road[i][0];
        int N2 = road[i][1];
        int Dist = road[i][2];
 
        V[N1].push_back(make_pair(N2, Dist));
        V[N2].push_back(make_pair(N1, Dist));
    }
 
    Dijkstra(N);
    int answer = 0;
    for (int i = 1; i <= N; i++)
    {
        if (Dist[i] <= K) answer++;
    }
 
    return answer;
}

* 참고 링크 : https://yabmoons.tistory.com/633

 출처

https://programmers.co.kr/learn/courses/30/lessons/12978

Spring Framework 용어 정리

 Spring Framework 용어 정리 1 (Version)

① Spring Framework Version : 4.3.30 release

② JDK Version : 1.8

③ DB Version : Oracle 11g Express Edition 

④ Servlet / JSP Version : 추후 확인 예정

⑤ Build Tool ( 빌드 툴 )

⑥ logging → logback

⑦ 버전관리 (형상관리) → Git / Github

 Spring Framework 용어 정리 2 (POJO & IoC & Bean)

① POJO (Plain Old Java Object)

- 어떠한 것도 implements & extends 하지 않음

- public class classname { } → 독립적 => 재사용 ↑

- Spring 환경에 의존적 X

② IoC (Inversion of Control : 제어의 역행)

③ Bean → 클래스를 의미

 Spring Framework 용어 정리 3 (IoC Container)

IoC Container

=> 궁극적인 기능 Bean들의 Life Cycle 관리 

=> IoC 기능을 담당하는 그릇

* IoC 기능 : 외부에서 Bean을 생성하고 필요 시 주입

 Spring Framework 용어 정리 4 (Spring Framework 개발 방법)

① xml 이용 : Bean 등록, 주입, ...

② @(어노테이션) + 최소한의 xml 이용

③ @(어노테이션) 이용 ( Java Coding Configuration )

* Spring Boot는 @(어노테이션) 기반

 Spring Framework 용어 정리 5 (AOP)

AOP ( Aspect Oriented Programming )

 Spring Framework 용어 정리 6 (Spring)

Spring → Java 기반

→ View를 생성하는 방법이 다양한 기술을 활용한다.

ex) JSP/Servlet, Velocity, thymeleaf => html(Spring Boot), pdf, excel, ... 

=>  View Resolve Bean 이용

JSP/Servlet 전담 View Resolver

Internal Resource View Resolver

 Spring Framework 용어 정리 7 (Spring Framework 실행 순서)

@ + 최소한의 xml 이용

① Bean 생성 (Class 생성)

② xml 등록

<bean id="" class="" />

③ IoC Container에게 xml 인식

//XXXXAplicationContext

ApplicationContext ctx = new GenericXmlApplicationContext("classpath:com/config/user.xml");

④ Bean 얻기

ctx.getBean("id", A.class);

 Spring Framework 용어 정리 8 (Bean 간의 사용)

 출처

+ 강의 교재