2nd/10_Wiki/Topics/Architecture/Problem_Solving.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-problem-solving	Problem Solving	10_Wiki/Topics	verified	self	Problem Solving 문제 해결 decomposition	none	A	0.9	applied	methodology meta decomposition heuristics		2026-05-10	pending	language framework meta methodology

Problem Solving

매 한 줄

"매 큰 문제를 매 작은 문제로 매 쪼개고 매 합쳐라". Problem Solving은 매 ill-defined situation을 매 well-defined sub-problem 으로 매 decompose 하고 매 solve → compose 하는 매 universal methodology. Polya (1945) 부터 매 modern algorithmic thinking, 매 LLM tool-use planning 까지 매 backbone.

매 핵심

매 4-step (Polya)

1. Understand: input/output/constraint 매 명확화.
2. Plan: 매 known problem과 매 mapping, 매 sub-goal 분해.
3. Execute: 매 plan 매 step-by-step.
4. Review: 매 verify, 매 generalize.

매 Heuristic toolkit

• Decomposition: divide-and-conquer.
• Analogy: 매 known problem → 매 transform.
• Working backward: goal에서 매 출발.
• Invariant: 매 변하지 않는 property 매 식별.
• Specialization: 매 simpler case 먼저.
• Generalization: 매 더 일반 case로 매 abstract.

매 응용

1. Algorithm design.
2. System architecture (decomposition into services).
3. Debugging (Problem Solving Skills 참고).
4. LLM agent planning (ReAct, ToT).
5. Research project scoping.

💻 패턴

Decomposition template

# 매 1. Restate
# Goal: 매 sort N items by key with stable + in-place
# Inputs: list[T]; Outputs: list[T] sorted
# Constraints: stable, O(1) extra space, T comparable

# 매 2. Plan — sub-problems
# (a) partition pivot          (in-place quicksort)
# (b) but quicksort 매 unstable → swap to merge sort?
# (c) merge sort 매 not in-place → block merge sort (Wikisort)

# 매 3. Execute — pick block merge sort
def block_merge_sort(a): ...  # 매 implement

# 매 4. Review — invariants, edge cases (empty, dupes, all-equal)

Working backward (puzzle solving)

# Find x such that f(g(h(x))) == target
# Backward: y = f^-1(target); z = g^-1(y); x = h^-1(z)
def backward(target, inverses):
    cur = target
    for inv in reversed(inverses):
        cur = inv(cur)
    return cur

Invariant-based proof (loop)

def gcd(a, b):
    # 매 Invariant: gcd(a0, b0) == gcd(a, b) at every iteration
    while b:
        a, b = b, a % b
    return a

Specialization → Generalization

# 매 Step 1 — special case: 매 sorted list, no duplicates
def find_special(arr, t):
    lo, hi = 0, len(arr)-1
    while lo <= hi:
        mid = (lo+hi)//2
        if arr[mid] == t: return mid
        if arr[mid] < t: lo = mid+1
        else: hi = mid-1
    return -1

# 매 Step 2 — generalize: 매 with duplicates → leftmost binary search
def find_general(arr, t):
    lo, hi = 0, len(arr)
    while lo < hi:
        mid = (lo+hi)//2
        if arr[mid] < t: lo = mid+1
        else: hi = mid
    return lo if lo < len(arr) and arr[lo] == t else -1

LLM agent decomposition (ReAct loop)

# 매 Pseudo-ReAct
def solve(task, llm, tools, max_steps=10):
    history = [{"role": "user", "content": task}]
    for _ in range(max_steps):
        out = llm.chat(history)              # Thought + Action
        if out.is_final: return out.answer
        result = tools[out.action](out.args)  # Observation
        history += [out.message, {"role": "tool", "content": result}]
    return None

매 결정 기준

상황	Approach
Algorithm puzzle	Polya + decomposition
System design	Component decomposition + interface
Debugging	Problem Solving Skills (repro/bisect)
Research	Specialization → generalization
LLM agent	ReAct / Tree-of-Thoughts

기본값: Understand → Decompose → Solve smallest → Compose → Review.

🔗 Graph

• 부모: Methodology · Engineering-Mindset
• 변형: Polya-Method · Divide-and-Conquer · Working-Backward
• 응용: Algorithm-Design · System-Architecture · LLM-Agent-Planning
• Adjacent: Problem Solving Skills · Heuristic · ReAct

🤖 LLM 활용

언제: ill-defined task scoping, 매 multi-step planning, 매 agentic workflow 설계. 언제 X: 매 1-line trivial task.

❌ 안티패턴

• 매 Skip understanding: 매 problem 매 명확하지 않은 채 매 코딩 시작.
• 매 Premature optimization: 매 sub-problem 매 미해결인데 매 perf tune.
• 매 No review: 매 동작하면 매 commit, 매 generalization 안 함.
• 매 Cargo-cult algorithm: 매 비슷한 문제의 매 solution 매 무비판 복붙.

🧪 검증 / 중복

• Verified (Polya "How to Solve It" 1945, Schoenfeld "Mathematical Problem Solving" 1985).
• 신뢰도 A.
• 관련: Problem Solving Skills (debugging-focused sibling).

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Polya + heuristic toolkit + algorithmic patterns