→ 화재감시자 (Fire Watcher)

용접·용단 등 화기 작업 시 화재 발생 여부를 감시

잔불 및 불꽃 비산 여부 확인

2. 야광봉을 들고 흔들면서 길 안내하는 사람

→ 신호수 (Flagman / Traffic Controller)

차량 및 장비 이동 시 신호를 통해 안전 유도

야간에는 야광봉(라이트 배턴) 사용

3. 사람을 보고 따라오라고 안내하는 사람

→ 유도원 (Guide / Banksman)

작업자 또는 장비를 특정 위치까지 안전하게 유도

협소 공간, 후진 작업 등에서 필수 역할

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

4 - 1. 이 세상은 객체로 이루어져 있다

객체란

typedef struct Animal {
  char name[30];  // 이름
  int age;        // 나이

  int health;  // 체력
  int food;    // 배부른 정도
  int clean;   // 깨끗한 정도
} Animal;

• 전에 작성한 Animal 구조체를 정의한 후, animal 변수를 만들어서 이를 필요로 하는 함수를 작성함

• 이 때 객체가 현실 세계에서의 존재하는 것들을 나타내기 위해서는 추상화(abstraction)라는 과정이 필요

• animal.food += 100; 자체는 외부에서 animal 이라는 '객체' 의 '인스턴스 변수' 에 '직접' 접근하는 것이기 때문에 불가능

• animal.increase_food(100); 의 경우 animal 객체의 '인스턴스 함수' 를 통해서 값을 수정하는 것이기 때문에가능한 것이지요. 이와 같이 외부에서 직접 인스턴스 변수의 값을 바꿀 수 없고 항상 인스턴스 메소드를 통해서 간접적으로 조절하는 것을 캡슐화(Encapsulation)라고 함

클래스란

class Animal {
 private:
  int food;
  int weight;

 public:
  void set_animal(int _food, int _weight) {
    food = _food;
    weight = _weight;
  }
  void increase_food(int inc) {
    food += inc;
    weight += (inc / 3);
  }
  void view_stat() {
    std::cout << "이 동물의 food   : " << food << std::endl;
    std::cout << "이 동물의 weight : " << weight << std::endl;
  }
};

• Animal 클래스 상에서 이들을 지칭할 때 각각 멤버 변수(member variable) 과 멤버 함수(member function) 라고 부름

private:
int food;
int weight;

• 아래에 쓰여진 것들은 모두 객체 내에서 보호되고 있다 라는 의미
• 모든 것들은 자기 객체 안에서만 접근할 수 있을 뿐 객체 외부에서는 접근할 수 없게 됨

public:
void set_animal(int _food, int _weight) {
  food = _food;
  weight = _weight;
}
void increase_food(int inc) {
  food += inc;
  weight += (inc / 3);
}
void view_stat() {
  std::cout << "이 동물의 food   : " << food << std::endl;
  std::cout << "이 동물의 weight : " << weight << std::endl;
}

• public 이라는 것은 말 그대로 공개된 것으로 외부에서 마음껏 이용할 수 있게 됨

  animal.set_animal(100, 50);
  animal.increase_food(30);
  animal.view_stat();

• 이런식으로 다 지원하게 됨
• 만일 멤버 함수들을 private 로 설정해버렸다면 어떨까요. public 키워드를 지워봄

  'Animal::set_animal' : cannot access private member declared in class 'Animal'

이런 에러가 발생

class Animal {
  int food;
  int weight;
  // ... 생략

• 이런식으로 작성하면 다 private으로 작성하게됨

4 - 2. 클래스의 세계로 오신 것을 환영합니다. (함수의 오버로딩, 생성자)

함수의 오버로딩 (Overloading)

1. 과적하다

2. sb (with sth) 너무 많이 주다[부과하다]

3. (컴퓨터・전기 시스템 등에) 과부하가 걸리게 하다

이런뜻으로 들어감

/* 함수의 오버로딩 */
#include <iostream>

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(char x) { std::cout << "char : " << x << std::endl; }
void print(double x) { std::cout << "double : " << x << std::endl; }

int main() {
  int a = 1;
  char b = 'c';
  double c = 3.2f;

  print(a);
  print(b);
  print(c);

  return 0;
}

• 해당 코드에서 신기한 점은 함수의 이름이 동일하다는것임
• 하지만 해당것은 오류가 안나오고 코드가 compile 됨

하지만

/* 함수의 오버로딩 */
#include <iostream>

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(double x) { std::cout << "double : " << x << std::endl; }

int main() {
  int a = 1;
  char b = 'c';
  double c = 3.2f;

  print(a);
  print(b);
  print(c);

  return 0;
}

이는 지금 print로 int와 double로 두개의 함수를 작성하지만 main함수에서는 char가 있음 이에 결과는

int : 1 int : 99 double : 3.2

이상하게 결과가 나옴

오버로딩의 과정 같은 경우

• 1 단계 자신과 타입이 정확히 일치하는 함수를 찾음

• 2 단계 정확히 일치하는 타입이 없는 경우 아래와 같은 형변환을 통해서 일치하는 함수를 찾아봄

  Char, unsigned char, short 는 int 로 변한왐

  Unsigned short 는 int 의 크기에 따라 int 혹은 unsigned int 로 변환됨

  Float 은 double 로 변환됨

  Enum 은 int 로 변환됨

• 3 단계 위와 같이 변환해도 일치하는 것이 없다면 아래의 좀더 포괄적인 형변환을 통해 일치하는 함수를 찾음

  임의의 숫자(numeric) 타입은 다른 숫자 타입으로 변환됨 ex) float -> int

  Enum 도 임의의 숫자 타입으로 변환ehla ex) Enum -> double

  0 은 포인터 타입이나 숫자 타입으로 변환된 0 은 포인터 타입이나 숫자 타입으로 변환됨

  포인터는 void 포인터로 변환됨

• 4 단계 유저 정의된 타입 변환으로 일치하는 것을 찾음

(만약에 컴파일러가 위 과정을 통하더라도 일치하는 함수를 찾을 수 없거나 같은 단계에서 두 개 이상이 일치하는 경우에 모호하다 (ambiguous) 라고 판단해서 오류를 발생하게 됨)

// 모호한 오버로딩
#include <iostream>

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(char x) { std::cout << "double : " << x << std::endl; }

int main() {
  int a = 1;
  char b = 'c';
  double c = 3.2f;

  print(a);
  print(b);
  print(c);

  return 0;
}

error C2668: 'print' : ambiguous call to overloaded function could be 'void print(char)' or 'void print(int)' while trying to match the argument list '(double)'

• 일단 위 소스에서는 함수가 print (int x) 와 print (char x) 밖에 없으므로 관건은 print(c); 를 했을 때 어떠한 함수가 호출되어야 하는지 결정하는 것인데요, print(c) 를 했을 때 1 단계에서는 명백하게 일치하는 것이 없음
• 그래서 아무것도 없어서 오류가 나옴

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

힙

• 동적으로 할당된 변수가 할당되는 영역(Dynamic Memory Allocation)
• 프로그래머가 직접 공간을 할당, 해제하는 메모리 공간

스택

• 프로그램이 자동으로 사용하는 임시 메모리 영역

• 함수 호출 시 생성되는 지역 변수와 매개 변수가 저장되는 영역으로, 함수 호출이 완료되면 저장된 메모리도 해제됨

• C 언어에서는 malloc 과 free 함수를 지원하여 힙 상에서의 메모리 할당을 지원함

• C++ 에서도 마찬가지로 malloc 과 free 함수를 사용할 수 있는데 그것은 언어 차원에서 지원하는 것으로 바로 new 와 delete 라고 할 수 있음

