leet-code最长公共子序列&最长非公共子序列

今天本来是要做最长非公共子序列的，很简单的一个问题；被我做着做着做成了最长公共子序列。再也不怕子序列了！

1.最长公共子序列

目前对动态规划还不是很熟悉，所以还是使用暴力破解，a和b两个字符串，按照下述方式进行操作：
1.1从a中挑出子序列，子序列长度从长到短
1.2对于每一个a中挑出的子序列，从b中挑与之长度相同的的子序列进行比较，如果相等，则为一个公共子序列；也是最长公共子序列之一
1.3综合1.2可以看出，我采用的是对两个字符串的暴力搜索

代码如下：

import java.util.HashSet;
import java.util.Scanner;


public class Sequence {

    public static void main(String[] args){
        //String s="abahjesds";
        //String a="asdsdasd";

        Scanner sc=new Scanner(System.in);
        String a=sc.nextLine();
        String s=sc.nextLine();

        int alength=a.length();
        //int flag=0;
        HashSet<String> result=new HashSet<String>();

        //以字符串a的子序列为基准，找字符串b的子序列
        for(int i=0;i<alength;i++){
            if(result.isEmpty()){
                deala(a,a.length(),i,s,result);
            }
        }   
        for(String ss:result){
            System.out.println(ss);
        }
        System.out.println(result.toString());
        sc.close();
    }

    public static void deala(String a,int length,int n,String s,HashSet<String> result){
        if(n==0){
            //System.out.println(flag);
            deals(s,s.length(),s.length()-a.length(),a,result);
        }
        else{
            int alength=a.length();
            for(int i=0;i<alength;i++){
                StringBuilder aa=new StringBuilder("");
                for(int j=0;j<alength;j++){
                    if(j!=i)aa.append(a.charAt(j));
                }
                String mid=aa.toString();
                deala(mid,mid.length(),n-1,s,result);
            }
        }
    }

    public static void deals(String s,int length,int n,String a,HashSet<String> result){
        if(n==0){
            //System.out.println(s);
            if(s.equals(a)){
                result.add(s);
            }
        }
        else{
            int slength=s.length();
            for(int j=0;j<slength;j++){
                StringBuilder ss=new StringBuilder("");
                for(int i=0;i<slength;i++){
                    if(i!=j){
                        ss.append(s.charAt(i));
                    }
                }
                //System.out.println(ss);
                String mid=ss.toString();
                deals(mid,mid.length(),n-1,a,result);
            }
        }
    }

}

解释：
我使用了两个递归算法，算法复杂度一定不过关
分别对第一个字符串和第二个字符串都进行递归调用

这里学习到的东西有：

• set和list的区别：set中没有重复元素，无序(指的是不按插入顺序)；list中可以有重复元素，有序（存放顺序即为add顺序）浅谈Java中的Set、List、Map的区别
• 递归过程中涉及到的参数传递问题，这里涉及到引用传递和值传递：在希望记录下递归过程的中状态时，我本来使用的是int
  flag，由于值传递，虽然在递归过程中找到目标子序列并标记flag了，但是在一轮递归结束后，flag还是原来的值；因此，我改用了集合，既能传入引用，也可以记录序列的内容，一举两得

2.最长非公共子序列

然而，当我很开心的看到结果后，才发现题目要的是最长非公共子序列，nothing nothing 于是去了解了题目怎么做的，很简单：
只要两个串不同，那较长的那个字符串就是我们要找的那个串啦
代码：

import java.util.Scanner;

public class Uncommon {

    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String a=sc.nextLine();
        String b=sc.nextLine();
        if(a.equals(b)){
            System.out.println(-1);
        }
        else{
            System.out.println((a.length()>b.length())?a.length():b.length());
        }
        sc.close();
    }
}