位置:首页 » 技术 » 滴血小结(java版):最长公共子序列(子串)、最长公共回文子序列(子串)、最长公共前缀(后缀)

滴血小结(java版):最长公共子序列(子串)、最长公共回文子序列(子串)、最长公共前缀(后缀)

日期:2015-04-30 阅读:2num
Advertisement

滴血总结(java版):最长公共子序列(子串)、最长公共回文子序列(子串)、最长公共前缀(后缀)

1,最长公共前缀问题

有点类似冒泡算法,每次都要找最小的串的长度,然后进行截取,代码如下

public String longestCommonPrefix(String[] strs) {
         if(strs.length==0) return "";
         String s=strs[0];
          for (int i = 1; i < strs.length; i++) {
               if(s.length()==0||strs[i].length()==0) return "";
               int len=Math.min(s.length(), strs[i].length());
               /*
               int count=0;//临时变量,记录比较时候到哪一位就停止
               for ( int j = 0; j <len; j++) {
                    //这里不能是==
                    if (s.charAt(j)!=strs[i].charAt(j))
                          {count=j;break;}
               }
               s=s.substring(0, count);*/
    //上面错在多加了一个count,但是在实际的时候当"a""b的时候,count为0 截取的子串还是“a”
               int j;
               for (  j = 0; j <len; j++) {
                    //这里不能是==
                    if (s.charAt(j)!=strs[i].charAt(j))
                         break;
               }
               s=s.substring(0, j);//0到j-1的位置
          }
          return s;
    }

2,最长公共后缀

与上面的前缀类似,只是一些简单的坐标要变

  public static String longestCommonLastfix(String[] strs) {
             if(strs. length==0) return "";
             //s总是暂时放求的的当前的值
             String s=strs[0];
             for ( int i = 1; i < strs. length; i++) {
                      if(strs[i].length()==0||s.length()==0)
                            return "";
                      int len1=strs[i].length();
                      int len2= s.length();
                   int len=Math. min(len1,len2);
                   int j;
                   for ( j=0;j<len; j++) {
                           if(s.charAt(len2-1-j)!=strs[i].charAt(len1-1-j))
                                 break;
                     }
                     s=s.substring(len2-j);
                }
            return s;
         }

3,最长公共子串(返回子串长度或序列)

关于子串与子序列的问题,不想赘述了,分不清的话自己百度

思路:

子串是连续的,考虑动态规划的方法进行计算

dp[i][j]表示X[0-i]与Y[0-j]的最长公共子串的长度(包含x[i],y[j]的时候)

x[i]与y[j]来说要么与之前的公共子串构成新的公共子串;或者是补构成公共子串

1,x[i]=y[j],最边上的两个char相同,dp[i][j]=dp[i-1][j-1]+1

2,x[i]!=y[j],dp[i][j]=0

最大的值就是所有dp[i][j]中的最大值

// 动态规划问题

/*

* dp[i][j]表示X[0-i]与Y[0-j]的最长公共子串的长度

* x[i]与y[j]来说要么与之前的公共子串构成新的公共子串;或者是补构成公共子串

* 1,x[i]=y[j],最边上的两个char相同, dp[i][j]=dp [i-1][j-1]+1

* 2,x[i]!=y[j], dp[i][j]=0,因为若不相等,后面包含此串的串公共长度肯定在这后面开始算

*/

 public static int longestCommonSubString(String s1,String s2) {
       int len1=s1.length(),len2=s2.length();
       if(len1==0||len2==0) return 0;
        //初始化的时候数组为0,所以后面只需要判断不为0的一些情况
       int[][] dp=new int[len1][len2];
       int max=0;
       for (int i = 0; i < len1; i++) {
            for ( int j = 0; j < len2; j++) {
                 if(s1.charAt(i)==s2.charAt(j)){
                      //i或j中有一个为0,情况特殊
                      if(i==0||j==0){
                           dp[i][j]=1;
                     }
                      else if(i!=0&&j!=0)     dp[i][j]=dp[i-1][j-1]+1;
                      if(dp[i][j]>max){
                           max=dp[i][j];
                      //可以知道最大的起始索引下标为i+1-max
                     }
                }
           }
     }
            return max;
     }

在求最大长度的时候,顺便也把最大子串的起始坐标也知道了i+1-max,所以不论是返回子串还是子串的长度都不怕怕

4,最长回文子串

最长回文子串除了之前的必须是连续的子串外,还要求是回文

最长回文子串算法除了暴力方法外,还有动态规划算法(DP)和著名的Manacher算法,最优的时间复杂度为O(N)