new(동적 메모리 할당)

• 프로그램 실행 중에 heap 영역에 메모리를 할당
• 할당된 메모리의 주소(pointer)를 반환

delete (동적 메모리 해제)

• new로 할당한 메모리를 반드시 해제
• 해제하지 않으면 → 메모리 누수(memory leak) 발생

/* new 와 delete 의 사용 */
#include <iostream>

int main() {
  int* p = new int;
  *p = 10;

  std::cout << *p << std::endl;

  delete p;
  return 0;
}

사용방법

int* p = new int; 로 p 에 집어 넣었음을 알 수 있음 T* pointer = new T; 에 T 에는 임의의 타입이 들어가고 *p = 10; 를 통해서 값을 집어넣었고 이를 출력함

위와 같이 delete p 를 하게 되면 p 에 할당된 공간이 해제 가능

delete 로 해제할 수 있는 메모리 공간은 사용자가 new 를 통해서 할당한 공간만 가능

/* 지역 변수 delete 하기 */
#include <iostream>

int main() {
  int a = 5;

  delete &a;

  return 0;
}

이런경우 delete 로 해제해버리려 한다면 Heap 이 아닌 공간을 해제하려고 한다는 경고 메세지가 나타나게 됨

/* new 로 배열 할당하기 */

#include <iostream>

int main() {
  int arr_size;
  std::cout << "array size : ";
  std::cin >> arr_size;
  int *list = new int[arr_size];
  for (int i = 0; i < arr_size; i++) {
    std::cin >> list[i];
  }
  for (int i = 0; i < arr_size; i++) {
    std::cout << i << "th element of list : " << list[i] << std::endl;
  }
  delete[] list;
  return 0;
}

• *list = new int[arr_size]; 해당것은 이걸로 new로 힙에 메모리를 할당한것을 주소로 반환한것을 포인터에 저장한것

#include <iostream>

typedef struct Animal {
  char name[30];  // 이름
  int age;        // 나이

  int health;  // 체력
  int food;    // 배부른 정도
  int clean;   // 깨끗한 정도
} Animal;

void create_animal(Animal *animal) {
  std::cout << "동물의 이름? ";
  std::cin >> animal->name;

  std::cout << "동물의 나이? ";
  std::cin >> animal->age;

  animal->health = 100;
  animal->food = 100;
  animal->clean = 100;
}

void play(Animal *animal) {
  animal->health += 10;
  animal->food -= 20;
  animal->clean -= 30;
}
void one_day_pass(Animal *animal) {
  // 하루가 지나면
  animal->health -= 10;
  animal->food -= 30;
  animal->clean -= 20;
}
void show_stat(Animal *animal) {
  std::cout << animal->name << "의 상태" << std::endl;
  std::cout << "체력    : " << animal->health << std::endl;
  std::cout << "배부름 : " << animal->food << std::endl;
  std::cout << "청결    : " << animal->clean << std::endl;
}
int main() {
  Animal *list[10];
  int animal_num = 0;

  for (;;) {
    std::cout << "1. 동물 추가하기" << std::endl;
    std::cout << "2. 놀기 " << std::endl;
    std::cout << "3. 상태 보기 " << std::endl;

    int input;
    std::cin >> input;

    switch (input) {
      int play_with;
      case 1:
        list[animal_num] = new Animal;
        create_animal(list[animal_num]);

        animal_num++;
        break;
      case 2:
        std::cout << "누구랑 놀게? : ";
        std::cin >> play_with;

        if (play_with < animal_num) play(list[play_with]);

        break;

      case 3:
        std::cout << "누구껄 보게? : ";
        std::cin >> play_with;
        if (play_with < animal_num) show_stat(list[play_with]);
        break;
    }

    for (int i = 0; i != animal_num; i++) {
      one_day_pass(list[i]);
    }
  }
  for (int i = 0; i != animal_num; i++) {
    delete list[i];
  }
}

• 해당것은 동물 관련으로 진행하는 미니게임 형식임

typedef struct Animal {
  char name[30];  // 이름
  int age;        // 나이

  int health;  // 체력
  int food;    // 배부른 정도
  int clean;   // 깨끗한 정도
} Animal;

• 이부분은 구조체로 서로 다른 타입의 데이터를 하나로 묶으로 지정하는 사용자 정의 자료형임

• void one_day_pass, play etc, 이것들은 함수로 지정하여 switch 로 지정했을때 그것을 할당하는것을 의미하는것임

• 키 포인트는 동물을 포인터로 만들어 그것을 선택하면 동물값을 입력하는 구조로 만듬

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

레퍼런스의 개념

int x = 10; int& r = x;

• r과 x는 완전히 동일한 객체

• r을 바꾸면 x가 바뀜

• 선언과 동시에 반드시 초기화 필요

• 한 번 바인딩되면 다른 변수로 변경 불가

• 포인터: 주소를 저장 (int* p)

• 래퍼런스: 변수의 별명 (int& r)

래퍼런스 = “복사가 아닌 원본 자체를 직접 다루는 별명”

#include <iostream>

int change_val(int *p) {
  *p = 3;

  return 0;
}
int main() {
  int number = 5;

  std::cout << number << std::endl;
  change_val(&number);
  std::cout << number << std::endl;
}

change_val 함수의 인자 p 에 number 의 주소값을 전달하여, *p 를 통해 number 를 참조하여 number 의 값을 3 으로 바꿈

int& another_a = a;

그 후에 우리는 a 의 참조자 another_a 를 정의하였습니다. 이 때 참조자를 정하는 방법은, 가리키고자 하는 타입 뒤에 & 를 붙이면 됨

int a = 10;
int* p = &a; // p 는 a 를 가리킨다.

int b = 3;
p = &b // 이제 p 는 a 를 버리고 b 를 가리킨다

• p는 a를 가리키는것 즉 a가 현재 주소값을 보여 그것을 가리킴
• b는 3의 주소값을 가리킴

#include <iostream>

int main() {
  int &ref = 4;

  std::cout << ref << std::endl;
}

• 오류가나옴
• 위 상수 값 자체는 리터럴 이기 때문에
• 프로그래밍 언어에서 리터럴(literal)이란, 소스 코드 상에서 고정된 값을 가지는 것을 일컫습니다

int a, b;
int& arr[2] = {a, b};

• 주소값이 존재한다라는 의미는 해당 원소가 메모리 상에서 존재한다 라는 의미와 같습니다. 하지만 레퍼런스는 특별한 경우가 아닌 이상 메모리 상에서 공간을 차지 하지 않습니다. 따라서 이러한 모순 때문에 레퍼런스들의 배열을 정의하는 것은 언어 차원에서 금지가 됨

int& function() {
  int a = 2;
  return a;
}

int main() {
  int b = function();
  b = 3;
  return 0;
}

-> [1] 7170 segmentation fault (core dumped) ./test 이런 오류가 나옴

int& ref = a;

// 근데 a 가 사라짐
int b = ref;  // !!!

• 레퍼런스가 필요한데 사라지게됨 이래서 문제임
• 따라서 위 처럼 레퍼런스를 리턴하는 함수에서 지역 변수의 레퍼런스를 리턴하지 않도록 조심해야함

int& function(int& a) {
  a = 5;
  return a;
}

int main() {
  int b = 2;
  int c = function(b);
  return 0;
}

• 이경우는 래퍼런스 값이 b로 연결이 되어 그대로 레퍼런스와 연결이 됨 그래서 오류가 안나옴

  #include <iostream>
  

int function() { int a = 5; return a; }

int main() { const int& c = function(); std::cout << "c : " << c << std::endl; return 0; }

