位置:首页 » 技术 » 滴血小结(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 收华为荣耀 3C 移动版,有的联系!

    马化腾:八五9997745 --cut-- sharkli在2014-03-25 09:56:3回答到: 100收. DevilTee在2014-03-25 09:58:0回答到: @sharkli 怎么联系,我有全新一台. zjgsamuel在2014-03-25 10:12:2回答到: 荣耀 3C 都那么贱啦?? sharkli在2014-03-25 10:13:3回答到: @DevilTee 在北京吗 加QQ 2o久久七o5三 sharkli在2014-03-25 10:40:5回答到:

  • 给现在的自己 给现在的自己

    有很多话想和自己说,叫自己不要哭. 如果是冷漠迎面袭来,不要用冷漠回视. 冷漠害怕的是热情,在任何一副冷漠背后,热情的种子正等待浇灌, 倘若你成为那个园丁,热情会用原先冷漠的倍数感谢你. 如果所有的付出看不到结果,不要放弃. 成功缩在紧裹的壳里偷偷望着你, 经不起放弃的诱惑,走了,成功就会缩回脑袋, 以后永远别想扣开他的壳. 如果思念有时摊满了大脑,放纵你的思念,让他知道. 思念是只会飞的虫子,目的就是让你知道你爱谁而已,他不可怕. 思念会带走你的故事,你可以期盼有一天他带着你的故事去了他的脑袋

  • 佛像显灵救人 难道真的是我佛慈悲? 佛像显灵救人 难道真的是我佛慈悲?

    这件事情有很多的目击证人,石像居然也会动博彩通,伸手接住了一个从12层掉下的小女孩,这都是我们不能理解的超自然现象,难道真的是我佛慈悲. 2002年;泾阳县崇文塔上的一尊佛像伸手接住了一个从12层掉下的小女孩,目击人数超过百人,轰动一时. 位于泾阳县城东南10公里的崇文镇每逢阴历正月15都会开塔会,届时人山人海,表演杂技.马戏.卖小吃的什么都有异常热闹. 2002年,正逢塔会,有个顽皮的8岁多小女孩从崇文塔12层的防护栏钻出,不小心从塔上跌落下来,当时下边有超过一千人在下边逛塔会.就在小孩跌落的

  • 一个菜鸟站长对PR的疑惑

    poluoluo.Com提示:首先声明,本人虽然从事互联网行业一年有余,但做为站长,也才不到一个月,自己运营网站,就免不了要为网站的推广费心,下面的言论,只是一个菜鸟站长在做网站推广时产生的对GooglePR值重要性的怀疑,欢迎前辈们批评指证,有错误才有批评,有批评才能进步嘛. 我有一个 首先声明,本人虽然从事互联网行业一年有余,但做为站长,也才不到一个月,自己运营网站,就免不了要为网站的推广费心,下面的言论,只是一个菜鸟站长在做网站推广时产生的对GooglePR值重要性的怀疑,欢迎前辈们批评指

  • 关于高中美术教学反思

    高中美术教学以欣赏为主线,注重学生的个性发展和全面发展.它的这一特点决定了艺术课堂教学说采用的方法有别于其他学科.高中的学生已经形成较独立的个性,有自己的主张,而艺术课也不是高考项目,学生对艺术课的学习态度大部分取决于教师."亲其师,信其道"所以作为教师,上课要先抓住学生的心,学生接受我了,自然也就接受了我的课. 课堂教学中,学生的参与十分重要.教师要特别注意引导学生积极主动参与教学过程,勇于提出问题,掌握分析问题和解决问题的方法,注重自主,探究,合作式学习,让他们在学习中学会主动发展

  • 神经是一种精神_男生QQ静态头像 神经是一种精神_男生QQ静态头像

  • 三星A8怎么设置按主屏幕键接电话 三星A8怎么设置按主屏幕键接电话

    三星A8设置按主屏幕键接电话方法.生活中我们经常能看到一些小伙伴接电话根本不用滑动屏幕来接听的,他们只需要按一下home键即可快速接听,那么他们是怎么设置的呢,下面小编就来教你们三星A8设置按主屏幕键接电话教程吧! 1)首先我们先打开[电话],然后点击右上角的[更多],打开后我们再点击[设定].(如下图) 2)接着点击[接听和结束通话],最后再将[按主屏幕键]那栏右边的椭圆往右拉打开即可.(如下图)

  • iOS8小工具功能怎么用? iOS8小工具功能怎么用?

    在iOS8中苹果终于添加了小工具功能.该功能的好处在于它支持用户在一处浏览所有他们想看的各种类型的信息,包括天气.股票.包裹配送等.iOS8通知中心中的今天标签将会显示用户安装的第三方小工具. 苹果在iOS5中就已经增加了通知中心小工具功能,但是当时并不支持第三方工具.用户在其中能见到的小工具就仅有股票和天气.iOS7中增加了更多易于访问的小工具,比如日历.提醒事项.今天和明日标签.在iOS8中通知中心的今天标签将发挥更大的作用,因为从这里用户就可以访问第三方开发者的小工具. 小工具工作方式 用

  • 苹果iPhone6实用6个拍照使用技巧 苹果iPhone6实用6个拍照使用技巧

    iphone拍照效果在不同的人手中同样的手机拍出来的照片效果是完全不一样的,这里我来为各位详细的介绍苹果iPhone6实用6个拍照使用技巧,希望例子能够对各位有帮助. ●给你设计了网格线就要用! 我们打开手机的摄像头之后,比如iPhone的摄像头,会看到有一个九宫格的网格,这些线就是辅助线.很多人都会觉得这些线很碍事,但是其实这些线能够帮助到你,分别是以下几点: 用网格线找到横评竖直 1.找到横平竖直.我们不论是拿手机还是拿相机,很多时候我们眼睛看到的会有误差,因此并不一定能够拍出横平竖直的照片

  • 在哪跌倒,未必要在哪站起来 在哪跌倒,未必要在哪站起来

    在哪跌倒,未必要在哪站起来 老同学聚会,一位许久不见的男生进门就宣布:"我换工作啦!" 这位男生是班上学习最好的几个人之一,毕业就考了公务员.那个年代的公务员还是香饽饽,想从千万人中脱颖而出,并没那么容易,所以听说他考试成功时,大家还是很羡慕的.谁知才几年,他居然就辞职了. "做得不开心吗?" "这么冲动不是你的性格啊" "咳,怎么说辞就辞,不知道多少人羡慕你吗?" 大家询问着,他耸耸肩:"太累了,官场上那些事我真的

