算法题目积累0721

1，两个字符串的最长公共子串

基本思想是扫描两次矩阵，第一次进行字符比较；第二次找出对角线为1的最长长度

package com.bobo.interview;

import com.bobo.util.MetrixPrint;

/**
 *  这个类实现的功能室查找两个字符串的最长公共子串（要求连续）
 *  扫描两次矩阵，第一次的时候是两个字符串的比较，相等的位置赋值1，不等的位置赋值0
 *  第二次扫描，找出对角线为1的最大长度
 *  需要注意的是：分支不止一个的情况
 * @author weibo.lwb
 *
 */
public class LargestCommonStr {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LargestCommonStr test=new LargestCommonStr();
        test.largestCommonStr("abce", "ebcen");

    }

    public int largestCommonStr(String str1,String str2){
        int n=str1.length();
        int m=str2.length();
        int metrix[][]=new int[n][m];
        //第一遍扫描，两个字符串相等的地方赋值1，否则赋值为0
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(str1.charAt(i)==str2.charAt(j)){
                    metrix[i][j]=1;
                }else{
                    metrix[i][j]=0;
                }
            }
        }

        System.out.println("第一次扫描之后构建的矩阵为：");
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                System.out.print(metrix[i][j]+" ");
            }
            System.out.println();
        }
        int max=0;
        int xpos=0;
        int ypos=0;
        //第二遍扫描，看上个矩阵对角线为1的最大长度

        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                if(metrix[i-1][j-1]>=1&&metrix[i][j]>=1){
                    metrix[i][j]=metrix[i-1][j-1]+1;
                    if(max<metrix[i][j]){
                        max=metrix[i][j];
                        xpos=i;
                        ypos=j;
                    }
                }
            }

        }
        System.out.println("第2次扫描之后构建的矩阵为：");
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                System.out.print(metrix[i][j]+" ");
            }
            System.out.println();
        }

        //两次扫描之后完成，之后需要做的是输出公共子串
        System.out.println("最长公共子串的长度为："+max);
        System.out.println(str1.substring(xpos-max+1,xpos+1));
        return max;

    }

}

最长公共子串

2，两个字符串的最长公共子序列

基本思想，注意这里是构建一个(len1+1)*(len2+1)的矩阵

利用动态规划的递推公式：

f(i,j)=f(i-1,j-1)+1 如果str1[i]=str2[j]

f(i,j)=max{f(i-1,j),f(i,j-1)}如果str1[i]!=str2[j]

对于该矩阵赋予的初值是第一行和第一列都等于0

package com.bobo.interview;

import com.bobo.util.MetrixPrint;

/**
 * 该类主要是实现计算两个字符串的最长公共子序列（不要求连续）
 * 采用动态规划的方法
 * @author weibo.lwb
 *
 */
public class LargestCommonList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LargestCommonList test=new LargestCommonList();
        test.largestCommonList("agbic", "abcmn");
    }

    public static int largestCommonList(String str1,String str2){
        int len1=str1.length();
        int len2=str2.length();
        int[][] result=new int[len1+1][len2+1];
        for(int i=0;i<=len1;i++){
            result[i][0]=0;
        }
        for(int j=0;j<=len2;j++){
            result[0][j]=0;
        }

        for(int i=1;i<=len1;i++){
            for(int j=1;j<=len2;j++){
            if(str1.charAt(i-1)==str2.charAt(j-1)){
                System.out.print(str1.charAt(i-1));
                result[i][j]=result[i-1][j-1]+1;
            }else{
                result[i][j]=result[i-1][j]>result[i][j-1]?result[i-1][j]:result[i][j-1];
            }
            }

        }
        System.out.println();
        MetrixPrint.printMetrix(result);
        return result[len1][len2];
    }

}

最长公共子序列

3，计算2的n次方

动态规划，减少计算次数

package com.bobo.interview;

public class cal2mi {

    /**
     * @param args
     */
    public static void main(String[] args) {
        cal2mi test=new cal2mi();
        System.out.println(test.cal2byn(3));
        System.out.println(test.cal2byn(10));

    }

    public static int cal2byn(int n){
        if(n==0){
            return 1;
        }
        if(n==1){
            return 2;
        }
        if(n%2==0){
            return cal2byn(n/2)*cal2byn(n/2);
        }else
        {
            return 2*cal2byn((n-1)/2)*cal2byn((n-1)/2);
        }

    }

}

计算2的n次方

4，计算所有的全排列

4，计算字典序的全排列

算法题目积累0721