이런 경우 const로 예외 상수로 받아 상수 레퍼런스로 리턴값을 받게 되면 해당 리턴값의 생명이 연장됨

| 함수 반환              | 받는 방식                | 가능 여부  | 동작 설명                         | 주의사항            |
| ------------------ | -------------------- | ------ | ----------------------------- | --------------- |
| `int f()` (값 반환)   | `int a = f()`        | 가능     | 값 복사됨                         | 없음              |
| `int f()` (값 반환)   | `int& a = f()`       | 컴파일 오류 | rvalue를 non-const 참조로 받을 수 없음 | -               |
| `int f()` (값 반환)   | `const int& a = f()` | 가능     | 임시 객체를 const 참조로 바인딩          | lifetime 연장     |
| `int& f()` (참조 반환) | `int a = f()`        | 가능     | 값 복사됨                         | 참조 의미 사라짐       |
| `int& f()` (참조 반환) | `int& a = f()`       | 가능     | 원본 변수 참조                      | **지역 변수 반환 금지** |
| `int& f()` (참조 반환) | `const int& a = f()` | 가능     | const 참조로 바인딩                 | **지역 변수 반환 금지** |




---
### 참고
https://modoocode.com/141

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

씹어먹는 C++ - <1 - 2. 첫 C++ 프로그램 분석하기>

#include <iostream>

int main() {
  std::cout << "Hello, World!!" << std::endl;
  return 0;
}

#include

• 해당 부분은 C++ 에서 표준 입출력에 대한 필요한것을 포함함

int main()

• C 와 마찬가지로 C++ 에서의 main 함수는 프로그램이 실행될 때 가장 먼저 실행되는 함수

std::cout << "Hello, World!!" << std::endl; return 0;

• std::cout 은 화면에 무언가 출력시켜주는 것 같은데, printf 와 다르게 사용된 것을 보니 함수 같지는 않네요. 그리고 화면에 출력된 것을 대충 보면 "계속하려면 아무 키나 누르세요" 가 한 줄 개행되어서 나온 것을 보니 std::endl 은 한 줄 엔터를 쳐서 나타내라는 표시

  • main 함수에서도 return

std::cout

• std 는 C++ 표준 라이브러리의 모든 함수, 객체 등이 정의된 이름 공간(namespace)
• std 라는 이름 공간에 정의되어 있는 cout 을 의미 합니다. 만약에 std:: 없이 그냥 cout 이라고 한다면 컴파일러가 cout 을 찾지 못합니다. 서울에 사는 철수인지 부산에 사는 철수 인지 알 길이 없기 때문

#include "header1.h"
#include "header2.h"

namespace header1 {
int func() {
  foo();           // 알아서 header1::foo() 가 실행된다.
  header2::foo();  // header2::foo() 가 실행된다.
}
}  // namespace header1

• 소속을 밝히면 이게 이거를 불러오게 됨

  #include "header1.h"
  #include "header2.h"
  using namespace header1;
  

