代码随想录算法训练营day28 || 93.复原IP地址 、 78.子集 、 90.子集II

93. 复原 IP 地址

该题的难点在于分割字符串以及判断字符串是否合法。由于每次分割后要加点，说以在分割后的回溯递归的值要加2

class Solution {
    List<String> coutt=new ArrayList();
    public List<String> restoreIpAddresses(String s) {
    
        backjjj(s,0,0);
        return coutt;
    }
    public void backjjj(String s,int start,int point)
    {
        if(point==3)
        {
            if(iphefa(s,start,s.length()-1))
            {
                coutt.add(s);
            }
            return;
        }
            for(int i=start;i<s.length();i++)
            {
                if(iphefa(s,start,i))
                {
                    s=s.substring(0,i+1)+"."+s.substring(i+1);
                    point++;
                    backjjj(s,i+2,point);
                    point--;
                    s=s.substring(0,i+1)+s.substring(i+2);
                }
                else
                {
                    break;
                }
            }
        
    }
    public boolean iphefa(String s,int stardnum,int end)
    {
        if(stardnum>end)
        {
            return false;
        }
        if(s.charAt(stardnum)=='0'&&stardnum!=end)
        {
            return false;
        }
        int num=0;
        for(int i=stardnum;i<=end;i++)
        {
            if(s.charAt(i)>'9'||s.charAt(i)<'0')
            {
                return false;
            }
            num=num*10+(s.charAt(i)-'0');
            if(num>255)
            {
                return false;
            }
        }
        return true;
    }
}

78. 子集

该题难点在于判断结束条件，只要内部的数组范围不大于给定数组，那就可以放入

class Solution {
    List<List<Integer>> resdu=new ArrayList();
    LinkedList<Integer> patth=new LinkedList();
    public List<List<Integer>> subsets(int[] nums) {
        ods(nums,0);
        return resdu;
    }
    public void ods(int[] nums,int index)
    {
         resdu.add(new ArrayList(patth));
        if(patth.size()>nums.length)
        {
          
            return;
        }
        for(int i=index;i<nums.length;i++)
        {
            patth.add(nums[i]);
            ods(nums,i+1);
            patth.removeLast();
        }
    }
}

90. 子集 II

该题在上一题有了去重的操作

class Solution {
    List<List<Integer>> resutt=new ArrayList();
    LinkedList<Integer> ewss=new LinkedList();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        for (int i = 0; i < nums.length; i++) {  //长度不减1，是因为要留多一个位置方便插入数
			//定义待插入的数
			int insertValue=nums[i];
			//找到待插入数的前一个数的下标
			int insertIndex=i-1;
			while (insertIndex>=0 && insertValue <nums[insertIndex]) {//拿a[i]与a[i-1]的前面数组比较
				nums[insertIndex+1]=nums[insertIndex];
				insertIndex--;
			}
			nums[insertIndex+1]=insertValue;
		}
        ndiao(nums,0);
        return resutt;

    }
    public void ndiao(int[] nums,int index)
    {
        resutt.add(new ArrayList(ewss));
        if(ewss.size()>nums.length)
        {
            return;
        }
        for(int i=index;i<nums.length;i++)
        {
            if(i>index&&nums[i]==nums[i-1])
            {
                continue;
            }
            ewss.add(nums[i]);
            ndiao(nums,i+1);
            ewss.removeLast();
        }
    }
}

总结：第一题有些难