DNA携带的遗传信息可以用形如：AGGTCGACTCCA.... 的串来表示。DNA在转录复制的过程中可能会发生随机的偏差，这才最终造就了生物的多样性。

    为了简化问题，我们假设，DNA在复制的时候可能出现的偏差是（理论上，对每个碱基被复制时，都可能出现偏差）：

　　1. 漏掉某个脱氧核苷酸。例如把 AGGT 复制成为：AGT

    2. 错码，例如把 AGGT 复制成了：AGCT

    3. 重码，例如把 AGGT 复制成了：AAGGT

    如果某DNA串a，最少要经过 n 次出错，才能变为DNA串b，则称这两个DNA串的距离为 n。

    例如：AGGTCATATTCC 与 CGGTCATATTC 的距离为 2

    你的任务是：编写程序，找到两个DNA串的距离。

【输入、输出格式要求】

    用户先输入整数n(n<100)，表示接下来有2n行数据。

    接下来输入的2n行每2行表示一组要比对的DNA。（每行数据长度<10000）

    程序则输出n行，表示这n组DNA的距离。

    例如：用户输入：
3
AGCTAAGGCCTT
AGCTAAGGCCT
AGCTAAGGCCTT
AGGCTAAGGCCTT
AGCTAAGGCCTT
AGCTTAAGGCTT

    则程序应输出：
1
1
2

结题思路：参阅百度百科http://baike.baidu.com/view/2020247.htm
代码如下：

import java.util.*;


public class Main {
    
    
    static String instr0;
    static String instr1;
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        sc.nextLine();
        for(int ii = 0; ii < N; ii++){
            instr0 = sc.nextLine();
            instr1 = sc.nextLine();
            int rs = pro();
            System.out.println(rs);
        }
        
    }
    static int pro(){
        int[][] dis = new int[instr0.length()][instr1.length()];
        for(int i = 0; i < instr0.length(); i++)
            dis[i][0] = i;
        for(int j = 0; j < instr1.length(); j++)
            dis[0][j] = j;
        for(int i = 1; i < instr0.length(); i++){
            for(int j = 1; j < instr1.length(); j++){
                int cost = 0;
                if(instr0.charAt(i) != instr1.charAt(j))
                    cost = 1;
                dis[i][j] = min3(dis[i - 1][j] + 1, dis[i][j - 1] + 1, 
                        dis[i - 1][j - 1] + cost);
            }
        }
        return dis[instr0.length() - 1][instr1.length() - 1];
        
    }
    static int min3(int a, int b, int c){
        return Math.min(Math.min(a, b), c);
    }

    
}

    今年（2012）的国庆节是星期一。

    那么，从建国到现在，有几次国庆节正好是星期日呢？

import java.util.*;


public class Main {
    
    public static void main(String[] args)
    {
        int count = 0;
        int weekd = 5;
        for(int i = 1950; i < 2013; i++){
            int y = 365;
            if(isRN(i))
                y++;
            weekd = (weekd + y) % 7;
            if(weekd == 6){
                count++;
                System.out.println("i=" + i);
            }
        }
        System.out.println("count=" +  count);
    }
    static boolean isRN(int y){
        if(y % 4 == 0 && y % 100 != 0 || y % 400 == 0)
            return true;
        return false;
    }

    
}

    Excel是最常用的办公软件。每个单元格都有唯一的地址表示。比如：第12行第4列表示为：“D12”，第5行第255列表示为“IU5”。
   
    事实上，Excel提供了两种地址表示方法，还有一种表示法叫做RC格式地址。 第12行第4列表示为：“R12C4”，第5行第255列表示为“R5C255”。

    你的任务是：编写程序，实现从RC地址格式到常规地址格式的转换。

【输入、输出格式要求】

    用户先输入一个整数n（n<100），表示接下来有n行输入数据。

    接着输入的n行数据是RC格式的Excel单元格地址表示法。

    程序则输出n行数据，每行是转换后的常规地址表示法。

    例如：用户输入：
2
R12C4
R5C255

    则程序应该输出：