int main() { header2::foo(); // header2 에 있는 함수를 호출 foo(); // header1 에 있는 함수를 호출 }

어쩃든 호출하는것임

---

  다시 돌아가서

int main() { std::cout << "Hello, World!!" << std::endl; return 0; }

두 iostream 헤더파일의 std 라는 이름 공간에 정의되어 있는 것을 불러옴

#include using namespace std;

int main() { cout << "Hello, World!!" << endl; return 0; }

귀찮은면 이렇게 함

---
## 씹어먹는 C++ - <1 - 3. C++ 은 C 친구 - C 와 공통점>

// 변수의 정의 #include

int main() { int i; char c; double d; float f;

return 0; }

변수 정의

int arr[10]; int *parr = arr;

int i; int *pi = &i;

- 포인터로 arr[10]이라는 배열이 있음
- int *parr = arr; parr 포인터로 받는 변수를 정해 arr 값의 &arr[0] 주소 값을 저장
 - parr = 1000(&arr[0]의 주소값)
  - *parr = arr[0] 즉 1000이 가리키는 값이 되어 arr[0] 이됨

  - i라는값이 있음
  - i의 주소값을 출력해서 pi포인터에 저장

// C++ 의 for 문 #include

int main() { int i;

for (i = 0; i < 10; i++) { std::cout << i << std::endl; } return 0; }

반복문(for, while)

// switch 문 이용하기 #include

using std::cout; using std::endl; using std::cin;

int main() { int user_input; cout << "저의 정보를 표시해줍니다" << endl; cout << "1. 이름 " << endl; cout << "2. 나이 " << endl; cout << "3. 성별 " << endl; cin >> user_input;

switch (user_input) { case 1: cout << "Psi ! " << endl; break;

case 2:
  cout << "99 살" << endl;
  break;

case 3:
  cout << "남자" << endl;
  break;

default:
  cout << "궁금한게 없군요~" << endl;
  break;

} return 0; }

``` switch 문

출처 https://modoocode.com/136

예제 입력 1 5 0 -7 -3 -2 5 8

예제 출력 1 1

study part

• 항상 보는 백트래킹으로 문제를 풀이함

    if(arrange_count==input_count)
    {
        return 0;
    }

    if(sum_value+arrange_value[arrange_count]==input_sum)
    {
        output_count+=1;
    }

• 이부분에서는 먼저 기입한 값과 동일하면 끝 그리고 input_sum이 같으면 output_count+1 형식으로 결과를 도출하고 자함

    check_num(sum_value,arrange_count+1);
  
    check_num(sum_value+arrange_value[arrange_count],arrange_count+1);
  
    return 0;

• 이부분에서는 진행정도와 값이 계속 누적되는것을 추가하는것으로 합해지는것 이렇게 해서 check_num을 만드는것

code

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;

int input_count;

int input_sum;

int output_count = 0;

vector <int> arrange_value;

int check_num(int sum_value,int arrange_count)
{
    if(arrange_count==input_count)
    {
        return 0;
    }

    if(sum_value+arrange_value[arrange_count]==input_sum)
    {
        output_count+=1;
    }

    check_num(sum_value,arrange_count+1);

    check_num(sum_value+arrange_value[arrange_count],arrange_count+1);

    return 0;
}

int main()
{
    cin>>input_count>>input_sum;
    arrange_value.resize(input_count);

    for(int i = 0 ; i<input_count;i++)
    {
        cin>>arrange_value[i];
    }

    check_num(0,0);

    cout<<output_count;

}

해당 글은 개인적으로 공부하기 위한 글로 알아주시면 감사하겠습니다.

1.시스템 구조

개루프 시스템

• 개루프 시스템은 입력 명령을 제어하기에 적합한 형태로 변환하는 입력변환기(input transducer)라는 보조 시스템으로 시작함
• 입력은 기준입력(reference)로 칭하며 출력은 피제어 변수(controlled variable)라고 칭함
• 외란과 같은 신호는 입력되는 신호들을 대수적으로 합하는 접합점(summing junction)에서 제어기나 공정의 출력과 합해짐
• 질량이 움직일때 일정한 힘을 소모하는 제동기(damper)와 질량 및 스프링으로 구성되는 기계 시스템은 또 다른 개루프 시스템의 한 예임
• 개루프는 외란에 민감하여 외란을 제거하지 못하는 것이 단점

폐루프 시스템(feedback system)

• 입력 변환기는 입력 명령을 제어기에 적합한 형태로 변환시키며 출력변환기(output transducer) 또는 센서(sensor)로 출력을 측정하여 제어기에 적합한 형태로 변환
• 접합점으로 피드백 경로(feedback path)을 통하여 도달하는 출력 신호와 입력 신호를 대수적으로 합함
• 출력 신호의 부호가 반전되어 신호가 합해지는데 이를 구동신호(actuating signal)이라고 함
• 실제 입력과 출력의 차가 구동 신호가 되는데이를 오차(error) 라고 함
• 간단한 이득 조정을 하거나 제어기를 재설계함으로 써 과도 응답과 정상 상태 오차를 개선시키는것을 보상(compensating)이라고 함 재설계된 하드웨어를 보상기(compensator)라고 함

2. 해석과 설계 목적

과도 응답

• 과도 응답이 너무 빠르면 복구하지 못할 물리적 손상을 시스템에 입힐수 있음

  정상상태 응답

  안정도

• 과도 응답과 정상 상태 오차에 대한 해석과 설계는 시스템이 안정하지 않는 경우에는 의미가 없음
• 고유응답(natural response)과 강제응답(foreced responser)의 합으로 표시됨
• 이런 응답을 각각 동차해(homogeneous solution), 특이해(particular solution)이라함
• 선형시스템은 전체 응답의 다음과 같이 표현됨 $$ 전체 응답 = 고유 응답 + 강제응답 $$

  사례연구

• 이런 진동하거나 정상 상태에서는 고유응답이 0으로 되어 강제응답만 남는 경우 불안정(instability)라고 함
• 감쇠진동(daped oscillation) : 시간에 따라 크기가 줄어드는 정현파 응답하는 과도 상태를 갖게 되는것

  3. 설계 절차

  1단계 : 요구조건에 맞는 실제 시스템 선정

• 요구 조건에 맞는 실제 시스템(physical system)을 선정함

  2단계 : 기능별 블럭선도 작성

• 정상적으로 표현된 시스템의 각 부분을 기능별 블록선도로 나타내고 이를 블록들을 상호 연결하여 전체 블록선도를 완성함

  3단계 : 구조 개요도 도안

• 예로 직류전동기(dc motor) 구동 시키기 위해 차동 증폭기(differential amplifier)와 전력 증폭기는 각각 이득이나 전력 증폭을 하는 제어기로 사용됨
• 부하(load)의 경우 회전하는 질량과 베어링 마찰을 가지므로 부하 모델은 자동차의 충격 흡수 장치나 스크린 문 제동기(screen door damper)와 같이 속도와 증가함에 따라 역회전 토크(torque)가 증가되는 관성(inertia)와 점성마찰(viscous damping)으로 표현됨

4단계 : 수학적 모델의 개발

• 시스템 구조에 대한 개요도가 완성되면 전기 회로에 kirchhoff의 법칙과 실제 시스템에 대해 적용되는 Newton의 법칙과 같은 물리적 법칙과 가정을 이용하여 시스템을 모델링함
• kirchhoff의 전압 / 전류 법칙, newton의 법칙을 이용하면서 동적 시스템의 입력과 출력 사이의 관계를 나타내는 수학적 모델링을 얻을수 있음
• 선형 시불변 미분방정식(linear time-invariant differential equation)으로 표시됨
• 시스템 모델은 차수가 높아지거나 비선형 시변(nonlinear time varying) 또는 편미분 방정식(partial differential equation)으로 표현됨
• 전달함수(transfer function)은 시스템을 수학적으로 모델링하는 방법으로 전달함수를 laplace변환을 이용하여 선형 시불변 미분방정식으로 유도됨
• 상태공간(state space)에서도 시스템 모델이 표현될수 있음 이는 모델을 상태 공간에서 표현하려는 이유는 선형 미분 방정식으로 나타낼수 없는 시스템에서도 적용할수 있을 뿐만 아니라 시뮬레이션하기 편한 형태로 나타낼수 있기 때문

  5단계 : 블럭선도 단순화

  6단계 : 해석과 설계

  
• 계단 함수 : 위치 속도나 가속도가 일정한 크기를 가질때 입력 명령을 표시하는데 사용됨
• 램프 함수 입력 : 선형으로 증가하는 명령을 나타냄
• 정현파 입력 : 시스템에 대한 수학적 모델을 유도하기 위하여 실제 시스템을 시험하는데 이용됨

감도(sensitivity) : 시스템 파라미터 변동에 대한 성능 변동을 퍼센트로

english version

1. System Architecture

1.1 Open-Loop Systems

An open-loop control system operates without feedback.

• The system begins with an input transducer, which converts the command into a form suitable for the controller/plant.
• The input signal is called the reference input.
• The output is referred to as the controlled variable.
• Disturbances may enter at a summing junction, where signals are algebraically combined.

Example: A mechanical system composed of a mass, spring, and damper.

• A damper dissipates energy (typically proportional to velocity).

Limitation:
Open-loop systems are sensitive to disturbances and cannot automatically correct for unexpected variations, leading to degraded accuracy and robustness.

1.2 Closed-Loop Systems (Feedback Systems)

A closed-loop system uses feedback to reduce error and improve robustness.

• The input transducer converts the reference command for the controller.
• A sensor (output transducer) measures the output and converts it into a comparable signal form.
• The measured output returns through the feedback path to the summing junction.

The error (actuating signal) is:

$$ e(t) = r(t) - y(t) $$

where:

• $r(t)$: reference input
• $y(t)$: output
• $e(t)$: error (actuating signal)

Compensation

Improving transient response or steady-state error by gain adjustment or controller redesign is called compensation. The redesigned element is called a compensator.

2. Objectives of Analysis and Design

Control design typically focuses on:

• Transient response
• Steady-state response
• Stability

2.1 Transient Response

Transient response describes system behavior before reaching steady state.

Key measures include:

• rise time
• peak time
• overshoot
• settling time

Engineering note: An excessively fast transient can cause actuator saturation or physical damage in real systems.

2.2 Steady-State Response

Steady-state response describes long-term behavior after transients decay.

A key metric is the steady-state error, which depends on:

• system type
• input class (step, ramp, etc.)

2.3 Stability

If the system is unstable, transient and steady-state specifications are meaningless.

For an LTI system:

$$ \text{Total Response} = \text{Natural Response} + \text{Forced Response} $$

• Natural response = homogeneous solution
• Forced response = particular solution

For a stable system:

$$ \lim_{t \to \infty} \text{Natural Response} = 0 $$

Damped Oscillation

A damped oscillation is a transient sinusoidal response whose amplitude decreases over time due to dissipation.

3. Design Procedure

Step 1: Select the Physical System

Select a physical system that satisfies the given performance requirements, constraints, and operating conditions.

Step 2: Build the Functional Block Diagram

Represent each subsystem as a functional block and interconnect them to describe overall signal flow.

Step 3: Draw the Structural Schematic

Example: DC motor drive system

• differential amplifier: gain control
• power amplifier: power amplification
• load: inertia + viscous damping

A common load model:

$$ T = J\dot{\omega} + B\omega $$

where:

• $J$: inertia
• $B$: viscous damping
• $\omega$: angular velocity

Step 4: Develop the Mathematical Model

Use physical laws:

• Kirchhoff’s Voltage/Current Laws (electrical)
• Newton’s Second Law (mechanical)

Typical result: an LTI differential equation relating input and output.

Transfer Function

Applying Laplace transform:

$$ G(s) = \frac{Y(s)}{R(s)} $$

State-Space Model

State equation:

$$ \dot{x} = Ax + Bu $$

Output equation:

$$ y = Cx + Du $$

Why state-space?

• supports MIMO
• handles nonlinear extensions
• convenient for simulation
• foundation of modern control

Step 5: Block Diagram Reduction

Simplify interconnected blocks using algebraic reduction rules to obtain the overall system form.

Step 6: Analysis and Controller Design

Design the controller to satisfy:

• stability
• transient performance
• steady-state accuracy
• robustness

4. Standard Test Inputs

• Step input: represents a sudden command (often used in position control evaluation)
• Ramp input: represents a linearly increasing command (useful for tracking analysis)
• Sinusoidal input: used for frequency-response testing and system identification

5. Sensitivity

Sensitivity measures performance variation due to parameter changes:

$$ S = \frac{% \text{ change in output}}{% \text{ change in parameter}} $$

Low sensitivity implies strong robustness to modeling uncertainty and component tolerances.

6. Core Design Balance

Control design fundamentally balances:

1. Stability
2. Performance
3. Robustness

감속비 : 감속기어를통해 모터의엔진의 입력 회전 속도를 얼마나 줄여서 출력하는지를 나타내는 비율 즉 이거를 하면 기본 모터 단독 스펙에 rpm 자체가 1/14로 줄어들게 됨

허용 부화 : kg/cm 인데 이게 작동하고 나서 유지하는 힘을 기입

순시허용 토크 : 처음 시작할때 확 올라가는 토크임 이것도 최대 토크는 처음 시작하는 힘 그리고 최대 출력으로는 그냥 유지 될수 있는힘

1 2 3 5 8 13 1 2 3 5 8 21 1 2 3 5 8 34 1 2 3 5 13 21 1 2 3 5 13 34 1 2 3 5 21 34 1 2 3 8 13 21 1 2 3 8 13 34 1 2 3 8 21 34 1 2 3 13 21 34 1 2 5 8 13 21 1 2 5 8 13 34 1 2 5 8 21 34 1 2 5 13 21 34 1 2 8 13 21 34 1 3 5 8 13 21 1 3 5 8 13 34 1 3 5 8 21 34 1 3 5 13 21 34 1 3 8 13 21 34 1 5 8 13 21 34 2 3 5 8 13 21 2 3 5 8 13 34 2 3 5 8 21 34 2 3 5 13 21 34 2 3 8 13 21 34 2 5 8 13 21 34 3 5 8 13 21 34

Study code

• 해당 문제를 풀면서 이제 이해헀다고 생각했는데 아직 이해를 못했다
• 결과적으로 또 반복하지만 내 위치를 파악하고 그 위치에 도착하면 결과를 출력해라 이것이 메인임
• 또 해당 결과가 함축했다가 나오는게 아니라 할때마다 계속나와도 되는 것을 파악하고 0 에 결과가 아니라 그냥 할때 마다 결과를 도출함
• 그리고 여기서 굳이 2차원을 만들필요도 없었고 그냥 1차원으로 해서 만들어도 되었음
• 그래서 필요없는 clear를 쓰고 이런거임
• 결론적으로 도착하면 결과 그리고 layer 자체가 내가 input 한거 보다 이상 넘어갈수 있어서 그게 아니면 return임
• 추가적으로 void 라서 return 0 이 아니라 return임
• 백트래킹으로 계혹 들어가는 것과 재귀를 활용함
• 그래서 값을 계속 저장하고 for은 현재 layer로 이동한것이니 시작은 layer로 잡음
• 그리고 재귀는 result_function에 i를 넣으면서 해당 루프에 전체를 다 수색하게 함

추가적인것 2차원 resize하는거 ㄱemind

int n
cin >>n;

vector <vector<int>> new;

new.reszie(n);

for(int = 0 ; i < n;i++)
{
    new[i].resize(n);
}

or

vector <vector<int>> new(n, vector<int>(n));

Code

#include <iostream>
#include <string>
#include <vector>

using namespace std;

vector<vector<int>> input_list;

int input_value;

int value_result[6];

void result_function(int layer,int count)
{
    if(count==6)
    {
        for(int i=0 ; i<6 ; i++)
        {
            cout<<value_result[i]<<" ";
        }
        cout<<"\n";
        return;
    }

    if(layer>=input_value) return;

    for(int i=layer ; i<input_value ; i++)
    {
        value_result[count]=input_list[0][i];
        result_function(i+1,count+1);
    }
}

int main()
{
    while(1)
    {
        cin>>input_value;

        if(input_value == 0)
        {
            return 0;
        }

        vector <int> row_value(input_value);

        for(int i = 0; i<input_value ; i++)
        {
            cin>>row_value[i];
        }

        input_list.clear();
        input_list.push_back(row_value);
        result_function(0,0);
        cout<<"\n";
    }


}

예제 출력 1 35

Study code

Part1

• 2차원 배열을 만들어야 하는데 vector와 포인터 중에 뭐를 쓸지 고민했음
• 그래서 오래간만에 포인터를 활용하여 2차원 배열을 만들고자 했음
• 하지만 gpt나 현업에서는 vector를 사용하는것이 일반적이라고 함
• 포인터를 쓰게 되면 이렇게 메모리를 만들어줘야함 a │ ├─ a[0] ──▶ int int int int ├─ a[1] ──▶ int int int int ├─ a[2] ──▶ int int int int └─ a[3] ──▶ int int int int

int** a;

    a = new int*[input_num];

    for(int j = 0 ; j < input_num;j++)
    {
        a[j] = new int[input_num];
    }   

그래서 이렇게 진행해야 함

• 이렇게 한다음 그냥 2차원 배열 사용하듯이 평법하게 사용하면 됨
• 다 사용하고 나서 하단같이 메모리를 delete를 해야함
• 안그러면 메모리 누수 또는 런타임 오류가 나올수 있음

    for (int i = 0; i < input_num; i++)
    {
    delete[] a[i];
    }
    delete[] a;

• 각 행마다의 delete와
• 모든 행의 delete를 진행하는것

Part2

• 이번 문제를 풀면서 코드를 전체를 이해하기 보다는 흐름을 이해해야하는것으로 초점을 두었음
• 해당 문제에 대한 개념은 결과적으로 백트래킹으로 계속돌아가고 브루트포스로 숫자를 넣어서 비교하는 것으로 진행되어야 했음
• 그래서 내가 보았을때는 결론적으로 이렇다.

1. 해당 계산 함수의 시작은 처음 목표값까지 도달으면 그 결과를 나오게 하는것 1-1. 하지만 결과가 나오게 되는 것까지 특정 부분에서 예외가 있는경우가 있으니 return을 하거나 loop 구분이 있을시 continue로 넘어가는것

2. 다음것은 결과적으로 모든 것의 코드 그리고 index가 있을것이다. 그것을 빠르게 봐야하는 것, 그리고 방문을 했는지 안했는지 판단하는것이 가장 중요하고 계속해서 반복해야하는 부분은 check() 이부분을 반복해야한다. 2-1. 그래서 일단 그 index가 방문했는지 안했는지 판단하여 loop에 if을 해서 있으면 continue로 해서 넘어가고 아니면 그 다음 스텝을 가는것으로 진행 2-2. 그렇게 다음으로 가는것은 앞서 말한대로 check을 불러오는것을 시작으로 그 값에 추가를 하고 계속 자기자신을 불러옴 그리고 그 밑에는 방문을 했으니 flase로 방문을 끝냄

-> 여기서 중요한게 check를 하기전에는 true인지 false인지 check을 하고 false면 true로 만들어주고 끝나면 false로 만들어줌

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

int input_num;

bool ch[11] = {false,};

int** a;

int output_result = 1e9;

void check(int start,int index,int cnt,int sum_num)
{
    if (sum_num >= output_result) return; 

    if(cnt==input_num)
    {
    if(a[index][start]==0) return;

    output_result = min(output_result, sum_num + a[index][start]);
    return;
    }

    for(int i = 0;i<input_num;i++)
    {
        if(a[index][i]==0||ch[i]) continue;
        ch[i]=true;
        check(start,i,cnt+1,sum_num+a[index][i]);
        ch[i]=false;
    }
}

int main()
{
    cin>>input_num;
    a = new int*[input_num];

    for(int j = 0 ; j < input_num;j++)
    {
        a[j] = new int[input_num];
    }   

    for(int i = 0 ; i< input_num;i++)
    {
        for(int j = 0 ; j < input_num;j++)
        {
            cin>>a[i][j];
        }   
    }

    for (int i = 0; i < input_num; i++)
    {
        ch[i] = true;
        check(i,i,1,0);
        ch[i] = false;
    }

    cout<<output_result;

    for (int i = 0; i < input_num; i++)
    {
    delete[] a[i];
    }
    delete[] a;

    /*
    메모리 누수 또는 런타임 오류
    */

    return 0;
}

예제 입력 1 6 20 1 15 8 4 10

예제 출력 1 62

code study

• 저기 절대값이 있다는것을 순간적으로 몰라서 멍때리다가 절대값이라길래 아하 하고 풀었음
• next_permutation을 활용하였고 저번과 같이 배열을 sort를 하여 순서대로 하고 수식을 넣어 하나하나 비교하면서 풀었음
• sort(input_value.begin(),input_value.end()); 이방향으로 진행함
• 절댓값ㄷ이 abs라는것을 한번더 상기

•   for(int i = 0; i<input_count-1;i++)
    {
       check_result+=abs(input_value[i]-input_value[i+1]);
    }

  이부분에서 어디까지라는것을 먼저 확인하고 들어감

code

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;

int input_count;

vector <int> input_value;

int output_result = 0;

int check_result;


void check_num()
{
    do
    {
    for(int i = 0; i<input_count-1;i++)
    {
       check_result+=abs(input_value[i]-input_value[i+1]);
    }
    if(output_result < check_result)
    {
        output_result=check_result;
    }
    check_result=0;
    }while(next_permutation(input_value.begin(),input_value.end()));

    cout<<output_result;
}

int main()
{
    cin>>input_count;

    input_value.resize(input_count);

    for(int i = 0; i<input_count;i++)
    {
        cin>>input_value[i];
    }    

    sort(input_value.begin(),input_value.end());

    check_num();
}

예제 입력 1 4 1 2 3 4 예제 출력 1 1 2 4 3

예제 입력 2 5 5 4 3 2 1 예제 출력 2 -1

공부내용

• next_permutation를 배웠는데 이는 순열의 다음것을 출력해주는것임
• 이는 algorithm을 활용하면 #include가 있어야함
• prev_permutation를 활용하면 전꺼가 되니까 기억해라

    if(next_permutation(get_num.begin(),get_num.end()))
    {
        for(int i = 0;i<in_num;i++)
        {
            cout<<get_num[i]<<' ';
        }
    }

  이렇게 하면 다음께 출력이 되고

    do{ 
    for(int i = 0;i<in_num;i++) 
    {
        cout<<get_num[i]<<' ';
    }
    }while(next_permutation(get_num.begin(),get_num.end()));```

이렇게 하면 모든 순열이 출력이 된다

code

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;

int in_num;

vector <int> get_num; 


int main()
{
    cin>>in_num;

    get_num.resize(in_num);

    for(int i = 0;i<in_num;i++)
    {
        cin>>get_num[i];
    }


    if(next_permutation(get_num.begin(),get_num.end()))
    {
        for(int i = 0;i<in_num;i++)
        {
            cout<<get_num[i]<<' ';
        }
    }
    else
    {
        cout<<-1;
    }

    return 0;
}

예제 입력 1 4 -+0++++--+ 예제 출력 1 -2 5 -3 1

예제 입력 2 2 +++ 예제 출력 2 3 4

예제 입력 3 5 ++0+-+-+--+-+-- 예제 출력 3 1 2 -3 4 -5

공부

• 해당 코드를 공부하면서 시간을 많이 쓴것 같음
• 허나재귀 파트의 마지막 문제라서 조금더 집중을 한것같음
• 해당부분에서 중요한것은 이 세가지라고 생각함

1. 함수시작에 원하는 개수가 내가 input한 개수와 일치할 경우 그 최종결과를 출력하는것
2. return과 continue를 활용하여 넘어갈 것은 if을 통해 확인하고 바로 넘어가기 그리고 줄 넘버는 바로 주기
3. return을 수치를 return 하는것이 아닌 bool을 return함으로써 현재 그 수치가 이 안에 들어와도 되는지 확인하기

이렇게 되는것 같은데

즉 브루토포스로 수치를 다때려 박으면서 재귀를 통해 계속 자기자신을 반복하는것임 그리고 앞서 말할것 처럼 이 방법이 맞는지 확인하고 아니면 바로 돌아가는 것으로 다시 돌아가서 확인하는 백트래킹으로 진행하는것임

코드

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

char input_num_index[10][10];

int count_num;

int result[10];

bool check_num(int count_void)
{
    int sum = 0;
    for(int i = count_void;i>=0;i--)
    {
        sum = sum+result[i];
        if(input_num_index[i][count_void]=='+'&&sum<=0)
        return false;
        if(input_num_index[i][count_void]=='-'&&sum>=0)
        return false;
        if(input_num_index[i][count_void]=='0'&&sum!=0)
        return false;
    }
    return true;
}

void bfs(int count_void)
{
    if(count_void == count_num)
    {
        for(int i = 0 ; i<count_void;i++)
        {
            cout<<result[i]<<" ";
        }
        exit(0);
    }

    for(int i = -10;i<=10;i++)
    {
        if(input_num_index[count_void][count_void]=='+' && i<=0) continue;
        if(input_num_index[count_void][count_void]=='-'&& i>=0) continue;
        if(input_num_index[count_void][count_void]=='0'&& i!=0) continue;

        result[count_void] = i; 

        if(check_num(count_void)==true)
        {
            bfs(count_void+1);
        }
    }
}

int main()
{
    int input_bo_index = 0;

    string input_bo;

    cin>>count_num;

    cin>>input_bo;

    for(int i = 0;i<count_num;i++)
    {
        for(int j = i; j<count_num;j++)
        {
            input_num_index[i][j]=input_bo[input_bo_index++];
        }
    }

    bfs(0);
}

예제 입력 1 2 < >

예제 출력 1 897 021

예제 입력 2 9

< < < > > > < <

예제 출력 2 9567843012 1023765489

공부노트

• bool check(char big_small,int f_num,int sec_num)
  처음에는 해당 부분에서 bool check 하는 부분이 어떻게 체크를 해야하는지 몰랐음 그래서 보니까 bool로 return을 해야하는것으로 bool로 바꾸고 진짜 이 기호가 이 숫자가 들어가도 된다 안된다를 true false로 한다는 것에서 신선하게 이해개 되었음

• results.push_back(num); 처음에 전체 코드가 완성되면 해당 답에 push를 하여 답을 넣어서 출력하는 식이었음

• 코드의 핵심 알고리즘

    if(visit[i]) continue;
  
    else if(depth==0)
    {
        visit[i]=true;
        check_num(depth+1,num+to_string(i));
        visit[i]=false;
    }
    else
    {
        int change_int = num[depth-1]-'0';
        if(check(equality[depth-1],change_int,i))
        {
        visit[i]=true;
        check_num(depth+1,num+to_string(i));
        visit[i]=false;
        }
    }

  이부분에서

코드

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int input_value;

char equality[10];

bool visit[10];

vector<string> results;

bool check(char big_small,int f_num,int sec_num)
{
    if(big_small=='<')
    {
        return f_num < sec_num;
    }
        if(big_small=='>')
    {
        return f_num > sec_num;
    }
    return false;
} 

void check_num(int depth, string num)
{
    if(depth==input_value+1)
    {
        results.push_back(num);
        return;
    }

    for(int i = 0;i<=9;i++)
    {
        if(visit[i]) continue;

        else if(depth==0)
        {
            visit[i]=true;
            check_num(depth+1,num+to_string(i));
            visit[i]=false;
        }
        else
        {
            int change_int = num[depth-1]-'0';
            if(check(equality[depth-1],change_int,i))
            {
            visit[i]=true;
            check_num(depth+1,num+to_string(i));
            visit[i]=false;
            }
        }
    }
}

int main()
{   
    cin>>input_value;

    for(int i=0 ;i<input_value;i++)
    {
        cin>>equality[i];
    }

    check_num(0,"");

    sort(results.begin(),results.end());
    cout<<results.back()<<"\n";

    cout<<results.front()<<"\n";    

}

공부노트

• 해당 개념에서 백트래킹을 배우면서 우리가 원하는 값이 안나오면 돌아간다라는 개념을 공부하게 되었음
• 14889의 문제 같은경우 상대팀과 내 팀의 인원이 같은경우를 생각해야 되어서 n/2를 하며 진행함
• 그렇게 나누어진 부분을 벡터에 init하고 다음 score값에다가 배열을 하나하나 넣는 방식으로 진행함
• 그리고 team 부분에 continue 즉 방문을 한 것 우리팀인 것일 경우 continue를 진행하여 다음 for로 가게 만들어 진행함

14889코드

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int line;

int layer[20][20];

int lower_value = 500;

bool team[20];

void teamset(int mem, int fight_mem)
{
    vector<int> start;
    vector<int> link;

    int start_score = 0;

    int link_score = 0;

    if (fight_mem == line/2)
    {
        for(int i = 0 ; i < line ; i++)
        {
            if(team[i]==true)
            {
                start.push_back(i);
            }
            else
            {
                link.push_back(i);
            }
        }

        for(int i = 0 ; i<line/2 ; i++)
        {
            for(int j = 0 ; j<line/2 ; j++)
            {
               start_score+=layer[start[i]][start[j]];
               link_score+=layer[link[i]][link[j]];
            }
        }

        lower_value = min(lower_value,(abs(start_score-link_score)));
        return;
    }

    for(int i = mem ; i < line ; i++)
    {
        if(team[i])
        {
        continue;
        }
        else
        {
            team[i]=true;
            teamset(i,fight_mem+1);
            team[i]=false;
        }
    }
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);

    cin>>line;

    for(int i = 0 ; i<line;i++)
    {
        for(int j = 0 ; j<line;j++)
        {
            cin>>layer[i][j];
        }
    }
    teamset(0,0);
    cout<<lower_value;
}

