Recursive solution

For a given set, S,

whereas + and - signs denote set addition and set subtraction respectively.

Python implementation

def permutation(set):
        if set == []:
                return [[]]
        else:
                r = []
                for i in xrange(0, len(set)):
                        for p in permutation(set[0:i] + set[i+1:]):
                                r.append([set[i]] + p)
                return r

Results

>>> print permutation([1, 2, 3])
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

I wouldn't say this particular implementation is the most efficient one, but at least we know it works with up to a certain size of set. Sadly, we all have machines with a finite size of memory, our machine will produce stack overflow if your set is too big.

I think languages like Haskell would work very efficiently with this kind of recursive solution due to its beautiful features like lazy evaluation, tail recursion, etc. Please feel free to share your solution or implementation.

Optional discussion section meets on Wednesday, 7-8pm at FCS 101

Largest Empty Rectangle Problem

Divide and conquer

function DivideAndConquer(A, m, n) begin
    PrecomputeLeftRuns(...)
    PrecomputeRightRuns(...)
    return DivAndConq(A, m, 1, n, L, R)
end

DevAndConq()

PrecomputeLeftRuns() + PrecomputeRightRus()

Total number of rectangles

[m 2]          * [n 2]           = m*(m-1)/2 * n*(n-1)/2
(pair of rows)   (pair of cols)  theta(m^2)  theta(n^2)

To sum up, for Largest Empty Rectangle, we've seen following algorithms:

• Exhaustive search ( time)
• [Optimized exhaustive search ( time)]
• Divide and conquer ( time)
• [Dynamic programming ( time)]
• [Amortization ( time)] (optimal)

• Office hours posted on the course webpage: M-F
• Optional discussion section will be on Wednesdays at 7-8pm

Problem (Largest Monochromatic Rectangle)

Given an m*n boolean array A[1:m, 1:n] of zeroes and ones, find a subarray A[i:k, j:l] that contains only zeros.

Exhaustive Search (examine all possibilities; pick the best one)

function exhaustive(A, m, n) begin * returns the area of the largest solution
a := 0
for i := 1 to m do
for j := 1 to n do
for k := i to m do
for l := j to n do begin
scan A[i:k, j:l]
if it contains only zeroes then
a := max{a, (k-i+1)*(l-j+1)}
end (for)

return a
end (function)

• (a) scan - a := max{}
• (b) for l:= j to n
• (c) for k := i to m
• (d) for j := 1 to n
• (e) for i := 1 to m

Analysis

• (a)

• (b)

• (c)

• (d)

• (e) : time for exhaustive search without any optimization

Notations and Formulas

• upper- and lower-bounded by constant times f(n)
• upper-bounded by constant times f(n)

• lower-bounded by constant times f(n)

• (almost always)

• 

Divide and Conquer

Cut the input array vertically at the middle column. Then the optimal rectangle falls into three cases:

1. It lies strictly in left half. (recurse)
2. It lies strictly in right half. (recurse)
3. It spans the middle. (some work to do)

If we cut it at the middle column, it breaks into a left rectangle that ends at the middle column and is optimal, and a right rectangle that starts at the middle column and is optimal. (where the start and end rows i and k are fixed -> new subproblem!)

LCS(X, Y)
    for(i=1; i<=m; i++) L[i, 0] = 0
    for(j=0; j<=n; j++) L[0, j] = 0
    for(i=1; i<=m; i++)
        for(j=1; j<=n; j++)
            if(x[i] == y[j])
                L[i, j] = 1 + L[i-1, j-1]
            else if(L[i-1, j] >= L[i, j-1])
                L[i, j] = L[i-1, j]
            else
                L[i, j] = L[i, j-1]

bubblesort(A)
    N = the number of elements in A
    for(i=0; i<n; i++)
        for(j=0; j<n-(i+1); j++)
            if(A[j] > A[j+1]) swap(A[j], A[j+1])
        end
    end
end

기본 원리는 아주 간단하다: 뒤쪽부터 올바른 값으로 채워넣는다. Insertion Sort 와 상반되는 방법이라고도 할 수 있다.

