动态规划：假设前n-1本的取书方案已经解决，单独考虑第n本的取舍，如果保留第n本增加了已知的不整齐度，则取掉第n本。
首先要按高度进行排序。
dp[i][j] //以i结尾,已取好j本书
初始化：
dp[1][0]=0;
for(i=2;i<=n;i++) dp[i][0]=dp[i-1][0]+Math.abs(w[i]-w[i-1]);
方程：
dp[i][j]=min{dp[i-p-1][j-p]+abs(w[i]-w[i-p-1])}，0<=p<=j，0<=j<=k
ans=min(dp[n-i][k-i)]) ，0<=i<=k

import java.util.*;
import java.io.*;
import java.math.*;

public class ACM_1772{
    
    public static void main(String rgs[]) throws Exception
    {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));    
        String line = stdin.readLine();
        StringTokenizer st = new StringTokenizer(line);
        int n = Integer.parseInt(st.nextToken()); 
        int k = Integer.parseInt(st.nextToken());
        int i,j,k1,p,tmp;
        int[] h = new int[201];
        int[] w = new int[201];
        for(i=1;i<=n;i++){
            line = stdin.readLine();
            st = new StringTokenizer(line);
            h[i] = Integer.parseInt(st.nextToken());
            w[i] = Integer.parseInt(st.nextToken());
        }        
        for(i=1;i<n;i++){
            k1=i;
            for(j=i+1;j<=n;j++){
                if(h[k1]>h[j])
                    k1=j;
            }
            if(k1!=i){
                tmp=h[k1];
                h[k1]=h[i];
                h[i]=tmp;
                tmp=w[k1];
                w[k1]=w[i];
                w[i]=tmp;
            }
        }        
        int[][] dp =new int[201][201];
        dp[1][0]=0;
        for(i=2;i<=n;i++)
            dp[i][0]=dp[i-1][0]+Math.abs(w[i]-w[i-1]);        
        for(i=1;i<=n;i++){
            for(j=1;j<=k;j++){
                if(j>=i)
                    break;                    
                  dp[i][j]=0xffffff;
                  if(j==i-1)
                      dp[i][j]=0;
                  else{
                      for(p=0;p<=j;p++){
                         tmp=dp[i-p-1][j-p];
                         tmp=tmp+Math.abs(w[i-p-1]-w[i]);
                         if(tmp<dp[i][j])
                            dp[i][j]=tmp;
                    }
                }
            }
        }        
        int min=dp[n][k];
        for(i=1;i<=k;i++){
              if(dp[n-i][k-i]<min)
                  min=dp[n-i][k-i];
          }
        System.out.println(min);      
    }
}

1. 输入：
格式为：Scanner cin = new Scanner (new BufferedInputStream(System.in));

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main
{
    public static void main(String[] args) 
    {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int a; double b; BigInteger c; String d;
        a = cin.nextInt(); b = cin.nextDouble(); c = cin.nextBigInteger(); d = cin.nextLine(); // 每种类型都有相应的输入函数.
    }
}

2. 输出
函数：System.out.print(); System.out.println(); System.out.printf();
System.out.print(); // cout << …;
System.out.println(); // cout << … << endl;
System.out.printf(); // 与C中的printf用法类似.

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main
{
    public static void main(String[] args) 
    {
        int a; double b;
        a = 12345; b = 1.234567;
        System.out.println(a + " " + b);
        System.out.printf("%d %10.5f\n", a, b); // 输出b为字宽为10，右对齐，保留小数点后5位，四舍五入.
    }
}

规格化的输出：
函数：
// 这里0指一位数字，#指除0以外的数字(如果是0，则不显示),四舍五入.
    DecimalFormat fd = new DecimalFormat("#.00#");
    DecimalFormat gd = new DecimalFormat("0.000");
    System.out.println("x =" + fd.format(x));
    System.out.println("x =" + gd.format(x));

3. 字符串处理
java中字符串String是不可以修改的，要修改只能转换为字符数组.

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main
{
    public static void main(String[] args) 
    {
        int i;
        String st = "abcdefg";
        System.out.println(st.charAt(0)); // st.charAt(i)就相当于st[i].
        char [] ch;
        ch = st.toCharArray(); // 字符串转换为字符数组.
        for (i = 0; i < ch.length; i++) ch[i] += 1;
        System.out.println(ch); // 输出为“bcdefgh”.
        if (st.startsWith("a")) // 如果字符串以'0'开头.
        {
            st = st.substring(1); // 则从第1位开始copy(开头为第0位).
        }
    }
}