热门推荐
  • 手机财付通怎么给手机充流量? 手机财付通怎么给手机充流量? LZ,充流量的入口是隐藏在充话费选项下面的,我来告诉你吧: 1.打开手机财付通,点击[充手机话费]; 2.点击右上角的[充流量]; 3.输入要充值的号码,选择要充值的流量面值,点击[立即充值]然后完成付款就可以了.
  • 菜鸟学用Dreamweaver MX 2004行为(10)播放声音 菜鸟学用Dreamweaver MX 2004行为(10)播放声音 本站原创内容,转载请注明出处网页教学网. 播放声音 使用"播放声音"动作来播放声音.例如,您可能要在每次鼠标指针滑过某个链接时播放一段声音效果,或在页载入时播放音乐剪辑,或者点击某个按钮播放声音等等. 注意:浏览器可能需要用某种附加的音频支持(例如音频插件)来播放声音.因此,具有不同插件的不同浏览器所播放声音的效果通常会有所不同.很难准确地预测出站点的访问者对您提供的声音感受如何. 具体操作: 插入一个按钮,选择该对象,打开"行为"面板.如选择如下按钮打开"
  • 揭秘京东APPLE WATCH V1.0设计全过程 揭秘京东APPLE WATCH V1.0设计全过程 近年来可穿戴设备渐渐进入人们的视线,京东JDC也为给用户一个完整的体验加入到了探索的队伍中来. 全新的平台 谷歌与苹果的Watch设计理念基本相同,两个平台下我们面临相同的问题.如何体现Watch平台自身重情景.极简.轻量的特点是我们设计过程中始终思考的问题. 依旧从场景出发 用户主动使用场景:Watch可移植一些手机应用的功能,帮助用户在合适的场景下使用这些功能.如:公车上想看看中午买的东西到哪儿了,人太多且手机在公文包中不便于拿出,于是抬起手腕查了一下.走在路上,忽然想起家里大米没有了,对着
  • 《战斗之心:传承》转职流程攻略 《战斗之心:传承》转职流程攻略 战斗之心传承是IOS上面一款比较经典的ARPG游戏作品,这款游戏中其实有一些比较隐藏的职业,需要通过转职来转换,可能很多玩家对转职流程不太了解,下面是详细攻略分享. 触发剧情大地图一览 忍者职业为角色达到Lv5后在大地图进入名为"???"的遭遇战触发. 转职成功的职业导师会出现在首都[市中心]的学院中. 以下职业按体重从廋到胖排序 吟游诗人 属性需求:魅力.敏捷.智慧. 女巫 属性需求:耐力.智慧. 武僧 属性需求:力量.灵巧. 战斗法师 属性需求:力量.智慧. 忍者 属性需求:技巧.
  • bong手环怎么使用? bong手环怎么使用? 刚入手了一支bong手环,官方的介绍和说明中,该款手环有独特的算法和功能,那么其中的一个功能小编拿到手环之后就赶快尝试了一下,名为起床提醒,这个功能能够通过设置闹铃帮助叫醒我们. 当然这个闹铃不会响,是佩戴在我们手上的手环发出振动,通过振动来叫醒我们,同时我们可以设置在某个时间段的第一次浅睡眠时叫醒我们,这样就保证我们的睡眠状态,那么不多说了,向上君马上分享给各位具体的操作使用方法. 绑定bong的方法 1.首先我们要在手机上绑定bongII手环,方法为:打开手机蓝牙,然后下载并打开bong软件