首先要了解一下Manacher算法,也就是在所有的串串中间加一些特殊的分隔符,这样就简单话了奇数回文和偶数回文,不懂这个算法的可以去百度下

这里先给出我自己实现的算法,看不懂的慢慢看

/*
 * str_s = a b a a b a;
   Index = 0 1 2 3 4 5 6 7 8 9 10 11 12
   str[] = # a # b # a # a # b #  a #;
   P[]   = 0 0 0 2 0 1 5 1 0 3 0  1 0;
 */
     //最长公共子串,manacher 算法
      public static String longestPalindrome(String s) {
            if(s.length()==0||s== null) return "";
            if(s.length()==1) return s;
            int len=s.length();
             char[] ch= new char[2*len+1];
             int[] p= new int [2*len+1];
             //max是坐标id影响的最远的index,不是最大距离
             int max=0;
             //id表示的是影响到最远id的index,但不一定是最大的,所以后面还要寻找
             int id=0; //对称中心
             //添加特殊字符,一般是"#"
            for ( int i = 0; i < s.length(); i++) {
                ch[2*i+1]=s.charAt(i);
                ch[2*i]= '#';
           }
          ch[2*len]= '#';

            //进行判断
            for ( int i = 1; i < ch. length; i++) {
             //先把能进行扩展的p[i]值找到
                 if(max>i)
                     p[i]=Math. min(p[2*id-i], max-i);

                 //对i点进行扩展
                 while ((1+i+p[i])<ch.length&&(i-p[i]-1)>0&&(ch[1+i+p[i]]==ch[i-p[i]-1])) {
                     p[i]++;
                }

                 if(p[i]+i>max){
                     max=p[i]+i;
                     id=i;
                }
           }

           //寻找最大值
            max=0;
            id=0;
            for ( int i = 0; i < p. length; i++) {
                 if(max<p[i]){
                     max=p[i];
                     id=i;
                }

           }
            //最大长度为原来的max+1
            StringBuffer sb= new StringBuffer();
            for ( int i = id-max; i <=id+max; i++) {
                 if(ch[i]!= '#') sb.append(ch[i]);
           }
            return sb.toString();
         }

求解回文子串法二:DP,动态规划

//动态规划求最长回文子串

/*

* dp[i][j]表示从字符串i到j之间的字符串是否是回文串, dp[i][j]=0,i到j不是回文, dp[i][j]=1,i到j是回文

* dp[i][j]=dp [i+1][j-1] s[i]=s[j]

* dp[i][j]=0 s[i]!=s[j] i-j的子串不是回文子串,不去理会,初试的时候就是0

*

*动态规划的时候,此时是按子串的长度进行的

*/

     public static String longestPalindrome1(String s) {
            if(s.length()==0||s== null) return "";
            if(s.length()==1) return s;

            int maxLen=1,maxIndex=0;
            int len=s.length();
            int[][] dp= new int[len][len];

            //长度为1的时候
            for ( int i = 0; i < len; i++) {
                dp[i][i]=1;
           }
            //长度为2
            for ( int i = 0; i < len-1; i++) {
                 if(s.charAt(i)==s.charAt(i+1))
                     dp[i][i+1]=1;
                maxIndex=i;
                maxLen=2;
           }
            //长度大于1的时候
            for ( int len1=3 ; len1<=len ; len1++) {
                 for ( int i = 0; i <=len-len1; i++) {
                      int j=i+len1-1;
                      //dp[i+1][j-1]!=0判断不可少
                      if(s.charAt(i)==s.charAt(j)&&dp[i+1][j-1]!=0)
                {dp[i][j]=1;
                     maxIndex=i;
                     maxLen=len1;
                }
                }
           }          

            return s.substring(maxIndex,maxIndex+maxLen);
      }

5,最长公共子序列

  1. 先来一个返回子序列长度的版本

/DP问题,动态规划一下 dp[i][j]表示x长度为i,y长度为j时候的最长公共子序列的长度

/*

* 初始时候 dp[i][j]=0,

* dp[i][j]=0,如果i或者j为0

* dp[i][j]=dp[i-1][j-1]+1,如果前面的x[i-1]=y[j-1]

* dp[i][j]=max{dp[i-1][j], dp[i][j-1]},当x[i-1]=y[j-1]

* 这有点类似 leetcode最大抢劫问题,最大的就是 dp[len -1][len-1]的最大,但是这个是从长度为0开始,不是从下标为0 开始,

*/

