씅의 기록하는 개발노트

#include <iostream>

#include <algorithm>

#include <stdlib.h>

using namespace std;

#define N 9

#define MAX 100

int arr[N];

bool breakFlag=false;

void sol()

{

int tmp=0;

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

cin >> arr[i];

tmp += arr[i];

}

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

for (int j = i + 1; j < N; j++) {

if (tmp - arr[i] - arr[j] == MAX)

{

arr[i] = -1;

arr[j] = -1;

breakFlag = true;

}

}

if (breakFlag)

break;

}

sort(arr, arr + N);

for (int i = 2; i < N; i++)

cout << arr[i] << endl;

}

int main()

{

sol();

return 0;

}

#include <iostream>

#include <algorithm>

#define M_PI 3.14159265358979323846

using namespace std;

void sol()

{

ios_base::sync_with_stdio(0);

cin.tie(0);

double r;

cin >> r;

//소수점 6자리 고정

cout << fixed;

cout.precision(6);

cout << r * r*M_PI << "\n";

cout << r * r * 2 << "\n";

}

int main()

{

sol();

return 0;

}

#include <iostream>

#include <algorithm>

using namespace std;

int N, R;

void sol()

{

ios_base::sync_with_stdio(0);

cin.tie(0);

while (true) 

{

long long ret = 1;

cin >> N >> R;

if (N == 0 && R == 0)

break;

//이항계수의 성질

R = min(R, N - R);

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

ret *= N;

ret /= i;

N--;

}

cout << ret << endl;

}

}

int main()

{

sol();

return 0;

}

#include "pch.h"

#include <iostream>

using namespace std;

/*

1 1 1 1 모

1 1 1 0 도

1 1 0 0 개

1 0 0 0 걸

0 0 0 0 윷

*/

char RET[5] = { 'D', 'C', 'B', 'A', 'E' };

void sol()

{

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

int idx = 0;

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

bool tmp;

cin >> tmp;

idx += tmp;

}

cout << RET[idx] << endl;

}

}

int main()

{

sol();

return 0;

}

#include "pch.h"

#include <iostream>

#include <stdlib.h>

using namespace std;

const int MAX = 1001;

const int MOD = 10007;

int N, K;

int cache[MAX][MAX];

void init()

{

for (int i = 1; i <= N; i++)

{

cache[i][1] = i;

cache[i][i] = cache[i][0] = 1;

}

}

void sol()

{

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

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

cache[i][j] = cache[i - 1][j] % MOD + cache[i - 1][j - 1] % MOD;

}

}

}

int main()

{

cin >> N >> K;

if (N < 1 || N >= MAX || K<0 || K>N)

exit(-1);

init();

sol();

cout << cache[N][K] %MOD << endl;

return 0;

}

#include "pch.h"

#include <iostream>

using namespace std;

//N<=10 K<=N 인 자연수

int sol(int n)

{

if (n == 0)

return 1;

int ret=1;

for (int i = n; i >= 1; i--)

ret *= i;

return ret;

}

int main()

{

int n, k;

cin >> n >> k;

cout << sol(n) / (sol(k)*sol(n - k));

return 0;

}

#include <iostream>

#include <algorithm>

#include <string.h>

using namespace std;

const int MAX = 1000;

int map[MAX];

int caseNum;

void solution()

{

    int tc;

    int ret=0, tmp=0;

    memset(map, 0, sizeof(map));

    caseNum++;

    scanf("%d", &tc);

    for(int i=0;i<tc;i++)

       scanf("%d", &map[i]);

    for(int i=2;i<tc-2;i++)

    {

        tmp = map[i] - max(max(map[i-1], map[i-2]), max(map[i+1], map[i+2])); 

        if(tmp > 0)

            ret+=tmp;

    }

    cout<<"#"<<caseNum<<" "<<ret<<endl;

}

int main(void)

{

    for(int i=0;i<10;i++)

        solution();

    return 0;   

} 

#include <iostream>

#include <string.h>

using namespace std;

const int STUDENT = 1000;

int T,testNum,ret;

int arr[101];

int main(void)

{

int score;

scanf("%d",&T);

while(T--)

{

int max=0;

memset(arr,0,sizeof(arr));

scanf("%d", &testNum);

for(int i=0; i<STUDENT; i++)

{

scanf("%d", &score);

arr[score]++;

if(arr[score]>max)

max=arr[score];

}

for(int i=0; i<101; i++)

{

if(arr[i]==max)

ret=i;

}

cout<<"#"<<testNum<<" "<<ret<<endl;

}

return 0;

} 

