Greedy algorithms represent a straightforward approach to problem-solving where, at each stage, the algorithm makes a locally optimal choice with the expectation that this choice will lead to a globally optimal solution. This strategy is particularly effective for problems exhibiting optimal substructure. However, it's crucial to recognize that a greedy approach doesn't always guarantee a globally optimal result; it may sometimes yield only a locally optimal soultion.

Core Principles of Greedy Algorithms:

1. Mathematical Modeling: Abstract the problem into a mathematical model. This involves defining the states, the objective function, and any constraints.
2. Prove Greedy Choice Property: This is fundamental. Demonstrate that a globally optimal solution can indeed be constructed by making a sequence of locally optimal (greedy) choices.
3. Algorithm Design: Develop the greedy algorithm based on the proven greedy choice property, constructing the solution incrementally.
4. Correctness Analysis: Prove that the greedy algorithm yields the globally optimal solution, or atleast an acceptable approximation in certain scenarios.

Characteristics of Greedy Algorithms:

• Greediness: At each step, the algorithm selects the best available option in the current state.
• Local Optimality: Aims to build a global optimum through a series of local optima.
• No Guarantee of Global Optimality: For some problems, greedy choices might lead to a suboptimal outcome.

The Knapsack Problem Example:

Consider a scenario with multiple items, each having a specific weight and value. The goal is to maximize the total value of items placed in a knapsack without exceeding its weight capacity.

• Greedy Strategy: Prioritize items with the highest value-to-weight ratio.
• Caveat: This greedy strategy is not always foolproof for the knapsack problem. In some cases, selecting items with a lower value-to-weight ratio might be necessary to achieve the overall maximum value. Consequently, the knapsack problem is often better addressed using dynamic programming.

Greedy Algorithms vs. Dynamic Programming:

• Dynamic Programming: Typically tackles problems with overlapping subproblems and optimal substructure. It enhances efficiency by storing and reusing solutions to subproblems, thereby avoiding redundant computations.
• Greedy Algorithms: Make the best choice at each step, aiming for a global optimum through local optimizations. They generally have lower space complexity as they don't store subproblem solutions. However, they lack the guarantee of global optimality.

In summary, greedy algorithms offer a simple and effective design paradigm, especially for problems possessing the greedy choice property. Nonetheless, understanding their limitations is vital to avoid incorrect solutions when applied to unsuitable problems.

Here are two illustrative coding problems:

Finding the Shortest Unsorted Continuous Subarray

import java.util.Arrays;

class Solution {
    /**
     * Finds the length of the shortest subarray that, if sorted,
     * would make the entire array sorted.
     * @param nums The input integer array.
     * @return The length of the shortest unsorted subarray.
     */
    public int findUnsortedSubarray(int[] nums) {
        int n = nums.length;
        int maxSoFar = Integer.MIN_VALUE;
        int end = -1;
        int minSoFar = Integer.MAX_VALUE;
        int start = -1;

        // Scan from left to right to find the rightmost out-of-order element
        for (int i = 0; i < n; i++) {
            if (maxSoFar > nums[i]) {
                end = i;
            } else {
                maxSoFar = nums[i];
            }
        }

        // Scan from right to left to find the leftmost out-of-order element
        for (int i = n - 1; i >= 0; i--) {
            if (minSoFar < nums[i]) {
                start = i;
            } else {
                minSoFar = nums[i];
            }
        }

        // If no out-of-order elements were found, the array is already sorted.
        return (end == -1) ? 0 : (end - start + 1);
    }
}

Constructing the Largest Number

import java.util.Arrays;
import java.util.Comparator;

class Solution {
    /**
     * Forms the largest possible number by arranging a list of non-negative integers.
     * @param nums An array of non-negative integers.
     * @return A string representing the largest number formed.
     */
    public String largestNumber(int[] nums) {
        // Convert integers to strings for custom comparison
        String[] numStrs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            numStrs[i] = String.valueOf(nums[i]);
        }

        // Custom comparator to sort strings based on concatenated order
        // e.g., if x="3", y="30", then y+x="303", x+y="330". "330" > "303", so x comes before y.
        Comparator<String> customComparator = (x, y) -> (y + x).compareTo(x + y);
        Arrays.sort(numStrs, customComparator);

        // If the largest number starts with '0', it means all numbers were 0.
        if (numStrs[0].equals("0")) {
            return "0";
        }

        // Concatenate the sorted strings to form the largest number
        StringBuilder resultBuilder = new StringBuilder();
        for (String s : numStrs) {
            resultBuilder.append(s);
        }

        return resultBuilder.toString();
    }
}