35. Best Time to Buy and Sell Stock

08 Jul 2020 | Daily Algorithms

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxpro = 0;
        int minprice = INT_MAX;
        for(int i =0; i<prices.size();i++)
        {
            minprice = min(minprice, prices[i]);
            maxpro = max(maxpro, prices[i]-minprice);
        }
        return maxpro;

    }
};

minPrice is the minimum price from day 0 to day i. And maxPro is the maximum profit we can get from day 0 to day i. How to get maxPro? Just get the larger one between current maxPro and prices[i] - minPrice.
만약 맨 끝단에 자기 자신이 minprice가 된다면, max pro에서 스스로 뺴기 떄문에 0이 되므로 maxpro는 그대로 남는다.

Comment Read more

34. climbing Stairs

08 Jul 2020 | Daily Algorithms

class Solution {
public:
    int climbStairs(int n) {
        if(n<=1)
        {
            return n;
        }
        vector<int> steps(n,0); // n 행렬, element 값 0
        steps[0] = 1;
        steps[1] = 2;
        for(int i=2; i<n; i++)
        {
            steps[i] = steps[i-2] + steps[i-1];
        }
        return steps[n-1];

    }
};

Array ‘steps’ stands for how many distinct(明显) ways to climb to each level (index from 0, so 0 means level 1, 1 means level 2 and so on…. ). It’s trivial to know it has 1 distinct way to climb to stair 1 , and 2 distinct ways to climb to stair 2 . For stair level n (n>=3) , you can either (1) climb to stair n-2 , and climb 2 more steps to reach n , OR (2) climb to stair n-1, and climb 1 more step to reach n. That said , steps[n]=steps[n-1]+steps[n-2]. In another word, the number of distinct ways to reach level n is the sum of number of distinct ways to reach level n-1 and n-2.
확률적인 개수가 몇개인지 알아보려고 할떄 steps[n]=steps[n-1]+steps[n-2] 많이 쓰인다.
Fibonacci 방법중에 하나이다.

Comment Read more

나를 만드는 말들

07 Jul 2020 | daily

사람의 집중력은 길지 않다. 그러니 짧은 시간에 큰 집중하자.

인생은 속도가 아니라 방향이다.

눈길을 걸을 때 어지럽게 걷지 말기, 오늘 내가 걸어온 길이 훗날 다른 사람에 이정표가 되니

약자는 그것을 걸림돌이라 하지만 강자는 디딤돌이라 한다.

실패는 거름이다.

대담하게 살자, 안주하지 말자, 끝까지 밀어붙이자.

어리석은자는 멀리서 행복을 찾고, 현명한자는 발치에서 행복을 찾는다.

실패한 것이 부끄러운 것이 아니라 도전하지 못한 것이 부끄러운 것이다.

아무튼 저지르고 봐야해, 옳다고 생각되면 그럼 그때 해야해.

꿈을 크게 가져라, 깨져도 그 조각은 크다.

타임머신이 있다면 미래로 가고 싶나 과거로 가고 싶나.

술로 만들어진 관계는 훗날 술병처럼 허무하다.

목표를 낮추지 말고 노력을 높여라.

내가 지금 편안하다는 것은 내리막길을 걷고 있다는 뜻이다.

살면서 적당히 보다, 미쳤다라는 소리 한번 들어볼 만큼 열심히 하자.

나의 꿈 나의 미래, 내 삶의 비전들, 그리고 그들의 세상을 토론하자.

나만의 가치를 올리는 방법을 생각하자.

변하지 않는 방향, 나만 할 수 있는 일(나라는 사람의 가치), 내 위치가 어디인지 파악, 나의 수준, 성공한 사람보다 가치있는 사람이 되자(아이슈타인)

뇌나 사람은 게으르다, 쓸면서 늘리자

하루에 50만원씩 버는 것이 목표!

김군, 도인비

영어, 중국어 마스터

규칙적인 생활 하자

심도있게 고민하고 공부하자

연구에 재미를 붙이자.

진중이 처럼 열심히

목표를 이루기 위해 성실히 하자

많은 프로젝트와 계획은 도움이 된다. 최대한 많은 프로젝트하자.

낮은 자세로 사람을 대하자.

젊었을때 실력을 길러야 한다.

아무것도 하지 않으면, 아무것도 이뤄지지 않는다.