D12
IU5

结题思路：字符串处理，26进制转换。特别注意26要被转换成Z，因为A表示的是1而不是0。
代码如下：
（代码实现了两种格式的互换问题）

import java.util.*;


public class Main {
    
    
    static int N;
    static String instr1;
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        sc.nextLine();
        for(int i = 0; i < N; i++){
            instr1 = sc.nextLine();
            if(isRC(instr1)){
                toAN();
            }
            else{
                toRC();
            }
        }
        
    }
    static void toRC(){
        /**//*
         * D12-->R12C4
         */
        int i = 0;
        int numc = 0;
        while(Character.isLetter(instr1.charAt(i))){
            numc *= 26;
            numc += instr1.charAt(i) - 'A' + 1;
            i++;
        }
        int numr = Integer.parseInt(instr1.substring(i));
        System.out.println("R" + numr + "C" + numc);
    }
    static void toAN(){
        /**//*
         * R12C4-->D12
         */
        StringBuffer sbuf = new StringBuffer();
        String[] strs = instr1.split("[RC]");//正则式很有趣
        int numc = Integer.parseInt(strs[2]);
        while(numc > 0){
            char c = (char)((numc - 1) % 26 + 'A');//num - 1，避免26被转换为A
            sbuf.append(c);
            numc = (numc - 1) / 26;//num - 1，避免26被转换为AZ
        }
        System.out.println(sbuf.reverse() + strs[1]);
    }
    
    static boolean isRC(String instr){
        int count = 0;
        boolean isnumbg = false;
        for(int i = 0; i < instr.length(); ){
            if(Character.isDigit(instr.charAt(i))){
                if(isnumbg){
                    i++;
                }
                else{
                    isnumbg = true;
                    count++;
                    i++;
                }
            }
            else{
                if(isnumbg){
                    isnumbg = false;
                }
                i++;
            }
        }
        if(count == 2)
            return true;
        return false;
    }
        
}

    例如，我们可以对小车输入如下的指令：

    15L10R5LRR10R20

    则，小车先直行15厘米，左转，再走10厘米，再右转，...

    不难看出，对于此指令串，小车又回到了出发地。

    你的任务是：编写程序，由用户输入指令，程序输出每条指令执行后小车位置与指令执行前小车位置的直线距离。

【输入、输出格式要求】

    用户先输入一个整数n（n<100），表示接下来将有n条指令。

    接下来输入n条指令。每条指令只由L、R和数字组成（数字是0~100之间的整数）

    每条指令的长度不超过256个字符。

    程序则输出n行结果。

    每条结果表示小车执行相应的指令前后位置的直线距离。要求四舍五入到小数后2位。

    例如：用户输入：
5
L100R50R10
3LLL5RR4L12
LL
100R
5L5L5L5

    则程序输出：
102.96
9.06
0.00
100.00
0.00

import java.util.*;

public class Main {
    static int x = 0;
    static int y = 0;
    static int nowdir = 0;
    static int N;
    static String instr;
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        sc.nextLine();
        for(int i = 0; i < N; i++){
            instr = sc.nextLine();
            x = 0;
            y = 0;
            nowdir = 0;
            pro();
            double dis0 = Math.sqrt(x * x + y * y);
            System.out.printf("%.2f\n", dis0);
        }
    }
    static void pro(){
        boolean isnumbg = false;
        int numbgp = 0;
        instr = instr + "#";
        for(int i = 0; i < instr.length();){
            if(Character.isDigit(instr.charAt(i))){
                if(isnumbg){
                    i++;
                    continue;
                }
                else{
                    numbgp = i++;
                    isnumbg = true;
                }
            }
            else{
                if(isnumbg){
                    isnumbg = false;
                    String str1 = instr.substring(numbgp, i);
                    int dis = Integer.parseInt(str1);
                    if(nowdir == 0){
                        y += dis;
                    }
                    else if(nowdir == 2){
                        y -= dis; 
                    }
                    else if(nowdir  == 1){
                        x += dis;
                    }
                    else
                        x -= dis;
                }
                else{
                    char c = instr.charAt(i);
                    if(c == 'R'){
                        nowdir = (nowdir + 1) % 4;
                    }
                    else if(c == 'L'){
                        nowdir = (nowdir + 3) % 4;
                    }
                    i++;
                }
            }
        }
    }
}

    如果每个五角星代表 1 ~ 9 的不同的数字。

    这个算式有多少种可能的正确填写方法？

    173 + 286 = 459
    295 + 173 = 468
    173 + 295 = 468
    183 + 492 = 675

    以上都是正确的填写法！

    注意：
    111 + 222 = 333 是错误的填写法！
    因为每个数字必须是不同的！
    也就是说：1~9中的所有数字，每个必须出现且仅出现一次！