예제 입력 1 4 0 1 2 3 4 0 5 6 7 1 0 2 3 4 5 0 예제 출력 1 0 예제 입력 2 6 0 1 2 3 4 5 1 0 2 3 4 5 1 2 0 3 4 5 1 2 3 0 4 5 1 2 3 4 0 5 1 2 3 4 5 0 예제 출력 2 2 예제 입력 3 8 0 5 4 5 4 5 4 5 4 0 5 1 2 3 4 5 9 8 0 1 2 3 1 2 9 9 9 0 9 9 9 9 1 1 1 1 0 1 1 1 8 7 6 5 4 0 3 2 9 1 9 1 9 1 0 9 6 5 4 3 2 1 9 0 예제 출력 3 1

공부노트

• 이번 문제는 전문제와 다르게 팀수가 제한이 없었음
• 그래서 일단 모든팀을 true로 만든다음(우리팀으로 만든다음) 내부에 한팀이라도 size가 0이면 return을 하여 다음 함수로 가게 만듬
• 그리고 link와 start팀은 수가 각각 다르다고 판단하여 size도 나누어 score 값을 추출하고자 함

15661코드

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int input_value[20][20];

int input_count;

int output_answer=50;

bool are_you[20];

void teamset(int count)
{
    vector<int> link;
    vector<int> start;

    int link_score = 0;

    int start_score = 0;


    if(count==input_count)
    {
        for(int i=0;i<input_count;i++)
        {
            if(are_you[i]==true)
                link.push_back(i);
            else
                start.push_back(i);
        }

        if(link.size()==0 || start.size()==0)
        {
            return;
        }

        for(int i = 0;i<link.size();i++)
            for(int j = 0;j<link.size();j++)
            {
                link_score+=input_value[link[i]][link[j]];
            }

        for(int i = 0;i<start.size();i++)
            for(int j = 0;j<start.size();j++)
            {
                start_score+=input_value[start[i]][start[j]];
            }
            output_answer = min(output_answer,abs(link_score-start_score));
            return;
    }

    are_you[count]=true;

    teamset(count+1);

    are_you[count]=false;

    teamset(count+1);

}