젊었을 때 경험은 인생을 더 아름답게 해준다.

도전 도전 도전!

힘되는 말 자주 하기

사소한 일이더라도 칭찬하기

취미로 기타나 음악

하루에 모든 과목 한시간씩 공부

목표하는 회사 직무를 중심적으로 수강신청

평소에 중국어 영어 생활화하여 실력을 늘리자

취미생활을 하면서 풍요로운 삶을 살자

항상 스스로 다독이고 어려운 일도 취미 생활 처럼 나아가자

운동은 나를 위해 노동한 몸에 대한 휴식과 보상이다.

메일 철봉 그리고 스트레칭 하자

전공 수학 공부 철저

운동과 공부는 자존감과 자신감을 찾아준다.

기회는 준비된 자에게만 온다.

할땐 하고 놀땐 놀고

我以研究的方向展教授

不学习就退了

두려움을 용기로

시간 낭비하지 말자

내가 주도적으로 성과 낼 수 있는 일 하고 싶다.

2년이라는 시간 동안 나만의 무기를 만들자

Extraordinary, seize my day.

싯다르타 책

화는 백해무익이다.

최악의 상황을 생각한다.

이쁜말 하자

젊었을 때 시간을 잘 활용하자.

현재에 시간 지금 이 순간이 제일 중요하다.

내 주변 돌아오지 않는 시간을 내가 정말 원하는 것으로 이루자.

3개국어 엔지니어

Comment Read more

33. First Bad Version

06 Jul 2020 | Daily Algorithms

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int lower = 1, upper = n;
        int mid=0;
        while(lower<upper)
        {
            mid = lower+(upper-lower)/2;
            if(!isBadVersion(mid)) // 만역 버전이 bad가 아니면
            {
                lower = mid + 1; // only one call to API
            }
            else // 만역 버전이 bad이면
            {
                upper = mid;
            }
        }
        return lower; // because there will alway be a bad version, return lower here

    }
};

Comment Read more

32. Merge Sorted Array

06 Jul 2020 | Daily Algorithms

My Solution

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        unordered_map<int,int> mp;
        vector<int> result;
        if(nums1.size()<1 || nums2.size()<1)
        {
            return;
        }
        int max =0;
        if(nums1[0]<0 || nums2[0]<0)
        {
            for(int i =0; i<m;i++)
            {
                mp[nums1[i]+1]+=1;
                if(nums1[i]>max)
                    max = nums1[i];
            }            
            for(int i=0; i<n;i++)
            {
                mp[nums2[i]+1]+=1;
                if(nums2[i]>max)
                    max = nums2[i];
            }
            int i =0;
            int size_ = m+n;
            int iter = (max>size_)?max:size_;
            cout<<iter;
            while(i<=iter+1)
            {
                if(mp[i]>=1)
                {
                    result.push_back(i-1);
                    mp[i]--;
                }
                else
                {
                    i++;
                }
            }
        }
        else
        {
            for(int i =0; i<m;i++)
            {
                mp[nums1[i]]+=1;
                if(nums1[i]>max)
                    max = nums1[i];
            }
            for(int i=0; i<n;i++)
            {
                mp[nums2[i]]+=1;
                if(nums2[i]>max)
                    max = nums2[i];
            }
            int i =0;
            int size_ = m+n;
            int iter = (max>size_)?max:size_;
            while(i<=iter+1)
            {
                if(mp[i]>=1)
                {
                    result.push_back(i);
                    mp[i]--;
                }
                else
                {
                    i++;
                }
            }
        }

        nums1=result;


    }
};

other

This code relies on the simple observation that once all of the numbers from nums2 have been merged into nums1, the rest of the numbers in nums1 that were not moved are already in the correct place

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i = m-1;
        int j = n-1;
        int tar =m+n-1; // calculate the index of the last element of the merged array

        // go from the back by A and B and compare and put to the A element which is larger
        // 뒤에서부터 채운다
        while(j>=0)
        {
            nums1[tar--] = (i>=0 && nums1[i]>nums2[j])?nums1[i--]:nums2[j--];
        }


    }
};

Comment Read more

for Robot Artificial Inteligence

35. Best Time to Buy and Sell Stock

34. climbing Stairs

나를 만드는 말들

33. First Bad Version

32. Merge Sorted Array

My Solution

other