4. 高精度
BigInteger和BigDecimal可以说是acmer选择java的首要原因。
函数：add, subtract, divide, mod, compareTo等，其中加减乘除模都要求是BigInteger(BigDecimal)和BigInteger(BigDecimal)之间的运算，所以需要把int(double)类型转换为BigInteger(BigDecimal)，用函数BigInteger.valueOf().

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main
{
    public static void main(String[] args) 
    {
        int a = 123, b = 456, c = 7890;
        BigInteger x, y, z, ans;
        x = BigInteger.valueOf(a); y = BigInteger.valueOf(b); z = BigInteger.valueOf(c);
        ans = x.add(y); System.out.println(ans);
        ans = z.divide(y); System.out.println(ans);
        ans = x.mod(z); System.out.println(ans);
        if (ans.compareTo(x) == 0) System.out.println("1");
    }
}

5. 进制转换
java很强大的一个功能。
函数：
String st = Integer.toString(num, base); // 把num当做10进制的数转成base进制的st(base <= 35).
int num = Integer.parseInt(st, base); // 把st当做base进制，转成10进制的int(parseInt有两个参数,第一个为要转的字符串,第二个为说明是什么进制).  
BigInter m = new BigInteger(st, base); // st是字符串，base是st的进制.

(1).如果要将一个大数以2进制形式读入 可以使用cin.nextBigInteger(2);
当然也可以使用其他进制方式读入；
(2).如果要将一个大数转换成其他进制形式的字符串 使用cin.toString(2);//将它转换成2进制表示的字符串
例程：POJ 2305

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
    public static void main(String[] args)
    {
        int b;
        BigInteger p,m,ans;
        String str ;
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        while(cin.hasNext())
        {
            b=cin.nextInt();
            if(b==0)
                break;
            p=cin.nextBigInteger(b);
            m=cin.nextBigInteger(b);
            ans=p.mod(m);
            str=ans.toString(b);
            System.out.println(str);
        }
    }
}

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main
{
    public static void main(String[] args) 
    {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int n = cin.nextInt();
        int a[] = new int [n];
        for (int i = 0; i < n; i++) a[i] = cin.nextInt();
        Arrays.sort(a);
        for (int i = 0; i < n; i++) System.out.print(a[i] + " ");
    }
}

7. POJ高精度题目汇总：
POJ 1131 1205 1220 1405 1503 1604 1894 2084 2305 2325 2389 2413 3101 3199

对于ans+=a[i]&a[j], 实际上是加上sum{2^i}(0<=i<k && c[i] == 1)其中c[i] 是a[i]&a[j]用二进制表示时第i位的值，k代表a[i]&a[j]用二进制表示时共有几位

所以，我们可以统计所有输入的数，当它们用二进制表示时，第 i位为1时的次数，咱们用c[i]表示（注意此c[i]跟上面的c[i]意义不一样）,观察到, 当某位出现的次数为n时，其加到ans上的次数应为n*n,由些可得

ans = sum{2^i*c[i]*c[i]}(0<=i<k) k表示这些数中用二进制表示时的最大位数.

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

偶是华丽的分割线嘎

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

Problem B: 圆柱堆问题

假设取1号做受力分析（只考虑上方对其的作用力），那么有

其实力l是由3号提供的，r是由2号提供的，其实l与g,r与g的夹角均为30度，我们假定一个柱体，受到斜向左的力为l,斜向下右的力为r,重力为w,a[i][j]代表第i行第j个圆柱体，那么有

a[i][j].l = a[i-1][j].l + a[i-1][j].w * sqrt(3) / 3

a[i][j].r = a[i-1][j-1].r + a[i-1][j-1].w * sqrt(3) / 3

a[i-1][j].w * sqrt(3) / 3为重力在对应的l或者r 方向的分力.

接下来考虑最后一行的柱体对左挡板的压力

对于最后一行的柱体，假设向左的力是正,向右是负,则其水平方向的合力为F[i]=(a[n][i].l-a[i][i].r)/2

