leetcode 93 复原ip地址

leetcode 93 复原ip地址

垃圾大爆搜。。。虽然似乎题解思路也差不多。。。但是自己代码就是垃圾。

代码：

class Solution {

    List<String> res = new ArrayList<>();
    String ip = "";
    int p = 0;

    void trackBack(int pos, String s){
        if(pos == 4 && p == s.length()){
            String tmp = new String(ip);
            res.add(tmp.substring(0, tmp.length() - 1));
        }else{
            // 假如某个选项已经不行了，那么这一层后面的所有都不选取
            boolean lock = false;
            for(int i = 1;i < 4 && i <= s.length() - p;i++){
                // 假如第一个数字是0，那么直接取0
                if(i == 1 && s.substring(p, p+1).equals("0")){
                    if(s.length() - p >= 4 - pos){
                        p += i;
                        lock = true;
                        ip += "0.";
                        trackBack(pos+1, s);
                        ip = ip.substring(0, ip.length() - i - 1);
                        p -= i;
                    }
                }else{
                    if(!lock){
                        if(s.length() - p >= 4 - pos && Integer.parseInt(s.substring(p, p+i)) <= 255){
                            ip += s.substring(p, p+i) + ".";
                            p += i;
                            trackBack(pos+1, s);
                            p -= i;
                            //System.out.println(ip);
                            ip = ip.substring(0, ip.length() - i - 1);
                        }else{
                            lock = true;
                        }
                    }
                }
            }
        }
    }

    public List<String> restoreIpAddresses(String s) {
        if(s.length() <= 12){
            trackBack(0, s);
            return res;
        }else{
            return res;
        }

    }
}

10ms 39.2MB

知识回顾：java里字符串的初始化与编译优化

String类是java中用于储存一类不可改变字符串的类，一旦该类实例化为对象，那么它的内容是不能被更改的，一旦产生了更改，就会有一个新的对象产生。

我们知道，java中的内存有堆和栈之分，从中还衍生出了常量池。

堆是java中的对象实际储存位置，对象的实体在堆中动态储存。这些对象通过new等指令建立，通过垃圾回收器来销毁。

堆的优点是需求的内存大小不必提前告诉编译器，它是运行时动态决定的。缺点就是动态存取，这样比较慢。

栈中主要存放一些基本数据类型的变量（byte，short，int，long，float，double，boolean，char）和对象的引用。

栈的优点缺点就与堆相反了，需要在编译期告诉编译器需求内存的大小并完成分配，不灵活，但是存取快，数据可共享。

字符串初始化的两种方式就体现出栈与堆的差别，以及栈数据的共享性：

public static void main(String[] args) {
        String str1 = new String("abc");
        String str2 = new String("abc");
        System.out.println(str1 == str2);
    }

输出为false

public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1 == str2);
    }

输出为true

此外，在编译期，java会对字符串的各种写法进行一些优化：

String str1 = "ABCD";
String str2 = "A" + "B" + "C" + "D";
String str3 = "AB" + "CD";
String str4 = "AB" + str1;
String str1 = new String("ABCD");

在编译期，前三个表达式被优化为相同的str1形式，并在常量池（栈）中共享内存。

后两个只有在运行时，才会在堆中动态分配，他们具有独有的内存。