15, 38, 2, 1, -3, -10, 0, 11, -2, 9

이러한 자료를 담고 있는 배열을 정렬한다고 할 때

15, 2, 1, -3, -10, 0, 11, -2, 9, 38
2, 1, -3, -10, 0, 11, -2, 9, 15, 38
1, -3, -10, 0, 2, -2, 9, 11, 15, 38
-3, -10, 0, 1, -2, 2, 9, 11, 15, 38
-10, -3, 0, -2, 1, 2, 9, 11, 15, 38
-10, -3, -2, 0, 1, 2, 9, 11, 15, 38
-10, -3, -2, 0, 1, 2, 9, 11, 15, 38
-10, -3, -2, 0, 1, 2, 9, 11, 15, 38
-10, -3, -2, 0, 1, 2, 9, 11, 15, 38
-10, -3, -2, 0, 1, 2, 9, 11, 15, 38

이런식으로 동작한다. 여기서 이야기를 멈추면 중학생 수준의 포스트가 되어버리므로 계속 진행하겠다.

문제점

1, 2, 3, 4, 5, 6, 7, 8, 9, 10

위와 같이 이미 정렬되어있는 배열을 정렬하려고 할 경우 똑똑하지 못한 모습을 보여준다. 더이상 정렬할 필요가 없는데도 불구하고 sig(i, 1, N-1) 번 실행된다.

발전된 형태의 알고리즘

bubblesort(A)
    flag = N
    while(flag > 0)
        k = flag - 1
        flag = 0
        for(j=0; j<k; j++)
            if(A[j] > A[j+1])
                swap(A[j], A[j+1])
                flag = j + 1
            end
        end
    end
end

이미 정렬 되어있는 배열의 경우 O(N) 의 실행시간을 보여준다 (best case). flag 가 하는 역할에 주목할 필요가 있다. 이미 정렬된 부분을 표시함으로써 불필요한 연산을 하지 않도록 만들어준다.

각자 좋아하는 언어로 직접 구현해서 코멘트나 트랙백 다는것도 재밌을것 같다 ;-)

In the program spec, Dr. Moon wrote that a family of hash functions would be created by h sub k(s) = MyUtil.ELFhash(s, 2^k) for k > 0. Since M = 2^k, in order to find the value of k (so we can pass it into the argument of ElfHash when creating the extended function), we need to find the log2(M), am I correct? If so, how do I find this in Java? I cannot find any fuctions in Java's math utility that returns the log base 2 of a number.

메일링 리스트에 대략 이런 내용의 글을 올린 사람이 있어서 잠시 log(N) 의 값을 구하는 방법에 대해서 생각해보게 되었다. 사실 구할 필요도 없긴 하지만.

log(N)
    c = 0
    while(N > 1)
        N = N >> 1
        c = c + 1
    end
    return c
end

대략 의사 코드(pseudo code)로 작성해보았다. 길이가 짧기도 하고 복잡한 조건도 없어서 아주 예뻐보인다 :D

public int log(int n) {
    int c = 0;
    while(n > 1) {
        n = n >> 1;
        c++;
    }
    return c;
}

자바로는 이렇게 구현하면 될까나... 어떤 언어든지 1분 내로 구현할 수 있다고 본다. 어셈블리어는 제외.

이미 눈치 챈 사람도 있겠지만, N 의 값이 2의 k제곱이 아닐때에는 결과값이 floor of log(N) 이 된다. 아~ 이거 의외로 쓸만할지도 모르겠다.

수식은 MS Word 에서 Microsoft Equations 3.0 객체를 이용해서 입력했다. 실제 시험에서도 제발 이렇게만 나왔으면 좋겠다. 내가 한게 맞는건지는 잘 모르겠지만-_-a

Tree

여기 잘 만들어진 나무가 있다. Visio 를 이용해서 그렸다-_-v 중위 표기법으로 표현된 수식을 이러한 형식으로 변환하는 과정은 생략하겠다 :P

