算法_动态规划_图像压缩

import java.util.Scanner;
public class Main {
    private static int n;//像素点总个数
    private static int[] p;//像素点灰度值序列
    private static int[] s;//s[i]:像素序列{p1,p2,...,pk}的最优分段所需的存储位数
    private static int[] next;//每一个连续像素段的最后像素点对应的下标

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        compress();
        print();
    }
    private static void print(){
        System.out.println("存储整个像素序列所需的最少存储位数为"+s[n]);
        int k=n;

        //通过next[]数组找到每个连续像素段的最后像素点对应的下标，也就是分段工作
        while(k!=0){
            System.out.println("p"+(next[k]+1)+"--->p"+k+"  需要的存储位数为："+(s[k]-s[next[k]]));
            k=next[k];
        }
    }

    //计算s[1],s[2],...,s[n](动态规划的主要思想在这里体现)
    private static void compress(){
        for(int i=1;i<=n;i++){
            s[i]=Integer.MAX_VALUE;
            for(int k=1;k<=Math.min(i,256);k++){
                int temp=s[i-k]+k*bMax(i-k+1,i)+11;
                if(temp<s[i]){
                    s[i]=temp;
                    next[i]=i-k;
                }
            }
        }
    }

    //初始化先前定义的各项参数
    private static void init(){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        p=new int[n+1];
        s=new int[n+1];
        next=new int[n+1];

        for(int i=1;i<=n;i++){
            p[i]=sc.nextInt();
        }
    }

    //求存储p[i],p[i+1],...,p[j]中的最大值所需的最少位数（也即这个连续段中每个像素点所需的存储位数）
    private static int bMax(int i,int j){
        int pMax=-1;
        for(int k=i;k<=j;k++){
            if(p[k]>pMax){
                pMax=p[k];
            }
        }
        return (int)Math.ceil(Math.log(pMax+1)/Math.log(2));
    }

}