public static int LCSubseq(String s1,String s2){
            if(s1.length()==0||s2.length()==0) return 0;
            int len1=s1.length();
            int len2=s2.length();
            int[][] dp= new int[len1+1][len2+1];

            for ( int i = 1; i <=len1; i++) {
                 for ( int j = 1; j <=len2; j++) {

                   if(s1.charAt(i-1)==s2.charAt(j-1))
                        dp[i][j]=dp[i-1][j-1]+1;
                   else{
                        if(dp[i-1][j]>=dp[i][j-1])
                            dp[i][j]=dp[i-1][j];
                        else
                              dp[i][j]=dp[i][j-1];
                   }
                }
           }
            return dp[len1][len2];
     }

2,返回一个子序列版本的,代码大致差不多

//最长公共子序列,输出序列
            public static String LCSubseq1(String s1,String s2){
                 if(s1.length()==0||s2.length()==0) return "";
                 int len1=s1.length();
                 int len2=s2.length();
                 int[][] dp= new int[len1+1][len2+1];
                StringBuffer sb= new StringBuffer();  

                 for ( int i = 1; i <=len1; i++) {
                      for ( int j = 1; j <=len2; j++) {

                        if(s1.charAt(i-1)==s2.charAt(j-1))
                              {dp[i][j]=dp[i-1][j-1]+1;
                          }
                        else{
                              if(dp[i-1][j]>=dp[i][j-1])
                                  dp[i][j]=dp[i-1][j];
                              else
                                   dp[i][j]=dp[i][j-1];
                        }
                     }
                }
                 int max=dp[len1][len2];
                System. out.println( "最大长度为:" +max);
                 //随便输出一个序列

                 while(len1>=1&&len2>=1){
                      if(s1.charAt(len1-1)==s2.charAt(len2-1)&&dp[len1][len2]==dp[len1-1][len2-1]+1){
                           sb.append(s1.charAt(len1-1));
                           len1--;
                           len2--;
                     } else if(s1.charAt(len1-1)!=s2.charAt(len2-1)&&dp[len1-1][len2]>=dp[len1][len2-1]){
                           len1--;
                     } else{
                           len2--;
                     }
                }
                 return sb.reverse().toString();
           }

很明显,这里的动态规划是根据序列长度来规划的,下面来一个根据坐标动态规划的

<pre name="code" class="java">//最长公共子序列,输出长度就行
        public static int LCSubseq1(String s1,String s2){
            if(s1.length()==0||s2.length()==0) return 0;
            int len1=s1.length();
            int len2=s2.length();
            int[][] dp=new int[len1][len2];
            StringBuffer sb=new StringBuffer(); 

            //初始化
            for (int i = 0; i < len1; i++) {
                if(s1.charAt(i)==s2.charAt(0))
                    dp[i][0]=1;
            }
            //初始化
                for (int i = 0; i < len2; i++) {
                        if(s1.charAt(0)==s2.charAt(i))
                            dp[0][i]=1;
            }

            for (int i = 1; i <len1; i++) {
                for (int j = 1; j <len2; j++) {

                   if(s1.charAt(i)==s2.charAt(j))
                       {dp[i][j]=dp[i-1][j-1]+1;
                     }
                   else{
                       if(dp[i-1][j]>=dp[i][j-1])
                           dp[i][j]=dp[i-1][j];
                       else
                           dp[i][j]=dp[i][j-1];
                   }
                }
            }
            int max=dp[len1-1][len2-1];
            System.out.println("最大长度为:"+max);
            /*//随便输出一个长度,有点bug,输不出String,以后再来改
            int i=len1-1,j=len2-1;
            while(i>=1&&j>=1){
                if(s1.charAt(i)==s2.charAt(j)&&dp[i][j]==dp[i-1][j-1]+1){
                    sb.append(s1.charAt(i));
                    i--;
                    j--;
                }else if(s1.charAt(i)!=s2.charAt(j)&&dp[i-1][j]>=dp[i][j-1]){
                    i--;
                }else{
                    j--;
                }
            }
        //有点Bug,
            if(i==0&&j==0){
                if(s1.charAt(i)==s2.charAt(0))
                    sb.append(s1.charAt(0));
            }else if(i>j){
                while(i>=0)
                    if(s1.charAt(i--)==s2.charAt(0))
                        sb.append(s2.charAt(0));
            }else if(i<j){
                while(j>=0)
                    if(s1.charAt(0)==s2.charAt(j--))
                        sb.append(s1.charAt(0));
            }
            return sb.reverse().toString();*/
            return max;
        }


6,最长回文序列

1,递归的方式求解,返回子序列

//最长回文子序列

//递归