/****************************************************************************************************

자료구조 03 스택과 큐

2018.11.02

3.1 하나의 배열을 사용해 세 개의 스택을 구현

3.2 push와 pop 두 가지 연산과 함께 최솟값을 반환하는 min을 갖춘 스택을 구현

push, pop, min은 O(1)시간에 처리되도록 구현하시오

3.3 접시 무더기 높이가 특정 수준 이상으로 높아지면 새로운 무더기를 만드는 자료구조 SetOfStacks를 구현

SetOfStacks는 여러 스택으로 구성되어야 하며, 이전 스택이 지정된 용량을 초과하는 경우

새로운 스택을 생성해야 한다. push()와 pop()은 스택이 하나인 경우와 동일하게 동작하도록 구현하시오

3.4 하노이탑 문제 

한번에 하나만 옮길 수 있으며 탑의 맨 꼭대기에 있는 원판은 옆에 있는 탑으로 옮길 수 있다.

    원판은 자기보다 지름이 큰 원판 위로만 옮길 수 있다. 스택을 사용하여, 첫 번째 탑에 있는 모든 원판을

마지막 탑으로 옮기는 프로그램을 구현하시오.

****************************************************************************************************/ 

#include <iostream>

#include <algorithm>

#include <vector>

#include <string.h>

#include <string>

using namespace std;

//solve 3.1 -- start

const int STACKSIZE = 100;

int s[STACKSIZE * 3];

int top[3] = {-1, -1, -1}; //3개의 스택 top포인터

int getTop(int nStack)

{

return nStack*STACKSIZE + top[nStack];

}

void push(int nStack, int value)

{

top[nStack]++;

s[getTop(nStack)] = value;

}

int pop(int nStack)

{

int ret = s[getTop(nStack)];

s[getTop(nStack)] = 0; //value 0으로 초기화

top[nStack]--; //top값 1 감소

return ret;

} 

#include <iostream>

#include <algorithm>

#include <vector>

#include <string.h>

#include <string>

using namespace std;

// solve 3.2 push, pop, min O(1)시간 처리 스택 구현

typedef struct node {

int data;

struct node* next;

} Node;

class Stack {

private:

int cnt;

Node* top;

Node* minTop;

public:

Stack();

void push(int);

int pop();

int min();

bool isEmpty();

};

Stack::Stack() {

cnt=0;

top=NULL;

};

void Stack::push(int data) {

Node *newNode = new Node;

newNode->data=data;

if(isEmpty()) {

top=newNode;

minTop=newNode;

} else {

newNode->next=top;

top=newNode;

if(newNode->data <= minTop->data) {

newNode->next=minTop;

minTop=newNode;

}

}

}

int Stack::pop() {

if(isEmpty())

exit(1);

int ret=top->data;

if(minTop->data == ret) {

minTop=minTop->next;

}

top=top->next;

return ret;

}

int Stack::min() {

return minTop->data;

}

bool Stack::isEmpty() {

if( top == NULL )

return true;

else

return false;

}

 //

//  main.cpp

//  AlgorihmStudy

//

//  Created by sw on 2018. 9. 19..

//  Copyright © 2018년 sw. All rights reserved.

//

#include <cstdio>

#include <string.h>

#include <string>

#include <iostream>

#include <algorithm>

#include <queue>

#include <stack>

#include <vector>

#include <functional>

const int INF = 987654321;

using namespace std;

string input;

int dp[10002];

int getLevel(int head, int tail)

{

    string temp=input.substr(head,tail-head+1);

    // 모든 숫자가 같은 경우

    if(temp == string(temp.size(), temp[0]))

        return 1;

    // 숫자가 1씩 단조 증가 || 단조 감소

    bool isProgress=true;

    for(int i=0;i<temp.size()-1;i++)

    {

        if(temp[i+1]-temp[i] != temp[1]-temp[0])

            isProgress=false;

    }

    if(isProgress && abs(temp[1]-temp[0])==1)

        return 2;

    // 두 개의 숫자가 번갈아나타남

    bool isRotate=true;

    for(int i=0;i<temp.size();i++)

    {

        if(temp[i] != temp[i%2])

            isRotate=false;

    }

    if(isRotate)

        return 4;

    // 등차 수열

    if(isProgress)

        return 5;

    // 이외의 모든 경우

    return 10;

}

int solve(int start)

{

    // 기저사례

    if(start == input.size())

        return 0;

    int& ret=dp[start];

    if(ret != -1)

        return ret;

    ret=INF;

    for(int i=3; i<=5; i++)

    {

        if(start+i <= input.size())

            ret=min(ret,solve(start+i) + getLevel(start, start+i-1));

    }

    return ret;

}

int main(int argc, const char * argv[]) {

    int tc;

    scanf("%d",&tc);

    //기저 사례

    if(tc<0 || tc>51)

        exit(-1);

    while(tc--)

    {

        memset(dp,-1,sizeof(dp));

        cin>>input;

        cout<<solve(0)<<endl<<endl;

    }

    return 0;

}