第一题

方法，双指针

class Solution {
    public int maxArea(int[] height) {
        //双指针
        int l=0,r=height.length-1;//最左边，最右边
        int h=0,w=0;
        int s=0;
        while(l!=r){
            h=Math.min(height[l],height[r]);
            w=r-l;
            s=Math.max(h*w,s);
            if(h==height[l]) l++;
            else r--;
        }
        return s;
    }
}

对应力扣题目

第二题

回溯法（代码来自leecode）

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
import java.util.Stack;

public class Solution {

    public List<String> restoreIpAddresses(String s) {
        int len = s.length();
        List<String> res = new ArrayList<>();
        // 如果长度不够，不搜索
        if (len < 4 || len > 12) {
            return res;
        }
//双向链表
        Deque<String> path = new ArrayDeque<>(4);
        //成功分割次数
        int splitTimes = 0;
        //len是剩余字符串的长度
        dfs(s, len, splitTimes, 0, path, res);
        return res;
    }

    /**
     * 判断 s 的子区间 [left, right] 是否能够成为一个 ip 段
     * 判断的同时顺便把类型转了
     *
     * @param s
     * @param left
     * @param right
     * @return
     */

    private int judgeIfIpSegment(String s, int left, int right) {
        //-1代表失败
        int len = right - left + 1;
        // 大于 1 位的时候，不能以 0 开头
        if (len > 1 && s.charAt(left) == '0') {
            return -1;
        }

        // 转成 int 类型
        int res = 0;
        for (int i = left; i <= right; i++) {
            res = res * 10 + s.charAt(i) - '0';
        }

        if (res > 255) {
            return -1;
        }
        return res;
    }

    private void dfs(String s, int len, int split, int begin, Deque<String> path, List<String> res) {
        if (begin == len) {//如果待处理的begin==len说明已经遍历完了
            if (split == 4) {//遍历完乐，如果已经分割了4段了，那就OK
                res.add(String.join(".", path));//把path用.来组合
            }
            return;
        }

        // 看到剩下的不够了，就退出（剪枝），len - begin 表示剩余的还未分割的字符串的位数
        //剩下的位数要么一位，要么3位
        if (len - begin < (4 - split) || len - begin > 3 * (4 - split)) {
            return;
        }
        //试图分出新的一段
        for (int i = 0; i < 3; i++) {
            if (begin + i >= len) {
                break;
            }

            int ipSegment = judgeIfIpSegment(s, begin, begin + i);
            if (ipSegment != -1) {
                // 在判断是 ip 段的情况下，才去做截取
                path.addLast(ipSegment + "");
                dfs(s, len, split + 1, begin + i + 1, path, res);
                path.removeLast();//回溯
            }
        }
    }
}