结题思路：
排列1~9，写出符合条件的结果。
代码如下：

public class Main {
    
    static int bs[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    static int count = 0;
    public static void main(String[] args)
    {
        count = 0;
        DFS(0);
        System.out.println("count=" + count);
    }
    static void DFS(int nowp){
        if(nowp == bs.length){
            int n1 = bs[0] * 100 + bs[1] * 10 + bs[2];
            int n2 = bs[3] * 100 + bs[4] * 10 + bs[5];
            int n3 = bs[6] * 100 + bs[7] * 10 + bs[8];
            if(n1 + n2 == n3){
                System.out.println(n1 + " + " + n2 + " = " + n3);
                count++;
            }
        }
        else{
            for(int i = nowp; i < bs.length; i++){
                swap(nowp, i);
                DFS(nowp + 1);
                swap(nowp, i);
            }
        }
    }
    static void swap(int a, int b){
        int t = bs[a];
        bs[a] = bs[b];
        bs[b] = t;
    }
}

对于R={r1,r2,…,rn}，进行n个元素的全排列，设Ri=R – {ri}。结合X元素的全排列记为Perm(X)，(ri)Perm(X)表示在全排列Perm(X)的每个排列前面加上前缀ri的得到的序列。R的全排列可归纳定义如下：

n=1时，Perm(R)=(r)，其中r是R中的唯一元素；

n>1时，Perm(R)由(r1)Perm(R1), (r2)Perm(R2),…, (rn)Perm(Rn)构成。

显然，部分排列，只要控制递归结束条件即可。

再说组合：

组合与排列相比，忽略了元素的次序，因此我们只需将元素按编号升序排列（或则其他的规则）即可。
代码如下：

public class Main {
    
    static int count;
    public static void main(String[] args) {
        int a[] = {1, 2, 3, 4};
        count = 0;
        permutation(a, 0, 4);
        System.out.println("count=" + count);
        
        count = 0;
        combination(a, 0, 3, 0);
        System.out.println("count=" + count);
    }
    static void combination(int a[], int nowp, int m, int left){//zuhe
        /**//*
         * 求a[]中m个元素的组合
         * nowp表示当前已经组合好的元素的个数
         * left，只能选择编号为left和它之后的元素 进行交换
         */
        if(nowp == m){
            count++;
            for(int i = 0; i < m; i++){
                System.out.print(a[i] + " ");
            }
            System.out.println();
        }
        else{
            for(int i = left; i < a.length; i++){
                swap(a, nowp, i);
                combination(a, nowp + 1, m, i + 1);
                swap(a, nowp, i);
            }
        }
    }
    static void permutation(int a[], int nowp, int m){// pailie
        /**//*
         * 求a[]m个元素的排列
         * nowp，当前已经排列好的元素的个数
         */
        
        if(nowp == m){
            count++;
            for(int i = 0; i < m; i++){
                System.out.print(a[i] + " ");
            }
            System.out.println();
        }
        else{
            for(int i = nowp; i < a.length; i++){
                swap(a, i, nowp);
                permutation(a, nowp + 1, m);
                swap(a, i, nowp);
            }
        }
    }
    static void swap(int a[], int n, int m){
        int t = a[n];
        a[n] = a[m];
        a[m] = t;
    }

}