왜냐고 물으면 딱히 할 말이 없다. 그냥 귀찮아서? 이게 정답인것 같다. 괄호로 완벽하게 묶인(fully-parenthesized) 식이라면 몰라도 실세계에서 흔히 접하는 수식은 경우에 따라서 해석하기 난해할 수도 있다. 예를 들면 -8 / -1/2(2 + 4)(-3 + 1) 이런거...

연산자 후위 표기 (Postfix)

postfix(tree)
    if(tree is null) return

    postfix(tree.left)
    postfix(tree.right)
    print(tree.value)

의사 코드(pseudo code)이다. 이걸 보고 어떤 프로그래밍 언어냐고 묻는 사람은 없을거라고 믿는다.

1 2 + 3 4 - * 5 6 + *

연산자 후위 표기와 전위 표기의 주된 장점중 하나는 괄호 없이 연산자 우선순위를 명시할 수 있다는 것이다. 예를 들어서, a + b * c 와 같은 식의 연산자 우선순위를 바꾸려면 (a + b) * c 와 같이 괄호를 써줘야 한다. 하지만 후위 표기법으로 나타내면 전자는 a b c * +, 후자는 a b + c * 와 같이 나타낼 수 있다.

고등학생때 간단한 사칙연산 해석기(parser)를 만들었었는데, 그때도 후위 표기법을 사용했던걸로 기억한다. 중위 표기법으로 표현된 수식을 해석해서 후위 표기법으로 바꿔 스택에 넣으면 아주 간단하게 수식의 결과를 얻을 수 있다.

연산자 전위 표기 (Prefix)

prefix(tree)
    if(tree is null) return

    print(tree.value)
    postfix(tree.left)
    postfix(tree.right)

전위 표기법은 실제로 사용해본적이 없는것 같다.

* * + 1 2 - 3 4 + 5 6

연산자 중위 표기 (Infix)

대부분의 사람들한테 친숙한 표기법이다. 정규 교과 과정에 수학 과목이 포함되어있고, 정규 교과 과정에서 다루는 수학에서는 중위 표기법을 쓰니까.

infix(tree)
    if(tree is null) return

    infix(tree.left)
    print(tree.value)
    infix(tree.right)

이렇게 하면 될까?

1 + 2 * 3 - 4 * 5 + 6

대충 모양이 나오는것 같지만, 연산자 우선순위가 엉망이 되어버렸다. 연산자 중위 표기를 위해서는 약간의 추가적인 작업을 해줘야 한다.

infix(tree)
    if(tree is null) return
    if(tree.value is an operator) print("(")

    infix(tree.left)
    print(tree.value)
    infix(tree.right)

    if(tree.value is an operator) print(")")

결과는?

(((1 + 2) * (3 - 4)) * (5 + 6))

괄호 덕분에 연산자 우선순위가 바로잡혔다.

마무리

고등학생때(아마 2학년때였을 거다) 이러한 내용들을 알게 되었을때 뭔가 커다란 깨달음을 얻은것 같은 느낌이었다. 중3때 C언어 처음 만져봤을때처럼. 그때부터 이쪽으로 계속 연구했었다면 지금쯤 컴파일러 하나쯤 개발했을지도 모르겠다. 아하하...

1. 괄호 없이 연산자 우선순위 평가
2. 생략된 연산자 인식 (5(b + c) = 5 * (b + c))
3. 단일 연산자 구분 (a + -b)
4. 할당 연산자 (=)

이정도만 구현해도 꽤 괜찮은 수식 해석기를 만들 수 있을거라고 생각한다. 관심 있는 사람은 한번 도전해보길 바란다.

이게 뭐꼬 ㅠ_ㅠ;

지금 학교에서 듣고있는 Calculus 1도 그렇게 만만한 과목은 아닌데.. 이 책을 보고, 또 앞으로 배워야 할 수학(대학 졸업 하려면-_-)을 생각해보니까 지금까지 내가 공부해왔던 수학이 보잘것 없이 느껴진다. Calculus II, Calculus III, Linear Algebra... 앞으로 수학을 아주아주 열심히 공부해야겠다는 생각이 든다.