int main()
{
    cin>>input_count;

    for(int i=0;i<input_count;i++)
    {
        for(int j=0;j<input_count;j++)
        {
            cin>>input_value[i][j];
        }
    }

    teamset(0);

    cout<<output_answer;

}

예제 입력 1 7 3 10 5 20 1 10 1 20 2 15 4 40 2 200 예제 출력 1 45

예제 입력 2 10 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 1 10 예제 출력 2 55

예제 입력 3 10 5 10 5 9 5 8 5 7 5 6 5 10 5 9 5 8 5 7 5 6 예제 출력 3 20

예제 입력 4 10 5 50 4 40 3 30 2 20 1 10 1 10 2 20 3 30 4 40 5 50 예제 출력 4 90

공부 노트

vector로 여러가지 배열 만들기

• c도 파이썬 같이 배열안에 원하는 만큼 만들면 좋을것 같아서 찾아봄

  #include <iostream>
  #include <vector>
  using namespace std;
  

int count_num; int k; // 한 줄에 입력될 데이터 개수 vector<vector> layer;

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

cin >> count_num >> k;  // 예: 7 3 (7줄, 한 줄에 3개씩 입력)

layer.resize(count_num, vector<int>(k));

for(int i = 0; i < count_num; i++) {
    for(int j = 0; j < k; j++) {
        cin >> layer[i][j];
    }
}

}

