图像压缩

#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#define MAX 100  

int length(int n) 
{
    int i=n/2;
    int l = 1;
    while(i>0)
    {
        l++;
        i /= 2;
    }
    return l;
}

//灰度值序列长度为n
//各灰度值保存在p[]中
//l[i]为为第i段灰度值长度
//b[i]为存储第i个灰度值所需位数
//s[i]存储为前i段灰度值所需最小存储空间
void Compress(int n, int p[], int l[], int b[], int s[])
{
    int lmax = 256, header = 11;
    int i, k;
    s[0] = 0; 
    for(i=1; i<=n; i++)  //子段规模
    {
        b[i] = length(p[i]);  //像素点pi所需的存储位数
        int bmax = b[i]; //初始最优值
        l[i] = 1;  //初始最后一段只有一个像素
        s[i] = s[i-1] + bmax;  
        for(k=2; k<=i && k<=lmax; k++)  //检测每个规模中的每个截断点
        {                          //k为最后一段长度
            if(bmax < b[i-k+1]) //寻找当前规模下最后一段的最大存储位数 
                bmax = b[i-k+1];
            int temp = s[i-k] + k*bmax;  
            if(temp<s[i])
            {
                s[i] = temp;
                l[i] = k;
            }
        }
        s[i] += header;
    }
}

//最优分段的最后一段的段长度和像素位数存储于l[n] b[n]中
//前一段的段长度和像素位数存储于l[n-l[n]] b[n-l[n]]中
//i记录分了多少段
void TraceBack(int n, int &i, int s[], int l[]) //构造最优解
{
    if(n==0)
        return;
    TraceBack(n-l[n], i, s, l);
    s[i++] = n-l[n];  //s[]重新赋值，存储分段位置
}

void print(int s[], int l[], int b[], int  n)
{
    printf("图像压缩后所需最小空间为：%d\n", s[n]);
    int m = 0;
    TraceBack(n, m, s, l);
    int k;
    s[m] = n;  
    printf("共分成%d段\n", m);
    for(k=1; k<=m; k++)
    {
        l[k] = l[s[k]];
        b[k] = b[s[k]];
    }
    for(k=1; k<=m; k++)
        printf("段长%d, 位数%d\n", l[k], b[k]);
}

int main()
{
    int p[MAX], s[MAX], l[MAX], b[MAX], n, i;
    printf("输入灰度值序列个数：\n");
    scanf("%d", &n);
    printf("依次输入各灰度值：");
    for(i=1; i<=n; i++)
        scanf("%d", &p[i]);
    Compress(n, p, l, b, s);
    print(s, l, b, n);
    return 0;
}