现在我们从左至右考虑每根圆柱.每个圆柱产生的水平力非正即负或零,我们累加这个合力.假设存储为sum= ,其中,当1<=i<=k时,F[i]>0,现在考虑第k+1个圆柱.如果F[k+!]>0,那么显然,第k+!个圆柱产生的合力也要被左挡板承受,sum+=F[k+!];反之,如果F[k+!]<0,第k+1个圆柱产生的力是向右的,(我有向本题作者要过测试数据,测试数据就认为这时的sum值就是左挡板的压力),这里,我们再分两种情况:一.当k+1<=i<=n时,如果F[i]<0,说明第k个圆柱后面的产生合力都是向右,那么这个压力是由右挡板承受的,左挡板所受的压力就是sum;二,第k+1个圆柱后面的圆柱存在某个合力仍然向左的圆柱(假设这个圆柱是第m个圆柱).这种情况下,第k+1个圆柱到第m-1个圆柱产生向右的水平力会被该圆柱产生向左的水平力抵消一部分,甚至可能超过,这样两者产生的合力仍然是向左的,所以左挡板所受的压力要加上该值.分析到这里,我们不难看出,计算左挡板压力的方法: 从左至右,累加各个圆柱的合力,这个合力的最大值,就是左挡板所受的力.

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

又是华丽的分割线

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

Problem C: 液晶切割

注意到每次可以把一块矩形液晶水平或者竖直地切成两块，一开始没看到这个，把问题想复杂了许多，囧~~~~~

开一个二维数组dp[X][Y],dp[i][j]代表长为i宽为j的液晶块能切割能卖出的最多价钱，那么由于切割方式是水平或者竖直地切成两块，就有转换方程

dp[i][j] = Max{dp[i][j], dp[i-k][j]+dp[k][j]}(1<=k<=i/2)

dp[i][j] = Max{dp[i][j], dp[i][j-k]+dp[i][k]}(1<=k<=j/2)

而dp[i][j]的初始值为如果有长度为x，宽为y的C价钱的液晶，那么有dp[x][y] = dp[y][x] = C,因为数据没有严格按题目的要求给出（题目是说n种尺寸不一，且长大于宽的液晶）,故可能出现如下数据

3 2 100

2 3 3

那么很明显我们的dp[3][2]和dp[2][3]必须取100而不是3,即在赋值的时候要加一个判断if(dp[x][y]<C)才进行赋值，对于其他情况全部为dp[i][j]=0.

最终答案为dp[X][Y]，X,Y为大液晶块的长和宽

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

粉华丽的分割线

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

Problem D: 取款

很简单的一道模拟题。

开辟一个大小为K的a数组代表K个营业员要工作到的时间

每读到一个客户，先把该客户的到达时间转换成秒S，然后找到这K个营业员工作的时间最短的a[i]，然后a[i] = (Max(a[i],S) + 该客户业务所要办理的时间)

当wzc到达时，按上面的方法求得a[i]后，判断a[i] 是否小于17*3600，即是否未到银行关闭时间，如果小于，则将a[i]转换为相应的时秒分格式，否则就输出Bad Luck!

由于每次要找到K个营业员的最短时间，可以将这K个数构造成一个最小堆，时时维护，不过对于此题，K <= 100,没啥必要-_-…….

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

持续华丽的分割线

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀

Problem E: 椭圆容器问题

知识准备:

1.    椭圆面积公式:

S=πab    

这个公式要用到椭圆的参数方程,具体推导过程可以参阅任何一本<<高等数学>>或者<<数学分析>>中关于定积分的应用,(高等数学同济大学第六版上册276页例3)
2.椭圆体体积公式:

V= 4/3πabc=

这个微积分公式是本题的关键,见下面的推导吧 .^_^.

我们只考虑上半球,假设有一个上半椭圆球容器(z>=0),装有若干水,水面高度为h.对于0<=z<=h,z到z+dz将容器切为一个小片片,当dz很小时,小片片的体积v’=S*dz,S是小片片的截面面积,其方程为 ,两边除以,得:

其面积

 ,得到体元素为

 又z的变化范围是[0,h],有

1)        JDK 1.5.0 新增的Scanner类为输入提供了良好的基础，简直就是为ACM-ICPC而设的。