핵심적인부분이

layer.resize(count_num, vector<int>(k));

for(int i = 0; i < count_num; i++) {
    for(int j = 0; j < k; j++) {
        cin >> layer[i][j];

이부분인데 이렇게 받은 값을 

vector(k)

로 하면 여러개를 받을수 있음


### 코드

#include #include #include using namespace std;

int count_num;

vector<pair<int, int>> layer;

int* dp;

void soultion_get(const vector<pair<int,int>>& layer) { int max_pay = 0; for(int i=0;i<count_num;i++) {
dp[i+1]=max(dp[i+1],dp[i]); int time = layer[i].first; int pay = layer[i].second;

    int pass = time+i;

    if(pass<=count_num)
    {
        dp[pass] = max(dp[pass],dp[i]+pay);
    }
}
cout<<dp[count_num]<<"\n";

}

int main() { ios_base::sync_with_stdio(0);

cin >> count_num;

layer.resize(count_num);

dp = new int[count_num+1];

for(int i = 0 ; i<count_num;i++)
{
    cin >> layer[i].first>>layer[i].second;
}

for(int i = 0 ; i<count_num;i++)
{
    dp[i] = 0;
}

soultion_get(layer);

}

```

참고

https://codejin.tistory.com/173

예제 입력 1 3 1 4 5 2 예제 출력 1 2 4 5

예제 입력 2 4 2 9 8 7 1 예제 출력 2 1 7 1 8 1 9 7 8 7 9 8 9

예제 입력 3 4 4 1231 1232 1233 1234 예제 출력 3 1231 1232 1233 1234

개념 정리

vector vec

• C++ 에서 제공하는 정수형 동적 배열선언
• 초기에는 크기가 0이고 필요한 순간 동적으로 크기 조절이 가능
• 한줄이라고 생각하면 되는것 우리가 아는 배열 느낌으로

ios_base::sync_with_stdio(0)

• C++의 iostream(cin, cout)과 C의 stdio(scanf, printf) 간의 동기화를 끄는 명령이
• 이 작업으로 입출력 성능 최적화됨
• scanf/printf와 섞어 쓰면 안됨 동기화가 꺼졌기 때문

nums.resize(N);

• vector의 크기를 N만큼 변경(resize) 하는 명령어
• SIZE을 지정하는 것
• 정렬한후 순서대로 탐색

for (const int& v : vec)

• 해당것은 cpp 기반 범위 기반 FOR문임
• vec 내부의 원소를 앞에서부터 하나씩 순회

동일한 것

for (int i = 0; i < vec.size(); i++) { cout << vec[i] << ' '; }

또는

for (int v : vec) { // 복사 발생 cout << v << ' '; }

효율화 안전화 특면에서

for (const int& v : vec)

코드

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int line, get_out;
vector<int> nums;
vector<int> vec;

void NM(int a, int start)
{
    if(a == get_out)
    {
        for(int i = 0; i < get_out; i++)
            cout << vec[i] << " ";
        cout << "\n";
        return;
    }

    for(int i = start; i < line; i++)
    {
        vec[a] = nums[i];
        NM(a + 1, i + 1);
    }
}

int main()
{
    ios_base::sync_with_stdio(0);

    cin >> line >> get_out;

    nums.resize(line);
    vec.resize(get_out);

    for(int i = 0; i < line; i++)
        cin >> nums[i];

    sort(nums.begin(), nums.end());

    NM(0, 0);
}

이는 타 pc에 연결할때 내가 보면서 하고 싶어서 만든 것임ㅋ

• 이는 같은 와이파이상에서 하는 경우를 설명함
• 나는 wsl에서 접속한지라 wsl이 적혀있음

  wsl 환경에서 접속하는법

[상대 PC] 1) SSH 서버 설치

sudo apt update sudo apt install openssh-server -y

있는 지 확인하는법 ->which sshd

[상대 PC] 2) SSH 서비스 활성화

sudo systemctl enable ssh sudo systemctl start ssh sudo systemctl status ssh

서비스 활성 상태(enable) 확인 ->systemctl is-enabled ssh 답 : enable

서비스 실행 중인지 확인 ->systemctl status ssh 답 : Active: active (running)

SSH 포트(22) 열렸는지 확인 ->ss -tlnp | grep ssh

[상대 PC] 3) 방화벽(UFW)에서 SSH 허용

sudo ufw allow ssh sudo ufw enable sudo ufw status

UFW 방화벽에서 SSH 허용 여부 확인 ->sudo ufw status verbose

[상대 PC] 4) 서버 IP 확인

ip addr show

[WSL] 1) 상대 PC에 ping 테스트

ping 192.168.0.25

ping이 되면 네트워크 연결 가능 ping이 안되면 Windows 방화벽 또는 네트워크 문제

[WSL] 2) SSH 접속

ssh 사용자명@192.168.0.25 예: ssh jhlee@192.168.0.25

whoami로 사용자 명을 확인할수 있음

[WSL] 3) 첫 접속 시 fingerprint 등록

Are you sure you want to continue connecting (yes/no)? → yes 입력

[WSL] 4) 접속 확인

user@ubuntu-PC:~$

vscode에서 접속하는법

1. remote-ssh 다운
2. f1 클릭
3. ssh config 작성
4. C:Users\이름\ssh\config뜸

5.기입

Host **ubuntu_server**
    HostName **192.168.0.245**
    User **ros**
    Port **22**

• 해당부분에서 ubuntu_server는 너가 vscode에 지정할 이름을 작성하는것
• hostname은 상대 ip를 작성
• user도 상대 이름
• port는 일반적이면 22임

6. 좌측 빨강 클릭후 remotes tunnels 들어간다음 ssh에 너가 만든것이 있으면 성공한것임 이제 하단에 들어가면됨

참고

https://diokim17.tistory.com/13

예제 입력 1 4 6 a t c i s w

예제 출력 1 acis acit aciw acst acsw actw aist aisw aitw astw cist cisw citw istw

개념정리

push_back

• push_back이란 vector에서 뒤에 자리에 숫자를 집어 넣음
• 또는 str.push_back으로 해서 뒤에 문자도 집어넣을수 있음

vector <char> nums_line;

• 이렇게 vector는 int 뿐만아니라 char로도 할수 있었음

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int output_line, input_line;

vector<char> nums_line;

void dfs(vector<char> nums_line, int a, string str, int jaum, int moum)
{

    str.push_back(nums_line[a]);
    if(nums_line[a] == 'a' || nums_line[a] == 'e' || nums_line[a] == 'i'|| nums_line[a] == 'o'|| nums_line[a] == 'u')
    {
        ++moum;
    }
    else ++jaum;

    if(str.size()==output_line)
    {
        if(moum>=1 && jaum>=2)
        {
            cout<<str<<'\n';
        }
    }

    for(int i = a+1;i < input_line;i++)
    {
        dfs(nums_line, i, str, jaum, moum);
    }

}

int main()
{
    ios_base::sync_with_stdio(0);

    cin>>output_line>>input_line;

    nums_line.resize(input_line);

    for(int i = 0 ; i < input_line;i++)
    {
        cin>>nums_line[i];
    }

    sort(nums_line.begin(),nums_line.end());

    for(int i = 0; i < input_line; i++)
        dfs(nums_line,i,"",0,0);

}

참고 https://0m1n.tistory.com/21

예제 입력 1 3 1 4 5 2 예제 출력 1 2 4 5

예제 입력 2 4 2 9 8 7 1 예제 출력 2 1 7 1 8 1 9 7 1 7 8 7 9 8 1 8 7 8 9 9 1 9 7 9 8

예제 입력 3 4 4 1231 1232 1233 1234 예제 출력 3 1231 1232 1233 1234 1231 1232 1234 1233 1231 1233 1232 1234 1231 1233 1234 1232 1231 1234 1232 1233 1231 1234 1233 1232 1232 1231 1233 1234 1232 1231 1234 1233 1232 1233 1231 1234 1232 1233 1234 1231 1232 1234 1231 1233 1232 1234 1233 1231 1233 1231 1232 1234 1233 1231 1234 1232 1233 1232 1231 1234 1233 1232 1234 1231 1233 1234 1231 1232 1233 1234 1232 1231 1234 1231 1232 1233 1234 1231 1233 1232 1234 1232 1231 1233 1234 1232 1233 1231 1234 1233 1231 1232 1234 1233 1232 1231

code

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int input[10];

int output[10];

bool visit[10];

int line, get_out;

void NM(int m)
{
    if(m==line)
    {
        for(int i = 0;i<line;i++)
        {
            cout<<output[i]<<" ";
        }
        cout<<"\n";
    }
    else
    {
        for(int i = 0 ; i < get_out ;i++)
        {
            if(visit[i]==false)
            {
                output[m] = input[i];
                visit[i]=true;
                NM(1+m);
                visit[i]=false;
            }
        }
    }


}

int main()
{

    cin >> get_out >> line;

    for(int i = 0 ; i<get_out ; i++)
    {   
        cin >>input[i];
    }

    sort(input,input+get_out);

    NM(0);

    return 0;

}