/*

* dp[i][j]表示坐标i到j之间的最长回文长度

* 当x[i]=x[j], dp[i][j]=dp [i+1][j-1]+2;

* 当x[i]!=x[j], dp[i][j]=max{dp [i+1][j],dp[i][j-1]}

*

* 初试的时候 dp[i][j]=dp [0][len-1]

*/

 public static String LonPaliSubse(String s){
                int maxLength= Lps(s, 0, s.length()-1);
                   System. out.println( "最大回文子序列的长度为:" +maxLength);
                   //寻找最长子序列,并输出

                   return null;
              }
  public static int Lps(String s, int begin, int last){
      if(begin==last)
            return 1;
      if(begin>last) return 0;
      if(s.charAt(begin)==s.charAt(last))
            return Lps(s, begin+1, last-1)+2;
      return Math. max(Lps(s, begin, last-1), Lps(s, begin+1,  last));
  }

2,动态规划,返回最大的回文序列长度

//DP规划

/*

* 此时的动态规划是从序列长度为1逐次递增进行动态的

* dp[i][j] 从位置i到j之间的序列

*/

public static int LonPaliSubse1(String s){
       if(s.length()==0||s== null) return 0;
       int len=s.length();
       int[][] dp= new int[len][len];
       int max=0;
       //序列长度为1
       for ( int i = 0; i <len; i++)  dp[i][i]=1;

       //长度大于等于i+1的序列 dp[j][j+i]
       for ( int i = 1; i < len; i++) {
            for ( int j = 0; j+i<len; j++) {
                   //如果首位相同
                 if(s.charAt(j)==s.charAt(j+i))
                     max=dp[j+1][j+i-1]+2;
                 else max=Math. max(dp[j+1][j+i], dp[j][j+i-1]);

                dp[j][j+i]=max;
           }
     }
       return dp[0][len-1];
  }

3,构造将原字符串逆转,这样求回文子串,就是求这两个字符串的最大公共子序列,这根据上面求公共序列的情况就可以求了

public static String LonPaliSubse2(String s){
       if(s.length()==0||s== null) return "";
       StringBuffer sb= new StringBuffer(s);
       String s1=sb.reverse().toString();
       return LCSubseq2(s1, s);
  }

后面还有需要改进的和优化的,先到这把

滴血小结(java版):最长公共子序列(子串)、最长公共回文子序列(子串)、最长公共前缀(后缀)的相关内容