一般用法为：

import java.io.*

import java.util.*

public class Main

{

public static void main(String args[])

{

Scanner cin = new Scanner(new BufferedInputStream(System.in));

...

}

}

当然也可以直接 Scanner cin = new Scanner(System.in); 只是加Buffer可能会快一些。

2)         

读一个整数：   int n = cin.nextInt();         相当于   scanf("%d", &n);   或 cin >> n;

读一个字符串：String s = cin.next();         相当于   scanf("%s", s);    或 cin >> s;

读一个浮点数：double t = cin.nextDouble();      相当于   scanf("%lf", &t); 或 cin >> t;

读一整行：     String s = cin.nextLine();    相当于   gets(s);           或 cin.getline(...);

判断是否有下一个输入可以用 cin.hasNext() 或 cin.hasNextInt() 或 cin.hasNextDouble() 等，具体见 TOJ 1001 例程。

3)        输出一般可以直接用 System.out.print() 和 System.out.println()，前者不输出换行，而后者输出。

比如：System.out.println(n);   // n 为 int 型

同一行输出多个整数可以用

System.out.println(new Integer(n).toString() + " " + new Integer(m).toString());

也可重新定义：

static PrintWriter cout = new PrintWriter(new BufferedOutputStream(System.out));

cout.println(n);

4)        对于输出浮点数保留几位小数的问题，可以使用DecimalFormat类。

import java.text.*;

DecimalFormat f = new DecimalFormat("#.00#");

DecimalFormat g = new DecimalFormat("0.000");

double a = 123.45678, b = 0.12;

System.out.println(f.format(a));

System.out.println(f.format(b));

System.out.println(g.format(b));

这里0指一位数字，#指除0以外的数字。

2.         大数字

BigInteger 和 BigDecimal 是在java.math包中已有的类，前者表示整数，后者表示浮点数。

用法：不能直接用符号如+、-来使用大数字，例如：

import java.math.*   // 需要引入 java.math 包

BigInteger a = BigInteger.valueOf(100);

BigInteger b = BigInteger.valueOf(50);

BigInteger c = a.add(b)   // c = a + b;

主要有以下方法可以使用：

BigInteger add(BigInteger other)

BigInteger subtract(BigInteger other)

BigInteger multiply(BigInteger other)

BigInteger divide(BigInteger other)

BigInteger mod(BigInteger other)

int compareTo(BigInteger other)

static BigInteger valueOf(long x)

输出大数字时直接使用 System.out.println(a) 即可。

3.         字符串

String 类用来存储字符串，可以用charAt方法来取出其中某一字节，计数从0开始：String a = "Hello";    // a.charAt(1) = 'e'

用substring方法可得到子串，如上例

System.out.println(a.substring(0, 4))     // output "Hell"

注意第2个参数位置上的字符不包括进来。这样做使得 s.substring(a, b) 总是有 b-a个字符。

字符串连接可以直接用 + 号，如

String a = "Hello";

String b = "world";

System.out.println(a + ", " + b + "!");    // output "Hello, world!"

如想直接将字符串中的某字节改变，可以使用另外的StringBuffer类。

4.         调用递归（或其他动态方法）

在主类中 main 方法必须是 public static void 的，在 main 中调用非static类时会有警告信息，可以先建立对象，然后通过对象调用方法：

public class Main

{

...

void dfs(int a)

{

if (...) return;

dfs(a+1);

}

public static void main(String args[])

{

...

Main e = new Main();

e.dfs(0);

...

}

}

5.         其他注意的事项

1)        Java 是面向对象的语言，思考方法需要变换一下，里面的函数统称为方法，不要搞错。

2)        Java 里的数组有些变动，多维数组的内部其实都是指针，所以Java不支持fill多维数组。

数组定义后必须初始化，如 int[] a = new int[100];

3)        布尔类型为 boolean，只有true和false二值，在 if (...) / while (...) 等语句的条件中必须为boolean类型。

在C/C++中的 if (n % 2) ... 在Java中无法编译通过。

4)        下面在java.util包里Arrays类的几个方法可替代C/C++里的memset、qsort/sort 和 bsearch:

Arrays.fill();

Arrays.sort();

Arrays.binarySearch();