Greedy:三角形问题

　　　　　　　　　　　　　　　　

　　题目大意：有n根长度的为a1,a2....an的棒子，如果棒子可以组成三角形，求这些棒子能组成的三角形的最大周长？

　　这一题，一般人只能想到三重循环，当然我们是CS专业的，不能这样想，其实这题可以用DP（其实也不算DP），就是用o(n^2)的时间算出所有两根棒子的组合，然后再n的时间从大到小匹配

　　其实这一题有更简单的O（nlogn）的算法，那就是，既然我们都要选周长最大的三角形，那为什么我们不能从最大的棒子开始匹配呢？这样一想，其实DP也是在做这样的事情，从最大的开始做起，那么以为棒子的输入是随机的，我们就快排一次，然后从n-2开始往下匹配，完成任务

　　这一题真的是很简单，但是我一开始的时候还是没有想到，看来我还是需要很多锻炼

#include <stdio.h>
#include <stdlib.h>
#define CUTOFF 20

typedef int Position;
void Quick_Sort(Position, Position, Position *);
void Swap(Position, Position,Position *);
int Median_of_Three(Position, Position, Position,Position *);
void Insertion_Sort(Position, Position, Position *);
void Search(Position *, const int);

int main(void)
{
    int n, i;
    while (~scanf("%d", &n))
    {
        if (n == 0)
            break;
        Position *A = (Position *)malloc(sizeof(Position)*n);
        for (i = 0; i < n; i++)
            scanf("%d", &A[i]);
        Quick_Sort(0, n - 1, A);
        Search(A, n);
        free(A);
    }
    return 0;
}

void Swap(Position x, Position y, Position *A)
{
    A[x] ^= A[y];
    A[y] ^= A[x];
    A[x] ^= A[y];
}

int Median_of_Three(Position left, Position mid , Position right,Position *A)
{
    if (A[left] > A[mid])
        Swap(left, mid, A);
    if (A[left] > A[right])
        Swap(left, right, A);
    if (A[mid] > A[right])
        Swap(mid, right, A);
    Swap(mid, right, A);
    return A[right];
}

void Insertion_Sort(Position left, Position right, Position *A)
{
    int i, j, tmp;
    for (i = left + 1; i <= right; i++)
    {
        tmp = A[i];
        for (j = i; j > left && A[j - 1] > tmp; j--)
            A[j] = A[j - 1];
        A[j] = tmp;
    }
}

void Quick_Sort(Position left, Position right, Position *A)
{
    Position mid = (left + right) / 2;
    int i = left, j = right, pivot;
    if (right - left > CUTOFF)
    {
        pivot = Median_of_Three(left, mid, right, A);
        while (i < j)
        {
            while (A[++i] < pivot);
            while (A[--j] > pivot);
            if (i < j)
                Swap(i, j, A);
            else break;
        }
        Swap(i, right, A);
        Quick_Sort(left, i - 1, A);
        Quick_Sort(i + 1, right, A);
    }
    else
        Insertion_Sort(left, right, A);
}

void Search(Position *A, const int n)
{
    int found = 0, i;
    for (i = n - 1; i >= 2; i--)
    {
        if (A[i] < A[i - 1] + A[i - 2])
        {
            printf("%d
", A[i] + A[i - 1] + A[i - 2]);
            found = 1;
            break;
        }
    }
    if (!found)
        printf("0
");
}