相关文章
  • 滴血小结(java版):最长公共子序列(子串)、最长公共回文子序列(子串)、最长公共前缀(后缀)

    滴血总结(java版):最长公共子序列(子串).最长公共回文子序列(子串).最长公共前缀(后缀) 1,最长公共前缀问题 有点类似冒泡算法,每次都要找最小的串的长度,然后进行截取,代码如下 public String longestCommonPrefix(String[] strs) { if(strs.length==0) return ""; String s=strs[0]; for (int i = 1; i < strs.length; i++) { if(s.leng

  • 回文字符串总结(回文串判定+最长回文子序列)

    回文字符串小结(回文串判定+最长回文子序列) 定义:"回文串"是一个正读和反读都一样的字符串,比如"level"或者"noon"等等就是回文串. 回文串判定 例1:hdu2029 题意:请写一个程序判断读入的字符串是否是"回文". 思路:回文串最基本的判定法是将一个字符串扫一遍,判断第i个字符和倒数第i个字符是否相同,不相同则返回false. 也可以用栈来实现,复杂度均为O(n). code: /* * @author Nov

  • 动态规划解最长回文子序列并优化空间复杂度

    一个字符串有许多子序列,比如字符串abcfgbda,它的子序列有a.bfg.bfgbd,在这些子序列中肯定有回文字符串.现在要对任意字符串求其最长的回文子序列.注意,本文不是解决最长回文子串,回文子串是连续的,回文子序列是不连续的. 字符串abcfgbda的最长回文子序列为abcba,长度为5. 输入:包含若干行,每行有一个字符串,字符串由大小写字母构成,长度不超过100. 输出:对每个输入,输出一行,该行有一个整数,表示最长回文子序列的长度. Example Input: a abcfgbda

  • HDU 4745 Two Rabbits(非连续最长回文子序列,区间DP)

    HDU 4745 Two Rabbits(非连续最长回文子序列,区间DP) HDU 4745 Two Rabbits 题目地址 题意: 两只兔子,在n块围成一个环形的石头上跳跃,每块石头有一个权值ai,一只从左往右跳,一只从右往左跳,每跳一次,两只兔子所在的石头的权值都要相等,在一圈内(各自不能超过各自的起点,也不能再次回到起点)它们最多能经过多少个石头(1 分析: 其实就是求一个环中,非连续最长回文子序列的长度. dp[i][j] = max{ dp[i + 1][j], d[i][j - 1

  • java实践:小游戏:猜数目字、判断回文数

    java实践:小游戏:猜数字.判断回文数 . 猜数字小游戏源码: import java.util.*; public class caishuzi { public static void main (String args[ ]) { System.out.println("给你一个1至100之间的整数,请猜测这个数"); int realNumber=(int)(Math.random()*100)+1; int yourGuess=0; Scanner reader=new S

  • 字符串最长回文兑现

    字符串最长回文实现 字符串最长回文Java实现

  • hdu3068-最长回文(Manacer算法)

    hdu3068--最长回文(Manacer算法) 最长回文 Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 9418 Accepted Submission(s): 3238 Problem Description 给出一个只由小写英文字符a,b,c...y,z组成的字符串S,求S中最长回文串的长度. 回文就是正反读都是一样的字符串,如aba

  • Palindrome(补全回文串+最长公共子序列的应用)hdu1513+poj1159+动态规划

    Palindrome Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 4277 Accepted Submission(s): 1462 Problem Description A palindrome is a symmetrical string, that is, a string read identically from left

  • 回文字符串(南阳oj37)(最长公共子序列有关问题)

    回文字符串(南阳oj37)(最长公共子序列问题) 回文字符串 时间限制:3000 ms | 内存限制:65535 KB 难度:4 描述 所谓回文字符串,就是一个字符串,从左到右读和从右到左读是完全一样的,比如"aba".当然,我们给你的问题不会再简单到判断一个字符串是不是回文字符串.现在要求你,给你一个字符串,可在任意位置添加字符,最少再添加几个字符,可以使这个字符串成为回文字符串. 输入 第一行给出整数N(0<N<100) 接下来的N行,每行一个字符串,每个字符串长度不超

  • 找工作常识储备(2)-数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串 找工作常识储备(2)-数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串

    找工作知识储备(2)---数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串 作者:寒小阳 时间:2013年9月. 出处:http://blog.csdn.net/han_xiaoyang/article/details/11969497. 声明:版权所有,转载请注明出处,谢谢. 0.前言 这一部分的内容原本是打算在之后的字符串或者数组专题里面写的,但看着目前火热进行的各家互联网公司笔试面试中,出现了其中的一两个内容,

  • 联通SGIP1.2短信接口 Java版实现 小结 2013-10-23测试通过

    联通SGIP1.2短信接口 Java版实现 总结 2013-10-23测试通过 我的开发过程: 1:根据联通提供的SGIP接口文档,封装装协议. 2:编写通信流程 3:经理建议由原来的socket换成nio socket 4: 经理建议由原来的把Jar集成到需要调用的应用中变为 独立一个短信应用并用hessian对外发布.别的应用可以访问此接口进行调用.语言无间隔(此出源码中并没有hessian部分.你想怎么独立出一个应用,我不管). 期间郁闷的地方 1:SGIP接口文档中 有专用SGIP方式与

  • 微信打飞机--Java版 微信打飞机--Java版

    世风日下啊,大家现在动不动就打飞机... 上个周末实在是无聊,就写了个Java版的微信打飞机游戏..拿上来和大家交流交流,不喜勿喷(网络上这个资源已经很多了很多了) 目前实现的功能: 1.敌方有两类飞机:小飞机和大BOSS飞机(小飞机1滴血:BOSS有10滴血,我方我只设置一滴血,可以修改blood参数) 2.药丸:有蓝色药丸和红色药丸 3:蓝色药丸能双发子弹 (有时间限制) 4:红色药丸全屏爆炸 屏幕下方显示已有的红色药丸数目 5:按键说明:游戏暂停p 游戏继续s 游戏重开始 r 方向键控制上

  • 微信公众平台开发教程Java版(3) 消息接收和发送 微信公众平台开发教程Java版(3) 消息接收和发送

    微信公众平台开发教程Java版(三) 消息接收和发送 前面两章已经介绍了如何接入微信公众平台,这一章说说消息的接收和发送 可以先了解公众平台的消息api接口(接收消息,发送消息) http://mp.weixin.qq.com/wiki/index.php 接收消息 当普通微信用户向公众账号发消息时,微信服务器将POST消息的XML数据包到开发者填写的URL上. http://mp.weixin.qq.com/wiki/index.php?title=%E6%8E%A5%E6%94%B6%E6%

  • qq聊天机器人 群发工具 (java版) (3)

    qq聊天机器人 群发工具 (java版) (三) 本篇简单讲解一下如何接收QQ消息. 在成功登陆QQ后,要每隔一段时间发一个POST请求,用来维持登陆状态,同时也是用来接收消息的,请求如下: Request URL:http://d.web2.qq.com/channel/poll2 Request Method:POST Content-Type:application/x-www-form-urlencoded Referer:http://d.web2.qq.com/proxy.html?

  • Java版工人-监工形式实现

    Java版工人-监工模式实现 之前在学习erlang OTP的时候,看到在OTP中实现了工人-监工模式,就是在定义一个工作者进程的时候,同时为器分配了一个overseer(监工),监工啥事儿也不作,就专门负责工作者进程是否正常工作,有无任务异常情况发生,当时看到在机制觉得不以为然觉得就这么几行代码没什么大不了的. 当我最近用java代码来实现分布式编程的时候发现要做一个稳定的,可靠的系统并不是那么容易,之前在单机系统中默认不会不会出任何问题的共享变量操作,进程间通信.在分布式系统中zookeep

  • 数据结构与算法分析首先部分(java版) 数据结构与算法分析首先部分(java版)

    数据结构与算法分析第一部分(java版) 第一章 引论 1.1 本书讨论的问题 在当今许多问题中,一个重要的观念是:写出一个工作程序并不够,如果这个程序在巨大的数据集上运行,那么运行时间就成了重要的问题. 一下两个示例足以能说明算法优化.数据处理的问题. 示例1:求出第K个从小到达排列后的数 1./** * 求出第K个从小到达排列后的数 * 我采用冒泡法,以后给出算法优化 */ package com.example.practice; import java.util.Scanner; pub

  • Java版短因特网址(ShortUrl)的算法

    Java版短网址(ShortUrl)的算法 最近,我的项目中需要用到短网址(ShortUrl)的算法,于是在网上搜索一番,发现有C#的算法,有.Net的算法,有PHP的算法,就是没有 找到Java版的短网址(ShortUrl)的算法,很是郁闷.同时还发现有不少网友在发帖求助,怎么实现Java版的短网址(ShortUrl)的算 法.干脆一不做,二不休,参考了一下网上比较流行的PHP版短网址(ShortUrl)算法: http://www.snippetit.com/2009/04/php-shor

  • Google App Engine Java 版下构建电子书分享网站

    Google App Engine Java 版上构建电子书分享网站 Google App Engine Java 版上构建电子书分享网站 2010年07月23日 级别: 初级 张军, 软件工程师, IBM 中国软件开发中心 2009 年 10 月 27 日 "云计算"是目前热门的技术方向,本文从 Google 的云计算平台 App Engine 入手,简单介绍了 Google 面向 Java 开发人员的云计算平台.从一个实际的电子书分享应用构建出发,讲述了如何在 Google App

  • 单链表是不是相交(Java版)

    单链表是否相交(Java版) 题目:有两个带头结点的单链表L1,L2,判断它们是否相交(它们中是否有相同的结点) 解题思路: L1,L2中任何一个链表为空它们不相交 因为单链表中可能有环,所以分3种情况讨论 1.L1,L2中都没有环,那么可以通过判断它们中最后一个结点是否相同,来判断它们是否相交 2.L1,L2中一个有环,一个没有环,那么它们一定不相交 3.L1,L2中都有环,那么只有当它们的环相同时,它们才相交,当它们在进入环之前有相同的结点时,它们交点的个数大于环中结点的个数,当它们进入环时

  • Selenium2.0功能测试之怎么使用Remote WebDriver(Java版) Selenium2.0功能测试之怎么使用Remote WebDriver(Java版)

    Selenium2.0功能测试之如何使用Remote WebDriver(Java版) 可能目前使用WebDriver的绝大多数人还没有接触到Remote WebDriver,所以对Remote WebDriver没有一个概念,其实可以把Remote WebDriver理解成为在远程PC上执行WebDriver用例. 那么远程的好处在哪里呢?除了可以更方便的进行跨平台.浏览器的测试外,最重要的一点是排除我们本地环境的污染,因为我们工作用的PC其实我们安装了很多的软件,那么在coding的时候这些

最新文章
  • 如果公司强制要穿公司服装 是不是限制了员工的自由

    一个互联网公司,强制要求穿公司服装(夏装两套),这样是不是限制了员工的自由,特别对于开发部门的人来说.还有更可恶的事情,男士必须打领带以及每天都穿.如有违反,一次警告二次通报批评三次就开始罚款(没穿工服罚款 50 ,没打领带罚款 20 ). 像这样公司的制度是不是触犯了啥法律呀,查了一下好像并没有,求万能的 v 友帮忙解答.(我个人是很反感每天都穿公司服装的,特别是领带.) --cut-- jasontse在2016-05-08 19:15:28回答到: 这种帖子居然翻页了, V2er 真是有个

  • 不知道Cubemen 2这个游戏如何

    忽然有些想试试minecraft,不过有点贵,这个有点像mc,而且还可以在Linux上玩,有玩过的朋友来讲讲么 顺带各位也可以推荐推荐在steam下好玩的游戏(平台不限)吧,刚玩Alien Swarm,还不错的~ --cut-- shidenggui在2013-04-28 08:48:3回答到: 黑暗之魂,dark soul,氛围手感关卡设计超棒的游戏 alayii在2013-04-28 09:02:0回答到: @shidenggui 这个steam给的限制还真是...我填20岁都不让看...

  • 立冬如何养生最合适 立冬如何养生最合适

    立冬顾名思义就是真正的进入到冬天了,天气变冷了,人们也不想出门了,只想天天窝在被窝里面,更不说运动了.但是,小编告诉大家这时候也是养生的好时候,立冬养生主要就是避寒就温.保护阳气,使阴阳相对平衡起来,所以立冬养生就要预防疾病的发作和病情变重,要从饮食起居等多方面着手. 饮食 俗话说:"药补不如食补".食补在冬季调养中尤为重要.冬季气温过低,人体为了保持一定的热量,就必须增加体内糖.脂肪和蛋白质的分解,以产生更多的能量,适应机体的需要,所以必须多吃富含糖.脂肪.蛋白质和维生素的食物.同时

  • 手机支付宝好友如何删除 手机支付宝好友如何删除

    支付宝是付款软件,大家都十分担心账户安全问题,生怕有人把支付宝账号给盗了,如果你支付宝五福集齐了,或者加好友得福的任务完成了,那就残忍的把那些你不认识的支付宝朋友删除吧! 支付宝好友如何删除? 第一步:打开手机支付宝app,点击支付宝首页的小人图标. 第二步:进入联系人列表,点击要删除的好友栏. 第三步:进入详细页面,再点击右上角的[-] 第四步:点击最后的[删除]按钮,即可删除好友 注意:在好友聊天窗口的右上角下,没有删除这个功能,所以不要找错地方了.

  • 卡片长焦数码相机—富士F305EXR 卡片长焦数码相机—富士F305EXR

    F305EXR采用的24mm-360mm富士龙镜头,为了将这枚拥有15倍变焦的镜头装入如此之薄的机身中,并且还要达到很好的成像效果,富士采用了全新的非球面镜以及新的镀膜技术,并且突破性的采用了一种全新的双滑动镜片技术.如下图所示. F305采用的全新双滑动镜片技术 这种技术可以有效的保证从超广角24mm到长焦360mm的变焦范围而不会增加机身厚度.接下来我们就来看看,采用全新技术的富士龙镜头会给我们带来怎样的表现吧. 广角端分辨率测试 长焦端分辨率测试 从上面的测试,我们可以看到.该镜头在广角端

  • 浅析咖啡机行业网站优化的一些弊端-明白影响网站权重的因素 浅析咖啡机行业网站优化的一些弊端-明白影响网站权重的因素

    谈到一个网站的优化相信具有一定经验的站长都知道,在对一个网站进行优化之时不仅仅只是在三大标签布置多个关键字之后,就在站内发发文章,在站外发发外链.怎么简单,特别是现在当前搜索引擎算法不断频繁更新升级<主指度娘搜索引擎>就更难通过以上所谈的优化手法获得SEO效果,而且处理不当很有可能遭致降权.K站.拔毛的现象.说到这里肯定就会有些新手站长问到,那应该如何做好SEO呢?对于这一问题笔者就此简单的说说.当计划要对一个网站进行 SEO的话,那么在建设网站之前和建设网站中都需要做好优化工作如:一个网站主

  • 如何拍摄出迷幻的天空 如何拍摄出迷幻的天空

    (Photo by Pisit Rapitpunt) 相机 Nikon D7100 镜头 10-20mm 焦距 10mm 快门 1/320 sec 光圈 f/4 ISO 200 很多人也奇怪,怎样可以拍出这样「迷幻」的天空呢?其实要拍摄这种相片不太难,利用一点技巧便可以了,让我们学习一下! (一) 逆光拍摄 + 选择对焦 于一个天色晴朗的日落黄昏,在海边或上找一棵枯树,然后向着太阳拍摄,测光以天空为准(可以先向着天空测光),这样便会把树木拍成剪影效果,记得要对焦在树木上而不是天空,否则树木有机会

  • 鞋带松了 鞋带松了

    去年,在一次联谊活动中,我结识了一位盲女,我们一起聊天,直到活动结束.我让她扶着我的手臂,陪她走了一段路,我们边走边聊,正聊得愉快时,她向我说了声抱歉,因为她想蹲下系鞋带. 我低头一看,她的鞋带果然松了.我有些震惊,问看不见的她如何知道的?她笑着说:因为感觉松了.之后她告诉我,她的工作是按摩,闲暇时编些中国结饰品.随后,她拿着皮包旁用绳子编的娃娃给我看.她说下次若见面送我一个.她知道我对烹饪有兴趣后,口授了我几道菜,并告诉我有空可以去找她,她会教我编中国结及烹饪. 望着她诚挚的脸,我有些惭愧,因

  • Win8系统自带虚拟光驱使用方法 Win8系统自带虚拟光驱使用方法

    现在很多人都有个错误的思想,就是外界的应用程序总比系统内自带的好用,所以很多人都直接忽略系统内自带的一些程序,其实这个想法是片面的,有些自带的程序很好用,比如说win8系统中有个虚拟光驱,很多人都不知道,都是使用的外接虚拟光驱.下面小编就教大家正确使用win8系统中自带的虚拟光驱,会比我们现在市面上外接的虚拟光驱更适合哦! 在Win8中要怎么使用虚拟光驱呢?答案就几个字:"双击镜像".就这么简单?就是这么简单!出乎你们的意料吧?就在我们忙着下载daemon tools Lite,又是加

  • STL源码分析-空间配置器的底层实现 (2)

    STL源码分析--空间配置器的底层实现 (二) STL源码分析-空间配置器 空间配置器中门道 在STL中的容器里都是使用统一的空间配置器,空间配置器就是管理分配内存和销毁内存的.在STL将在heap空间创建一个对象分为两个步骤,第一是申请一块内存,第二是在这块内存中初始化一个对象.首先申请空间是由malloc提供,初始化一个对象时由constructor管理.销毁一个对象也是由两步骤完成,第一是销毁空间上的对象,第二是释放这块内存. 同时,STL的空间配置器分为两级内存,如果申请的内存空间大于1

热门推荐
  • 羊年元宵节苏州旅游景点大全2015 羊年元宵节苏州旅游景点大全2015 苏州,从名字里面就能给人感受到一股秀气的感觉来.而这种秀气也体现在她众多的旅游景点中,下面就来给小编一起去领略一下吧. 甪直镇原名甫里,隶属苏州市吴中区,位苏州市东南部,曾被费孝通誉为"神州水乡第一镇",以水多.桥多.巷多.名人多而著称,更因塑壁罗汉和水乡妇女服饰闻名天下,有2500年的文明历史. "水巷小桥多,人家尽枕河"是甪直浓厚水乡气息的真实写照,一平方公里的古镇区原有宋元明清时期各式石桥"七十二顶半",现尚存四十一座,素称"中国
  • 圣诞休闲 让人欲罢不能的休闲游戏推荐 圣诞休闲 让人欲罢不能的休闲游戏推荐 说起圣诞节,不知道各位亲爱的玩家朋友们都会想到什么呢?是开心的派对还是去找漂亮的妹纸或帅哥来一场浪漫的约会?不管是逛街吃饭还是和朋友唱K,怎么都是玩,空闲之余不如玩得更High一点!比如,最近苹果在其App Store首页放出的"App Store 2012年度精选"里,就有超多好玩的IOS游戏,而且推荐的大都是让广大果粉欲罢不能的好游戏哦! 在这样快乐的日子里,就让我们将心底里的所有欢乐随着这些游戏全部释放吧.下面,就为大家推荐其中的几款年度精选游戏,圣诞休闲时可以尽情玩玩哦! 一.
  • 《剑灵》足球武器怎么获得 属性怎么样 《剑灵》足球武器怎么获得 属性怎么样 今天小编和大家一起分享韩服足球武器属性和获取方式,攻击力看起来还不错,不过就现在的情况应该是不会更新到国服了.来看一下吧! 1.首先获取方式:一贯套路,开箱子. 2.进化? 3.属性翻译结果: 攻击351 命中226 穿刺98 有一定几率12s提高暴击伤害19.1 4.外观 翻译都是在线翻译,切莫轻信.
  • 天天飞车星空行者好不好?天天飞车星空行者怎么获得? 天天飞车星空行者好不好?天天飞车星空行者怎么获得? 天天飞车星空行者怎么样呢?星空行者是天天飞车中一款全新的RS级赛车了,这款新车性能怎么样呢?下面一聚教程小伙伴为各位整理一下. 天天飞车星空行者怎么样? 积分:+15% 惊险超车:+6% 隐身最长时间:5秒 技能:"怒"状态下同时持续5秒(初始)隐身 天天飞车星空行者获得方法 目前只有花钱来买了:费用在1500钻石左右哦